Path: utzoo!utgpu!attcan!uunet!wucs1!sbc
From: sbc@wucs1.wustl.edu (Steve B Cousins)
Newsgroups: comp.lang.lisp
Subject: Object Lisp bug or feature?
Keywords: object lisp, coral common lisp, usual-functions
Message-ID: <644@wucs1.wustl.edu>
Date: 6 Jan 89 16:48:25 GMT
Organization: Washington University, St. Louis, MO
Lines: 42

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			sbc@wucs1.WUSTL.EDU
Washington University		"Looking forward to an efficient CLOS"