[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Closure?

From: Kjetil S. Matheussen
Subject: Re: Closure?
Date: Mon, 14 Jul 2008 23:41:22 +0200 (CEST)

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)
=> 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

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 ()
    (hashq-set! attributes 'add (lambda (n)
                                  (set! sum (+ n sum))))

(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

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

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

reply via email to

[Prev in Thread] Current Thread [Next in Thread]