The history of multimethods

Post by Aemon
...
I've already traced the idea back to OOPLSA 1986.
Flavors
http://portal.acm.org/citation.cfm?id=28697.28698

<http://www.softwarepreservation.org/projects/LISP/>

has some more references about Flavors (including one to the
A.I. Memo No. 602 of 1980).

---Vassil.

--
"Even when the muse is posting on Usenet, Alexander Sergeevich?"

Aemon

2009-10-15 05:00:04 UTC

Post by Aemon
...
I've already traced the idea back to OOPLSA 1986.
Flavors
http://portal.acm.org/citation.cfm?id=28697.28698

<http://www.softwarepreservation.org/projects/LISP/>
has some more references about Flavors (including one to the
A.I. Memo No. 602 of 1980).
---Vassil.
--
"Even when the muse is posting on Usenet, Alexander Sergeevich?"

Thanks for the link, Vassil. The memo was very interesting. In
particular, there is no mention of multimethods.
Methods are defined over a single 'flavor' (analogous to a class).

One line down on the same page: David Moon and Daniel Weinreb.
Introduction to Flavors. 1985

This seems to be largely the same text as the memo from 1980. Also
makes no mention of multimethods, sticking to
the message passing metaphor:
"When a message is sent to an object, a function therefore must be
found to
handle the message. The two data used to figure out which function to
call are
the type of the object, and the name of the message."

Rainer Joswig

2009-10-15 06:57:29 UTC

In article

Post by Aemon
I'm doing a bit of research on the history of generic functions /
multimethods / multiple dispatch systems. I was wondering if anyone
could give me pointers on good places to look.
I've already traced the idea back to OOPLSA 1986.
Flavors
http://portal.acm.org/citation.cfm?id=28697.28698
and CommonLoops
http://portal.acm.org/citation.cfm?id=28697.28700&jmp=cit&coll=GUIDE&dl=GUIDE&CFID=57779486&CFTOKEN=37115212#CIT
Did the idea originate with object systems in Lisp? And by 'the idea'
I mean, families of methods that are dispatched according to some
runtime characteristic of all the arguments.
Many thanks,
Aemon

Flavors was very early with things like multiple-inheritance and mixins. It was
a message passing OO system.

Loops at Xerox was also very early on the scene. (see the Loops Manual for its extensive
capabilities).

CommonLoops was later influenced by Loops and Flavors. Common Lisp
added Multimethods and Generic Functions.

New Flavors added 'generic functions' with single dispatch to Flavors.

CLOS combines various features of CommonLoops and New Flavors. The first CLOS
implementation was based on Xerox' 'Portable CommonLoops' (PCL) code.

--
http://lispm.dyndns.org/

Pascal Costanza

2009-10-15 07:02:32 UTC

This idea doesn't originate with Lisp, but with EL1 (which looks
somewhat like a variant of Pascal, or so).

See http://doi.acm.org/10.1145/360980.360992

Pascal

--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/

Aemon

2009-10-15 20:02:43 UTC

Post by Aemon
I'm doing a bit of research on the history of generic functions /
multimethods / multiple dispatch systems. I was wondering if anyone
could give me pointers on good places to look.
I've already traced the idea back to OOPLSA 1986.
Flavors
http://portal.acm.org/citation.cfm?id=28697.28698
and CommonLoops
http://portal.acm.org/citation.cfm?id=28697.28700&jmp=cit&coll=GUIDE&...
Did the idea originate with object systems in Lisp? And by 'the idea'
I mean, families of methods that are dispatched according to some
runtime characteristic of all the arguments.

This idea doesn't originate with Lisp, but with EL1 (which looks
somewhat like a variant of Pascal, or so).
Seehttp://doi.acm.org/10.1145/360980.360992
Pascal
--
My website:http://p-cos.net
Common Lisp Document Repository:http://cdr.eurolisp.org
Closer to MOP & ContextL:http://common-lisp.net/project/closer/

Hi Pascal,
Thanks for the link.

Are you referring to the multi-part procedure definitions that are
described?

"
operator a + b;
iff missing a A same b take macro b
iff real a take
{iff long real b take macro a + shorten b
iff integer b take macro a + shorten (float b) }
iff long real a t a k e

{iff real b take macro shorten a -4- b
iff integer b take macro a + float b}

iff integer a take
{iff real b take macro shorten (float a) + b
iff long real b take macro float a + b}
"

I agree that this fits my definition of 'the idea'. It also brings to
mind
multipart function definitions from math:

|x| = { x if x >= 0, -x if x < 0 }

But now we're getting pretty far from my intuition about 'multi-
methods'. Do you
know of another system (that predates Flavors/Loops) where some sort
of subtype
relation is used to discriminate between function clauses?

Thanks,
Aemon

Pascal Costanza

2009-10-15 21:56:52 UTC

Post by Aemon
I'm doing a bit of research on the history of generic functions /
multimethods / multiple dispatch systems. I was wondering if anyone
could give me pointers on good places to look.
I've already traced the idea back to OOPLSA 1986.
Flavors
http://portal.acm.org/citation.cfm?id=28697.28698
and CommonLoops
http://portal.acm.org/citation.cfm?id=28697.28700&jmp=cit&coll=GUIDE&...
Did the idea originate with object systems in Lisp? And by 'the idea'
I mean, families of methods that are dispatched according to some
runtime characteristic of all the arguments.

