Home / Browse / CEDET / Mail / Archive

CEDET

Email Archive: cedet-eieio (read-only)

2001:	_Jan	_Feb	_Mar	_Apr	_May	_Jun	_Jul	_Aug (2)	_Sep (1)	_Oct	_Nov	_Dec
2002:	_Jan	_Feb	_Mar (4)	_Apr (6)	_May	_Jun	_Jul	_Aug (2)	_Sep	_Oct	_Nov (4)	_Dec (14)
2003:	_Jan (1)	_Feb (1)	_Mar	_Apr (1)	_May	_Jun	_Jul	_Aug	_Sep	_Oct	_Nov	_Dec
2005:	_Jan	_Feb	_Mar (4)	_Apr (5)	_May (3)	_Jun	_Jul (3)	_Aug	_Sep	_Oct (1)	_Nov	_Dec
2006:	_Jan (1)	_Feb	_Mar (2)	_Apr	_May	_Jun	_Jul	_Aug	_Sep	_Oct	_Nov	_Dec
2007:	_Jan	_Feb	_Mar	_Apr	_May	_Jun (12)	_Jul (4)	_Aug (1)	_Sep	_Oct	_Nov	_Dec
2009:	_Jan	_Feb (6)	_Mar (4)	_Apr	_May	_Jun	_Jul	_Aug (1)	_Sep (2)	_Oct	_Nov (2)	_Dec (7)
2010:	_Jan	_Feb	_Mar	_Apr	_May (4)	_Jun (10)	_Jul (11)	_Aug	_Sep	_Oct	_Nov	_Dec
2011:	_Jan	_Feb	_Mar	_Apr	_May	_Jun	_Jul (2)	_Aug	_Sep	_Oct	_Nov	_Dec
2012:	_Jan	_Feb	_Mar	_Apr	_May (1)	_Jun (6)	_Jul	_Aug	_Sep	_Oct (5)	_Nov	_Dec
2013:	_Jan	_Feb (23)	_Mar (2)	_Apr (1)	_May (1)	_Jun	_Jul	_Aug	_Sep	_Oct	_Nov	_Dec


S	M	T	W	T	F	S
				1	2	3
					(2)
4	5	6	7	8	9	10

11	12	13	14	15	16	17

18	19	20	21	22	23	24
(5)	(4)
25	26	27	28	29	30	31

[cedet-eieio] call-next-method invocation order

From: Frank <some.frank@gm...> - 2010-07-18 20:15

Hi there,

I'm not sure maybe there's a problem with (call-next-method)'s 
invocation order with multiple inheritance;

Check this tree out

  +--base
       +--derived1
       |    +--derived2
       |         +--derived3
       +--derivedX
            +--derived3

And here's the code for it;
Well it's kinda a complex example but the point why I bother you guys 
with it is if I run this example on Allegro CL I get a different result;
BTW if I add  :method-invocation-order :depth-first to class derived2 I 
get the same result as on Allegro CL;

As I'm not an expert in CL I'll leave it up to you guys what to do with it;

Thanks
Frank


