From: Steve B Cousins
Subject: Object Lisp bug or feature?
Date:
Message-ID: <644@wucs1.wustl.edu>
I just ran across this interesting bug/feature in object lisp
and figured I'd throw it out for comments.
Object lisp is an object-oriented programming paradigm implemented
in Coral Lisp on the Mac (and I don't know where else) which provides
many of the standard features of other lisp object systems. One of
these is the ability to call the shadowed version of a function from
within the shadowing version. To call the next most-specific version of
a function foo from within the definition of foo, you call the function
"usual-foo" with the original arguments. At any time, I can get a
pointer to the object for whom this function is defined by calling (self).
One would think that if I print the value of (self) as the very first
thing I do inside an object function, I should see an object of the class
for which this function was defined (otherwise a different function,
specific to the class of the object being manipulated but with the same
name as this function would have been called). But try the following
code:
(defobject foo)
(defobfun (f foo) ()
(format t "I am ~a" (self)))
(defobject baz)
(setq bazer (oneof baz))
(defobject bar foo)
(defobfun (f bar) ()
(ask bazer (usual-f)))
So a bar is a foo, and a baz is something completely different. To me,
only foos and descendents of foo should ever be (self) in (f foo). But
try this now:
? (ask (oneof bar) (f))
I am #<Object #203, a BAZ>
NIL
Does this seem counter-intuitive to you, or am I just not understanding?
Steve Cousins ยทยทยท@wucs1.WUSTL.EDU
Washington University "Looking forward to an efficient CLOS"