Hi Pascal,
Thanks for the link.
Are you referring to the multi-part procedure definitions that are
described?
"
operator a + b;
iff missing a A same b take macro b
iff real a take
{iff long real b take macro a + shorten b
iff integer b take macro a + shorten (float b) }
iff long real a t a k e
{iff real b take macro shorten a -4- b
iff integer b take macro a + float b}
iff integer a take
{iff real b take macro shorten (float a) + b
iff long real b take macro float a + b}
"
I agree that this fits my definition of 'the idea'. It also brings to
mind
|x| = { x if x >= 0, -x if x < 0 }
But now we're getting pretty far from my intuition about 'multi-
methods'. Do you
know of another system (that predates Flavors/Loops) where some sort
of subtype
relation is used to discriminate between function clauses?

No, I'm referring to the part that talks about 'generic operations'.

Pascal

--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/

Aemon

2009-10-18 20:34:07 UTC

Post by Aemon
I'm doing a bit of research on the history of generic functions /
multimethods / multiple dispatch systems. I was wondering if anyone
could give me pointers on good places to look.
I've already traced the idea back to OOPLSA 1986.
Flavors
http://portal.acm.org/citation.cfm?id=28697.28698
and CommonLoops
http://portal.acm.org/citation.cfm?id=28697.28700&jmp=cit&coll=GUIDE&...
Did the idea originate with object systems in Lisp? And by 'the idea'
I mean, families of methods that are dispatched according to some
runtime characteristic of all the arguments.

Hi Pascal,
Thanks for the link.
Are you referring to the multi-part procedure definitions that are
described?
"
operator a + b;
iff missing a A same b take macro b
iff real a take
{iff long real b take macro a + shorten b
iff integer b take macro a + shorten (float b) }
iff long real a t a k e
{iff real b take macro shorten a -4- b
iff integer b take macro a + float b}
iff integer a take
{iff real b take macro shorten (float a) + b
iff long real b take macro float a + b}
"
I agree that this fits my definition of 'the idea'. It also brings to
mind
|x| = { x if x >= 0, -x if x < 0 }
But now we're getting pretty far from my intuition about 'multi-
methods'. Do you
know of another system (that predates Flavors/Loops) where some sort
of subtype
relation is used to discriminate between function clauses?

No, I'm referring to the part that talks about 'generic operations'.
Pascal
--
My website:http://p-cos.net
Common Lisp Document Repository:http://cdr.eurolisp.org
Closer to MOP & ContextL:http://common-lisp.net/project/closer/

Pascal,

I don't know how I missed all of that, but 'wow'. There are
so many concepts here. The programmer defined 'generic routines' are
very much like multi-methods.

They use a 'cover' relation to decide which method to dispatch:

"In general, a mode G in a
mode set covers an argument mode A if any of the following hold:

I. G = ANY.
2. G is a united mode ONEOF(tl . . . t,,) and A = ti for some i.
3. G = A ."

Or failing, that an arbitrary predicate.

Generic type conversion,
ADTs,

Amazing. Do you know if EL1 had any direct offspring?

Many thanks,
Aemon

Pascal Costanza

2009-10-19 10:41:38 UTC

Post by Aemon
I'm doing a bit of research on the history of generic functions /
multimethods / multiple dispatch systems. I was wondering if anyone
could give me pointers on good places to look.
I've already traced the idea back to OOPLSA 1986.
Flavors
http://portal.acm.org/citation.cfm?id=28697.28698
and CommonLoops
http://portal.acm.org/citation.cfm?id=28697.28700&jmp=cit&coll=GUIDE&...
Did the idea originate with object systems in Lisp? And by 'the idea'
I mean, families of methods that are dispatched according to some
runtime characteristic of all the arguments.

Hi Pascal,
Thanks for the link.
Are you referring to the multi-part procedure definitions that are
described?
"
operator a + b;
iff missing a A same b take macro b
iff real a take
{iff long real b take macro a + shorten b
iff integer b take macro a + shorten (float b) }
iff long real a t a k e
{iff real b take macro shorten a -4- b
iff integer b take macro a + float b}
iff integer a take
{iff real b take macro shorten (float a) + b
iff long real b take macro float a + b}
"
I agree that this fits my definition of 'the idea'. It also brings to
mind
|x| = { x if x >= 0, -x if x < 0 }
But now we're getting pretty far from my intuition about 'multi-
methods'. Do you
know of another system (that predates Flavors/Loops) where some sort
of subtype
relation is used to discriminate between function clauses?

Pascal,
I don't know how I missed all of that, but 'wow'. There are
so many concepts here. The programmer defined 'generic routines' are
very much like multi-methods.
"In general, a mode G in a
I. G = ANY.
2. G is a united mode ONEOF(tl . . . t,,) and A = ti for some i.
3. G = A ."
Or failing, that an arbitrary predicate.
Generic type conversion,
ADTs,
Amazing. Do you know if EL1 had any direct offspring?

I don't know, but I'm pretty sure the LOOPS and CLOS designers knew
about it.

Pascal

--
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/

Keith H Duggar

2009-10-16 02:41:23 UTC