Object-Oriented Multi-Methods in Cecil

Multiple dispatching provides increased expressive power over single dispatching by guiding method lookup using the values of all arguments instead of only the receiver. However, existing languages with multiple dispatching do not encourage the data-abstraction-oriented programming style that is encouraged by traditional single-dispatching languages; instead existing multiple-dispatching languages tend to foster a function-oriented programming style organized around generic functions. We propose an alternative view of multiple dispatching that is intended to promote a data-abstraction-oriented programming style. Instead of viewing a multi-method as “outside” of all objects, we view a multi-method as “inside” the objects for which the multi-method applies (on which it dispatches). Because objects are closely connected to the multi-methods implementing their operations, the internals of an object can be encapsulated by being accessible only to the closely-connected multi-methods. We are exploring this object-oriented view of multi-methods in the context of a new programming language named Cecil.

[1]  Craig Schaffert,et al.  An introduction to Trellis/Owl , 1986, OOPLSA '86.

[2]  Alan Borning,et al.  Classes versus Prototypes in Object-Oriented Languages , 1986, FJCC.

[3]  Wilf R. LaLonde,et al.  An exemplar based Smalltalk , 1986, OOPLSA '86.

[4]  William R. Cook,et al.  Inheritance is not subtyping , 1989, POPL '90.

[5]  François Rouaix,et al.  Safe run-time overloading , 1989, POPL '90.

[6]  R. E. Johnson,et al.  Arithmetic and double dispatching in Smalltalk , 1990 .

[7]  Bertrand Meyer,et al.  Eiffel: The Language , 1991 .

[8]  WadlerPhilip,et al.  Report on the programming language Haskell , 1992 .

[9]  Daniel H. H. Ingalls A Simple Technique for Handling Multiple Polymorphism , 1986, OOPSLA.

[10]  Craig Chambers,et al.  An efficient implementation of SELF, a dynamically-typed object-oriented language based on prototypes , 1989, OOPSLA '89.

[11]  Craig Chambers,et al.  The design and implementation of the self compiler, an optimizing compiler for object-oriented programming languages , 1992 .

[12]  Craig Chambers,et al.  Debugging optimized code with dynamic deoptimization , 1992, PLDI '92.

[13]  Daniel C. Halbert,et al.  Using Types and Inheritance in Object-Oriented Languages , 1987, ECOOP.

[14]  Simon L. Peyton Jones,et al.  Report on the programming language Haskell: a non-strict, purely functional language version 1.2 , 1992, SIGP.

[15]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[16]  David A. Moon,et al.  Object-oriented programming with flavors , 1986, OOPLSA '86.

[17]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[18]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[19]  Craig Chambers,et al.  Parents are shared parts of objects: Inheritance and encapsulation in SELF , 1991, LISP Symb. Comput..

[20]  Bjarne Stroustrup,et al.  The Annotated C++ Reference Manual , 1990 .

[21]  Bruce G. Lindsay,et al.  Static type checking of multi-methods , 1991, OOPSLA '91.

[22]  Randall B. Smith,et al.  SELF: The power of simplicity , 1987, OOPSLA '87.

[23]  Randall B. Smith,et al.  Self: The power of simplicity , 1987, OOPSLA 1987.

[24]  Daniel G. Bobrow,et al.  Common lisp object system specification , 1988, SIGP.

[25]  William D. Clinger,et al.  Revised3 report on the algorithmic language scheme , 1986, SIGP.

[26]  Todd Leavens Gary Verifying object-oriented programs that use subtypes , 1989 .

[27]  John G. Hosking,et al.  Multi-Methods in a Statically-Typed Programming Language , 1991, ECOOP.

[28]  Verzekeren Naar Sparen,et al.  Cambridge , 1969, Humphrey Burton: In My Own Time.

[29]  Daniel G. Bobrow,et al.  CLOS: integrating object-oriented and functional programming , 1991, CACM.

[30]  Henry Lieberman,et al.  Treaty of Orlando , 1988, OOPSLA 1988.

[31]  Harold Ossher,et al.  Subdivided procedures: a language extension supporting extensible programming , 1990, Proceedings. 1990 International Conference on Computer Languages.

[32]  Gary T. Leavens,et al.  Reasoning about object-oriented programs that use subtypes , 1990, OOPSLA/ECOOP '90.

[33]  Henry Lieberman,et al.  Using prototypical objects to implement shared behavior in object-oriented systems , 1986, OOPLSA '86.

[34]  Daniel H. H. Ingalls A simple technique for handling multiple polymorphism , 1986, OOPSLA 1986.

[35]  Craig Chambers,et al.  Making pure object-oriented languages practical , 1991, OOPSLA '91.

[36]  L. Stein,et al.  Treaty of Orlando , 1987, OOPSLA '87.

[37]  Daniel G. Bobrow,et al.  CommonLoops: merging Lisp and object-oriented programming , 1986, OOPLSA '86.

[38]  Craig Chambers,et al.  An efficient implementation of SELF a dynamically-typed object-oriented language based on prototypes , 1989, OOPSLA 1989.

[39]  Adele Goldberg,et al.  Smalltalk-80 - the interactive programming environment , 1984 .

[40]  Alan Snyder Encapsulation and inheritance in object-oriented programming languages , 1986, OOPSLA 1986.

[41]  Craig Chambers,et al.  Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches , 1991, ECOOP.

[42]  Craig Chambers,et al.  Organizing programs without classes , 1991, LISP Symb. Comput..