[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Tue, 15 Jul 2008 00:46:57 +0200
>> 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_.
OK, sorry, I didn't understand at first.
>>> 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:
Is local-eval much slower than the usual eval?
It is very probable that I get something wrong
right now, but according to my imagination of
a possible implementation :D of eval it could be
the same function (and the closure would
actually be implemented as a hash table or
something like that).
And eval is actually what lisp is doing all the
time, so the only thing that changes here
is the scope (=reference to a hash table)
That's how, I believe, it could be implemented.
(but I've never tried to do that nor read it in the code,
so I'm just being a smart ass)
> (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.
To me it already looks very pretty (and works just
as efficiently as my imagination of local-eval operation :>).
This might be just what I've been looking for.
Thanks a lot.
>> 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. :-)
Neither do I (I just saw a lot of code, many many layers of code
so I've concluded that it is a complex multi-layer system I don't
want to get into). I never realized that eval causes such terrible
overheads ((procedure-source eval) doesn't show any of the
mysteries of the universe :P)
Re: Closure?, Kjetil S. Matheussen, 2008/07/14
- Re: Closure?, Maciek Godek, 2008/07/14
- Message not available
- Re: Closure?, Kjetil S. Matheussen, 2008/07/14
- Re: Closure?,
Maciek Godek <=