Next: , Previous: , Up: Data Structures   [Contents][Index]

7.1.13 Macroless Object System

(require 'object)

This is the Macroless Object System written by Wade Humeniuk ( Conceptual Tributes: Yasos, MacScheme’s %object, CLOS, Lack of R4RS macros.

7.1.14 Concepts


An object is an ordered association-list (by eq?) of methods (procedures). Methods can be added (make-method!), deleted (unmake-method!) and retrieved (get-method). Objects may inherit methods from other objects. The object binds to the environment it was created in, allowing closures to be used to hide private procedures and data.


A generic-method associates (in terms of eq?) object’s method. This allows scheme function style to be used for objects. The calling scheme for using a generic method is (generic-method object param1 param2 ...).


A method is a procedure that exists in the object. To use a method get-method must be called to look-up the method. Generic methods implement the get-method functionality. Methods may be added to an object associated with any scheme obj in terms of eq?


A generic method that returns a boolean value for any scheme obj.


A object’s method asscociated with a generic-predicate. Returns #t.

7.1.15 Procedures

Function: make-object ancestor …

Returns an object. Current object implementation is a tagged vector. ancestors are optional and must be objects in terms of object?. ancestors methods are included in the object. Multiple ancestors might associate the same generic-method with a method. In this case the method of the ancestor first appearing in the list is the one returned by get-method.

Function: object? obj

Returns boolean value whether obj was created by make-object.

Function: make-generic-method exception-procedure

Returns a procedure which be associated with an object’s methods. If exception-procedure is specified then it is used to process non-objects.

Function: make-generic-predicate

Returns a boolean procedure for any scheme object.

Function: make-method! object generic-method method

Associates method to the generic-method in the object. The method overrides any previous association with the generic-method within the object. Using unmake-method! will restore the object’s previous association with the generic-method. method must be a procedure.

Function: make-predicate! object generic-preciate

Makes a predicate method associated with the generic-predicate.

Function: unmake-method! object generic-method

Removes an object’s association with a generic-method .

Function: get-method object generic-method

Returns the object’s method associated (if any) with the generic-method. If no associated method exists an error is flagged.

7.1.16 Examples

(require 'object)

(define instantiate (make-generic-method))

(define (make-instance-object . ancestors)
  (define self (apply make-object
                      (map (lambda (obj) (instantiate obj)) ancestors)))
  (make-method! self instantiate (lambda (self) self))

(define who (make-generic-method))
(define imigrate! (make-generic-method))
(define emigrate! (make-generic-method))
(define describe (make-generic-method))
(define name (make-generic-method))
(define address (make-generic-method))
(define members (make-generic-method))

(define society
  (let ()
    (define self (make-instance-object))
    (define population '())
    (make-method! self imigrate!
                  (lambda (new-person)
                    (if (not (eq? new-person self))
                        (set! population (cons new-person population)))))
    (make-method! self emigrate!
                  (lambda (person)
                    (if (not (eq? person self))
                        (set! population
                              (comlist:remove-if (lambda (member)
                                                   (eq? member person))
    (make-method! self describe
                  (lambda (self)
                    (map (lambda (person) (describe person)) population)))
    (make-method! self who
                  (lambda (self) (map (lambda (person) (name person))
    (make-method! self members (lambda (self) population))

(define (make-person %name %address)
  (define self (make-instance-object society))
  (make-method! self name (lambda (self) %name))
  (make-method! self address (lambda (self) %address))
  (make-method! self who (lambda (self) (name self)))
  (make-method! self instantiate
                (lambda (self)
                  (make-person (string-append (name self) "-son-of")
  (make-method! self describe
                (lambda (self) (list (name self) (address self))))
  (imigrate! self)
  self) Inverter Documentation


        <inverter>::(<number> <description>)


        <inverter>::value      ⇒ <number>::value
        <inverter>::set-value! ⇒ <number>::set-value!
        <inverter>::describe   ⇒ <description>::describe
        <inverter>::inverter? Number Documention





Generic Methods

        <number>::set-value! Inverter code

(require 'object)

(define value (make-generic-method (lambda (val) val)))
(define set-value! (make-generic-method))
(define invert (make-generic-method
                (lambda (val)
                  (if (number? val)
                      (/ 1 val)
                      (error "Method not supported:" val)))))
(define noop (make-generic-method))
(define inverter? (make-generic-predicate))
(define describe (make-generic-method))
(define help (make-generic-method))

(define (make-number x)
  (define self (make-object))
  (make-method! self value (lambda (this) x))
  (make-method! self set-value!
                (lambda (this new-value) (set! x new-value)))

(define (make-description str)
  (define self (make-object))
  (make-method! self describe (lambda (this) str))
  (make-method! self help (lambda (this) "Help not available"))

(define (make-inverter)
  (let* ((self (make-object
                (make-number 1)
                (make-description "A number which can be inverted")))
         (<value> (get-method self value)))
    (make-method! self invert (lambda (self) (/ 1 (<value> self))))
    (make-predicate! self inverter?)
    (unmake-method! self help)
    (make-method! self help
                  (lambda (self)
                    (display "Inverter Methods:") (newline)
                    (display "  (value inverter) ==> n") (newline)))

;;;; Try it out

(define invert! (make-generic-method))

(define x (make-inverter))

(make-method! x invert! (lambda (x) (set-value! x (/ 1 (value x)))))

(value x)                       ⇒ 1
(set-value! x 33)               ⇒ undefined
(invert! x)                     ⇒ undefined
(value x)                       ⇒ 1/33

(unmake-method! x invert!)      ⇒ undefined

(invert! x)                     error→  ERROR: Method not supported: x

Next: , Previous: , Up: Data Structures   [Contents][Index]