Abordnet

Robert Kiendl < This e-mail address is being protected from spam bots, you need JavaScript enabled to view it writes: < - i can shoot down a bird somewhere in the code in a consistent manner. <   [ <     thats why i asked in the last mail for a _kill_ for lisp things and for <     that back_link_s in the GC-mechanism <     i think the back_link_s exist at least in case of that weak stuff? <   ] <   [ this is not done by (defvar *thing* this is a thing ) <        (setq *thing* nil) <     like someone mentioned; that doesn't kill the thing but the reference. <     its of course also not automated to do delete in the shoot-func, <     i am not willing to automate a thing i intentionally want to rise. <     a future AI program may be able to automate this but not this simple <     code. what's automated is what happens in response to delete bird: <   ] I don't understand C++, so I don't know what your code does, but I think I understand what you're trying to say. What I was trying to demonstrate was that lisp provides no explicit, automatic pointer manipulation; they're just handled automatically. Perhaps this is more along the lines of what you're looking for? (defclass _object_ () ()) (defclass killed-_object_ (_object_) ()) (defclass active-_object_ (_object_) ()) (defmethod kill-_object_ ((_object_ _object_))   (change-class _object_ 'killed-_object_)) (defvar *_object_-x* (make-instance 'active-_object_)) (defvar *_object_s* (vector *_object_-x* *_object_-x*)) (defvar *_object_-x-ref* *_object_-x*) *_object_-x*     = #<ACTIVE-_object_ @ #x204f076a *_object_s*      = #(#1=#<ACTIVE-_object_ @ #x204f076a #1#) *_object_-x-ref* = #<ACTIVE-_object_ @ #x204f076a (kill-_object_ *_object_-x*) = #<KILLED-_object_ @ #x204f076a *_object_-x*     = #<KILLED-_object_ @ #x204f076a *_object_s*      = #(#1=#<KILLED-_object_ @ #x204f076a #1#) *_object_-x-ref* = #<KILLED-_object_ @ #x204f076a The _object_ has been killed. All references to the killed _object_ refer to the killed _object_. You could of course define a method called delete on `_object_' if it suits your needs better.

i hope it is not too boring for you all but my problems representing some structures in lisp are still pending. (maybe i should read more books, but if one puts my nose on the right point ...) Well, I will suggest two solutions, both of which you invite! First, more books : The Art of the _meta__object_ Protocol, ISBN 0-262-61074-4. That and a Lisp that fully supports the _meta__object_ Protocol will get you going. And, FWIW, I rolled something of my own under a Lisp that did not have such full MOP support and it would achieve the same...Lisp can do anything. With AMOP you can cook up slots that register themselves as interested parties of cooperating slot-values, then write a function called #'c++-delete to notify them when you want something to be forgtten. Second, may be someone lateron tells me how to completely rearrange that whole... Hello! It strikes me you are mixing inappropriately wildly different levels of _expression_. Specifically, you think the C++ 'delete' operator is a way to kill a virtual bird. No way! But C/C++ are so close to the hardware

I didn't really understand the C++ stuff in this thread (it's over 10 years since I did anything with C++ other than stare horrified at it).  However I was inspired to try and see if I understood what was going on, as some of it seems to be reasonably close to things I already have. Unfortunately the code I actually use is not releasable