Re: Closure?

[Kjetil S. Matheussen]

On Mon, 14 Jul 2008, Maciek Godek wrote:

> Kjetil S. Matheussen:
>
> > I think local-eval is necessary for making
> > a namespace system of the below type without having to use
> > codewalking macros to expand the bodies of functions:
> >
> > (define-namespace bank)
> > (def-bank sum 0)
> > (def-bank (add n)
> >  (set! sum (+ n sum)) ;; Note that it's enough to write "sum".
> >
> > (bank.add 50)
> > bank.sum
> > => 50
>
> This certainly looks like trashing global namespace
> (which isn't good in the long run) and doesn't allow you
> to have object handlers (like many variables referring
> to the same object) without additional quirks.

It's just an example of what local-eval can
be good for. It's an example of a _namespace
system_, and not an _OO system_.



> > But for implementing a message passing OO system,
> > it's easier to use macros and hash tables, plus
> > that it probably performs much better:
>
> Pefrorms better than local-eval or better than
> define-namespace?

It's much faster than local-eval since it's not
calling eval for each method call. The overhead of calling
a method in an OO system, based on hash tables
and macros, is basically just the time it takes looking
up the address of the function from
a hash-table. For guile, which has a large
overhead already, your program probably won't
go any slower doing this compared to calling
functions directly:


(define (make-bank sum)
  (let ((attributes (make-hash-table)))
    (define dispatcher
      (lambda (which . rest)
        (apply (hashq-ref attributes which) rest)))
    (hashq-set! attributes 'sum (lambda ()
                                  sum))
    (hashq-set! attributes 'add (lambda (n)
                                  (set! sum (+ n sum))))
    dispatcher))

(define bank (make-bank 0))
(bank 'add 2)
(bank 'sum)
=> 2


And by using some macros, you can make the syntax look
much prettier.




> > (def-class <bank>
> >   (def-var sum 0)
> >   (def-method (add n)
> >      (set! sum (+ n sum)))
> >
> > (define bank (new <bank>))
> > (-> bank add 50)
> > (-> bank sum)
> > => 50
> >
> > There's a bunch of these systems for scheme.
> > The syntax above is used from
> > http://snd.cvs.sourceforge.net/snd/cvs-snd/oo.scm?view=log
> >
> > Guile's own OO system called GOOPS is also very nice.
> > GOOPS a quite verbose but very powerful and a lot
> > more interactive. It's similar to CL's CLOS, which
> > you should look at if you are not familiar with
> > already.
>
> Well, I've read some documentation of GOOPS and then
> I took a glimpse at its source. It has at least a few
> disadvantages, for it is an object system implemented in
> scheme -- it is therefore hard to access its objects from C
> (while closures are easily accessible through
> scm_local_eval) and it probably won't run as fast as
> local-eval, at least conceptually.

local-eval is forced to interpret its argument, and is therefore, at least 
conceptually, very slow. I very much doubt GOOPS is that slow,
but I don't know how GOOPS is implemented though. :-)