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