Re: Closure?

["Kjetil S. Matheussen" <k.s.matheussen@notam02.no>]

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. :-)