Common Lisp Object System

From Wikipedia, the free encyclopedia

The Common Lisp Object System (CLOS) is the facility for object-oriented programming which is part of ANSI Common Lisp (CL), and has been adapted into other dialects like EuLisp or Emacs Lisp^[1]. Originally proposed as an add-on, CLOS was adopted as part of the ANSI standard for CL. CLOS is a dynamic object system which differs radically from the OOP facilities found in static languages such as C++ or Java. It is inspired by earlier Lisp object systems such as MIT Flavors and Common LOOPS, although it is more general than either; this generality is the hard part, as it is easy to create a basic OO system in Lisp:

Making Lisp object oriented is easy: You can do it in two pages of code (Graham, 1994). Making object-oriented Lisp as extensible and flexible as the rest of Lisp is more difficult. Although CLOS is a complete object system, CLOS is implemented in an object-oriented fashion. The object-oriented implementation of CLOS is known as the CLOS Metaobject Protocol (or MOP) and permits the object system to be customizable and extensible.^[2]

CLOS is a multiple dispatch system. This means that methods can be specialized upon the types of all of their arguments. Most OO languages are single-dispatch, meaning that methods are only specialized on the first argument. Methods in CLOS are grouped into generic functions; a generic function is a collection of methods with the same name and argument structure, but with differently-typed arguments.

Like the OO systems in most dynamic languages (such as Python), CLOS doesn't provide encapsulation. Any data member (or slot) can be accessed using the slot-value function. CL programmers use the language's package facility to declare which functions or data structures are intended for export.

Apart from normal ("primary") methods, there also are :before, :after, and :around methods. These modify the order in which methods are executed on a derived class. An :around method can specify whether the primary method is executed at all. Additionally the programmer can adjust if all possible primary methods along the class hierarchy should be called or just the one providing the closest match.

CLOS allows multiple inheritance. When the default order in which methods are executed in multiple inheritance is not correct, the programmer may resolve the diamond inheritance problems by specifying the order of method combinations.

CLOS is dynamic, meaning that not only the contents, but also the structure of its objects can be modified at runtime. CLOS supports changing class definitions on-the-fly (even when instances of the class in question already exist) as well as changing the class membership of a given instance through the change-class operator.

CLOS is not a prototype language; classes must be defined before objects can be instantiated as a member of that class.

Outside of the ANSI standard, there is a widely implemented extension to CLOS called the MOP, or meta-object protocol. The MOP defines a standard interface to the underpinnings of the CLOS implementation, treating classes themselves as instances of metaclasses, and allows the definition of new metaclasses and the modification of basic class behavior. The flexibility of the CLOS MOP prefigures aspect-oriented programming, which was later developed by some of the same engineers, such as Gregor Kiczales.

[edit] References

^ "CLOS is a standard. Multiple vendors supply CLOS. CLOS (or parts of it) is being used to add object orientation to other Lisp dialects such as EuLisp or Emacs Lisp." pg 110 of Veitch 1998
^ pg 108 of Veitch 1998

"CommonLoops: merging Lisp and object-oriented programming", by Daniel G. Bobrow, Kenneth Kahn, Gregor Kiczales, Larry Masinter, Mark Stefik, Frank Zdybel. 1986, Portland, Oregon, United States. Pages 17 - 29 of the Conference on Object Oriented Programming Systems Languages and Applications, ISSN 0362-1340.
"A History and Description of CLOS", by Jim Veitch. Pages 107-158 of Handbook of Programming Languages, Volume IV: Functional and Logic Programming Languages, ed. Peter H. Salus. 1998 (1st edition), Macmillian Technical Publishing; ISBN 1-57870-011-6