(require 'cl)
(require 'eieio)

(defclass base ()
  ())
(defmethod func ((this base))
  (foo this))
(defmethod foo ((this base))
  (message "base::foo"))

(defclass derivedX (base)
  ())

(defclass derived1 (base)
  ())
(defmethod foo ((this derived1))
  (message "derived1::foo"))

(defclass derived2 (derived1)
  ()
;;;  :method-invocation-order :depth-first
)
(defmethod foo ((this derived2))
  (call-next-method)
  (message "derived2::foo"))

(defclass derived3 (derived2 derivedX)
  ())

(setq td1 (make-instance 'derived2))
(func td1) ;; Results in:
          ;; derived1::foo
          ;; derived2::foo

;;XXX shouldn't the result be the same as in the former example?
;;XXX on Allegro CL the result is the same as for td1
(setq td2 (make-instance 'derived3))
(func td2) ;; Results in:
          ;; base::foo
          ;; derived2::foo

Re: [cedet-eieio] call-next-method invocation order

From: Jan Moringen <jan.moringen@un...> - 2010-07-19 01:07

Hi Frank.

> I'm not sure maybe there's a problem with (call-next-method)'s 
> invocation order with multiple inheritance;
> 
> Check this tree out
> 
>   +--base
>        +--derived1
>        |    +--derived2
>        |         +--derived3
>        +--derivedX
>             +--derived3
> 
> And here's the code for it;
> Well it's kinda a complex example but the point why I bother you guys 
> with it is if I run this example on Allegro CL I get a different result;
> BTW if I add  :method-invocation-order :depth-first to class derived2 I 
> get the same result as on Allegro CL;

EIEIO has three linearization methods: depth-first, breadth-first and c3
(see [1]). The default is breadth-first search which can reach base
before derived1, as your td2 example shows, since paths from derived3
have length 2 in both cases. The method used in CLOS (and therefore
probably in Allegro CL) is different from all three and also described
in [1].

In many cases, even complex hierarchies, the c3 linearization mentioned
in [1] does the right thing. Your example should work with c3
linearization. It can be used in EIEIO
with :method-invocation-order :c3.

> As I'm not an expert in CL I'll leave it up to you guys what to do with it;

Maybe the documentation can be improved.

Kind regards,
Jan

[1] http://192.220.96.201/dylan/linearization-oopsla96.html

Re: [cedet-eieio] call-next-method invocation order

From: Eric M. Ludlam <eric@si...> - 2010-07-19 02:15

On 07/18/2010 07:16 PM, Jan Moringen wrote:
>> Well it's kinda a complex example but the point why I bother you guys
>> with it is if I run this example on Allegro CL I get a different result;
>> BTW if I add  :method-invocation-order :depth-first to class derived2 I
>> get the same result as on Allegro CL;
>
> EIEIO has three linearization methods: depth-first, breadth-first and c3
> (see [1]). The default is breadth-first search which can reach base
> before derived1, as your td2 example shows, since paths from derived3
> have length 2 in both cases. The method used in CLOS (and therefore
> probably in Allegro CL) is different from all three and also described
> in [1].
>
> In many cases, even complex hierarchies, the c3 linearization mentioned
> in [1] does the right thing. Your example should work with c3
> linearization. It can be used in EIEIO
> with :method-invocation-order :c3.
>
>> As I'm not an expert in CL I'll leave it up to you guys what to do with it;
>
> Maybe the documentation can be improved.

I was re-writing bits of the doc today based on the first question when 
I noticed that :c3 wasn't there.  Then I noticed the doc didn't say what 
the default was.

So I tried making :c3 the default (thus solving some of these issues 
from happening by default) and found that CEDET didn't build properly. 
(Complaints of malformed hierarchies.)

Things then stalled for me and I didn't have time to finish.  If this is 
going to be a common issue, I'd like to try and get this new mechanism 
in as the default, but it may take a while.

Eric

Re: [cedet-eieio] call-next-method invocation order

From: Frank <some.frank@gm...> - 2010-07-19 03:13

Eric M. Ludlam schrieb:

> On 07/18/2010 07:16 PM, Jan Moringen wrote:
>
>>> Well it's kinda a complex example but the point why I bother you guys
>>> with it is if I run this example on Allegro CL I get a different 
>>> result;
>>> BTW if I add  :method-invocation-order :depth-first to class derived2 I
>>> get the same result as on Allegro CL;
>>
>>
>> EIEIO has three linearization methods: depth-first, breadth-first and c3
>> (see [1]). The default is breadth-first search which can reach base
>> before derived1, as your td2 example shows, since paths from derived3
>> have length 2 in both cases. The method used in CLOS (and therefore
>> probably in Allegro CL) is different from all three and also described
>> in [1].
>>
>> In many cases, even complex hierarchies, the c3 linearization mentioned
>> in [1] does the right thing. Your example should work with c3
>> linearization. It can be used in EIEIO
>> with :method-invocation-order :c3.
>>
>>> As I'm not an expert in CL I'll leave it up to you guys what to do 
>>> with it;
>>
>>
>> Maybe the documentation can be improved.
>
>
> I was re-writing bits of the doc today based on the first question 
> when I noticed that :c3 wasn't there.  Then I noticed the doc didn't 
> say what the default was.
>
> So I tried making :c3 the default (thus solving some of these issues 
> from happening by default) and found that CEDET didn't build properly. 
> (Complaints of malformed hierarchies.)
>
> Things then stalled for me and I didn't have time to finish.  If this 
> is going to be a common issue, I'd like to try and get this new 
> mechanism in as the default, but it may take a while.
>
> Eric

Fair enough!!
BTW c3 doesn't seem to be available in emacs 23.2.1

Well I still puzzle how to apply the class option 
:method-invocation-order properly.

(1) Does it have to be defined for all classes in a tree;

(2) or to the base class and the specified invocation order is then 
effective for all child classes which inherit from it

(3) or to the some class and if an object of this class is created then 
the specified invocation order is effective as specified by this class?

Thanks
Frank

Re: [cedet-eieio] call-next-method invocation order

From: Jan Moringen <jan.moringen@un...> - 2010-07-19 04:56

Hi Frank.

> Fair enough!!
> BTW c3 doesn't seem to be available in emacs 23.2.1

If you just wish to experiment, you could download eieio.el of the CEDET
CVS version and load it into your current session.

> Well I still puzzle how to apply the class option 
> :method-invocation-order properly.
> 
> (1) Does it have to be defined for all classes in a tree;
> 
> (2) or to the base class and the specified invocation order is then 
> effective for all child classes which inherit from it
> 
> (3) or to the some class and if an object of this class is created then 
> the specified invocation order is effective as specified by this class?

The method invocation order is determined by the class precedence list.
When computing the class precedence list, the "starting point" class of
the search process determines how the search process is carried out. In
the context of invoking methods, the most specific class would be the
"starting point".

For MOP-based systems (unlike EIEIO) this means that the
class-precedence-list method of the "starting point" class is called. In
this case, that method (I make a slight simplification here) decides how
the class precedence list is computed.

In EIEIO, the class precedence list is also present and is computed
based on the method-invocation-order of the "starting point" class. It
is used in method invocation, together with other mechanisms. As a
consequence of these other mechanisms, the method-invocation-orders of
superclasses of the "starting point" class can influence method
invocation. This behavior is not optimal (that's my impression), but it
would required *a lot* of work to change it.

Conclusion: In principle, only the "starting point" class matters. In
today's EIEIO, superclasses may matter as well.

Kind regards,
Jan

[cedet-eieio] :method-invocation-order :depth-first

From: Frank <some.frank@gm...> - 2010-07-18 08:25

Hi,

Is the :method-invocation-order :depth-first a common lisp feature?

Just curious as I'd like to know how portable this feature is;

Thanks
Frank

Re: [cedet-eieio] :method-invocation-order :depth-first

From: Eric M. Ludlam <eric@si...> - 2010-07-18 11:39

On 07/18/2010 04:25 AM, Frank wrote:
> Hi,
>
> Is the :method-invocation-order :depth-first a common lisp feature?
>
> Just curious as I'd like to know how portable this feature is;

I made up the :method-invocation-order flag.  The original order turned 
out to be broken for multiple inheritance, but some programs depended on 
it.  As such, I added this option when I changed the invocation order to 
something that made more sense in that case.  Later it was convenient in 
that Jan Moringen was able to add another invocation order that is even 
better.

Eric

Re: [cedet-eieio] :method-invocation-order :depth-first

From: Jan Moringen <jan.moringen@un...> - 2010-07-18 13:46

Hi Frank.

> Is the :method-invocation-order :depth-first a common lisp feature?

There is no equivalent feature in Common Lisp. However, many modern CLOS
implementations in various Common Lisps are based on a Meta Object
Protocol [1]. This is a much more powerful mechanism to change the
behavior of the object system. For the method invocation order, which is
derived from the class precedence list (also in EIEIO), one would create
a new class meta object (the class of class objects) and write a custom
method that computes the class precedence list differently.

> Just curious as I'd like to know how portable this feature is;

As Eric explained, the :method-invocation-order option is specific to
EIEIO. The MOP is not part of Common Lisp, so it can be considered
non-standard as well. In practice however, Common Lisp programs using
the MOP can be written to be rather portable.

Kind regards,
Jan

[1] http://en.wikipedia.org/wiki/AMOP

Re: [cedet-eieio] :method-invocation-order :depth-first

From: Frank <some.frank@gm...> - 2010-07-18 22:19

Eric M. Ludlam schrieb:

> On 07/18/2010 04:25 AM, Frank wrote:
>
>> Hi,
>>
>> Is the :method-invocation-order :depth-first a common lisp feature?
>>
>> Just curious as I'd like to know how portable this feature is;
>
>
> I made up the :method-invocation-order flag.  The original order 
> turned out to be broken for multiple inheritance, but some programs 
> depended on it.  As such, I added this option when I changed the 
> invocation order to something that made more sense in that case.  
> Later it was convenient in that Jan Moringen was able to add another 
> invocation order that is even better.
>
> Eric
>
So the `depth-first' order is ment to implement the CL standard behaviour?
How exactly do I have to apply this class option? Do I have to add it to 
every class in my class tree or like just to the base class?

Thanks
Frank

[cedet-eieio] compiling error

From: Frank <some.frank@gm...> - 2010-07-02 08:14

Hello,

I tried to byte-compile-file this

(require 'eieio)

(defclass foo ()
  ())

(defmethod bar ((this foo))
  )


and I get this error

`eieio.el:8:1:Error: Symbol's value as variable is void: filename'

How can I get it to compile my file?

Thanks
Frank

Re: [cedet-eieio] compiling error

From: Eric M. Ludlam <eric@si...> - 2010-07-02 11:40

On 07/02/2010 04:14 AM, Frank wrote:
> (require 'eieio)
>
> (defclass foo ()
>    ())
>
> (defmethod bar ((this foo))
>    )

Hi,

This byte compiles for me fine with CEDET/CVS.  The last set of changes 
I made were related to :initform, and I don't think filenames were involved.

I'm not sure how to get stacks out of the byte compiler.

The only place filename shows up in an odd way is when 
byte-compile-verbose is true.  Perhaps you can turn that off?  In that 
case, I suspect you have some newer versions of Emacs that may have 
eliminated that variable?

Eric