Re: Simplified slot access in goops

["Panicz Maciej Godek" <godek.maciek@gmail.com>]

Neil wtote:
>> I think this is a nice interface; but I'm less sure about the
>> implementation.  Why do you need to use primitive-eval at all?
>>
>> Isn't CL's with-slots a bit like this?  It might help to look at how
>> that is implemented.

Well, I've been having similar doubts, so I came up with something
which turned out to be similar to CLOS's with-slots. The previous solution
indeed required primitive-eval (or something similar), because it
wasn't just a syntax transformation -- that is, it invoked the class-slots
and class-of functions

The workaround requires the user to enumerate all the slots that
he or she is going to access. I wrote two macros, so you can write
(continuing the example from the previous letter):

(with-object-slots (o a b c)
  (set! a 5)
  (set! b (* a a))
  (set! c (+ a b))
  (list a b c))
=> (2 25 30)

you don't have to use the original slot names;
you can also use the `with-object-slots' macro supplying aliases:
(with-object-slots (o (x a) (y b) (z c))
  (set! x (+ y z))
  (list x y z))
=> (55 25 30)

the only problem is that you can't mix both ways, ie.
! (with-object-slots (o a (y b)) (+ a y))
would be incorrect (it is possible to implement such a macro,
but for now this one should suffice). It's still ok to write
(with-object-slots (o (a a) (y b)) (+ a y))
=> 80

The second macro, let-slots allows to make aliases for slots of more
than one object, for instance:
(define p (make C))

(let-slots ((o a b c)
                  (p (pa a) (pb b) (pc c)))
  (set! a 5)
  (set! pa a)
  (+ pa a))

Everything should work just fine.
The implementation is based solely on R5RS macro system and the
make-procedure-with-setter, that is afaik specific to guile

Clinton wrote:
> with-slots uses symbol-macrolet[0] to bind each of the variable names to
> symbol macros within its body. I don't know of anything in Guile that is
> equivalent.

R5RS pattern language allows to create syntactic aliases for practically
any form. Some time ago I've found the following `let-alias' macro that does
just this:

(use-syntax (ice-9 syncase))

(define-syntax let-alias
  (syntax-rules ()
    ((_ ((id alias) ...) body ...)
     (let-syntax ((helper (syntax-rules ()
                            ((_ id ...) (begin body ...)))))
	(helper alias ...)))))

;; And here's the code for the aforementioned with-object-slots and let-slots:

(use-modules (oop goops))
(define slot-ref (make-procedure-with-setter slot-ref slot-set!))

(define-syntax with-object-slots (syntax-rules ()
                                  ((_ (object (alias1  slot1) ...) expr1 ...)
                                   (let-alias ((alias1 (slot-ref
object (quote slot1))) ...)
                                     expr1 ...))
                                  ((_ (object prop1 ...) expr1 ...)
                                   (let-alias ((prop1 (slot-ref object
(quote prop1))) ...)
                                     expr1 ...))))

(define-syntax let-slots (syntax-rules ()
                           ((_ () expr1 ...)
                            (begin expr1 ...))
                           ((_ (binding1 binding2 ...) expr1 ...)
                            (with-object-slots binding1
                                               (let-slots (binding2 ...)
                                                 expr1 ...)))))


It is also possible to define the `with-slots' macro exactly
as it is in CLOS (but I think let-slots is fine)

Cheers
M.