The history of multimethods
in [Lisp]
|
From: Aemon on 15 Oct 2009 16:02 On Oct 15, 12:02 am, Pascal Costanza <p...(a)p-cos.net> wrote: > Aemon wrote: > > 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
From: Pascal Costanza on 15 Oct 2009 17:56 Aemon wrote: > On Oct 15, 12:02 am, Pascal Costanza <p...(a)p-cos.net> wrote: >> Aemon wrote: >>> 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? 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/
From: Keith H Duggar on 15 Oct 2009 22:41 On Oct 15, 4:02 pm, Aemon <aemoncan...(a)gmail.com> wrote: > On Oct 15, 12:02 am, Pascal Costanza <p...(a)p-cos.net> wrote: > > Aemon wrote: > > > 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? The relevant mathematics of heterogeneous algebras and multi- sorted algebras date back at least to the early 1970s. See for example Birkhoff and Lipson Heterogeneous Algebras Journal of Combinatorial Theory, 8:115-133, 1970 Guttag Abstract Data Types and the Development of Data Structures Communications of the ACM, 20(6):396-404, 1977 which are exactly relevant. KHD
From: Aemon on 18 Oct 2009 16:34 On Oct 15, 2:56 pm, Pascal Costanza <p...(a)p-cos.net> wrote: > Aemon wrote: > > On Oct 15, 12:02 am, Pascal Costanza <p...(a)p-cos.net> wrote: > >> Aemon wrote: > >>> 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? > > 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
From: Pascal Costanza on 19 Oct 2009 06:41 Aemon wrote: > On Oct 15, 2:56 pm, Pascal Costanza <p...(a)p-cos.net> wrote: >> Aemon wrote: >>> On Oct 15, 12:02 am, Pascal Costanza <p...(a)p-cos.net> wrote: >>>> Aemon wrote: >>>>> 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? >> 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? 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/
First
|
Prev
|
Pages: 1 2 Prev: case sensitiveness for reader/printer Next: URL to image illustrating parenthesisfobia? |