Common Lisp Object System - Revision history

imported>Nick Levine: /* Literature */ definitely not a link to the correct Nick Levine

2025-12-18T08:34:29Z

Literature: definitely not a link to the correct Nick Levine

← Previous revision		Revision as of 08:34, 18 December 2025
Line 97:		Line 97:
	* [[Andreas Paepcke]], ''[[Object-Oriented Programming: the CLOS Perspective]]'', 1993, The MIT Press. {{ISBN\|0-262-16136-2}}		* [[Andreas Paepcke]], ''[[Object-Oriented Programming: the CLOS Perspective]]'', 1993, The MIT Press. {{ISBN\|0-262-16136-2}}
	* [http://www.dreamsongs.com/Files/ECOOP.pdf The Common Lisp Object System: An Overview] by [[Richard P. Gabriel]] and [[Linda DeMichiel]] provides a good introduction to the motivation for defining classes by means of generic functions.		* [http://www.dreamsongs.com/Files/ECOOP.pdf The Common Lisp Object System: An Overview] by [[Richard P. Gabriel]] and [[Linda DeMichiel]] provides a good introduction to the motivation for defining classes by means of generic functions.
	* [https://cl-cookbook.sourceforge.net/clos-tutorial/ Fundamentals of CLOS] by [[Nick Levine]] provides a step-by-step exposure to the implementation of OO concepts in CLOS, and how to utilize them. It is intended for anybody with a basic knowledge of Lisp or Scheme.		* [https://cl-cookbook.sourceforge.net/clos-tutorial/ Fundamentals of CLOS] by Nick Levine provides a step-by-step exposure to the implementation of OO concepts in CLOS, and how to utilize them. It is intended for anybody with a basic knowledge of Lisp or Scheme.
	* ''[[Common Lisp HyperSpec]]'', [http://www.lispworks.com/documentation/HyperSpec/Body/07_.htm Chapter 7: ''Objects'']		* ''[[Common Lisp HyperSpec]]'', [http://www.lispworks.com/documentation/HyperSpec/Body/07_.htm Chapter 7: ''Objects'']

imported>TarnishedPath: Per page move: Changed link from Class (computer programming) to Class (programming) using MovePlus

2025-10-17T08:46:30Z

Per page move: Changed link from Class (computer programming) to Class (programming) using MovePlus

← Previous revision		Revision as of 08:46, 17 October 2025
Line 5:		Line 5:

	== Features ==		== Features ==
	The basic building blocks of CLOS are [[method (computer programming)\|method]]s, [[Class (~~computer~~ programming)\|class]]es, instances of those classes, and [[generic function]]s.		The basic building blocks of CLOS are [[method (computer programming)\|method]]s, [[Class (programming)\|class]]es, instances of those classes, and [[generic function]]s.
	CLOS provides macros to define those: <code>defclass</code>, <code>defmethod</code>, and <code>defgeneric</code>. Instances are created with the method <code>make-instance</code>.		CLOS provides macros to define those: <code>defclass</code>, <code>defmethod</code>, and <code>defgeneric</code>. Instances are created with the method <code>make-instance</code>.

Line 97:		Line 97:
	* [[Andreas Paepcke]], ''[[Object-Oriented Programming: the CLOS Perspective]]'', 1993, The MIT Press. {{ISBN\|0-262-16136-2}}		* [[Andreas Paepcke]], ''[[Object-Oriented Programming: the CLOS Perspective]]'', 1993, The MIT Press. {{ISBN\|0-262-16136-2}}
	* [http://www.dreamsongs.com/Files/ECOOP.pdf The Common Lisp Object System: An Overview] by [[Richard P. Gabriel]] and [[Linda DeMichiel]] provides a good introduction to the motivation for defining classes by means of generic functions.		* [http://www.dreamsongs.com/Files/ECOOP.pdf The Common Lisp Object System: An Overview] by [[Richard P. Gabriel]] and [[Linda DeMichiel]] provides a good introduction to the motivation for defining classes by means of generic functions.
	* [~~http~~://cl-cookbook.sourceforge.net/clos-tutorial/ Fundamentals of CLOS] by [[Nick Levine]] provides a step-by-step exposure to the implementation of OO concepts in CLOS, and how to utilize them. It is intended for anybody with a basic knowledge of Lisp or Scheme.		* [https://cl-cookbook.sourceforge.net/clos-tutorial/ Fundamentals of CLOS] by [[Nick Levine]] provides a step-by-step exposure to the implementation of OO concepts in CLOS, and how to utilize them. It is intended for anybody with a basic knowledge of Lisp or Scheme.
	* ''[[Common Lisp HyperSpec]]'', [http://www.lispworks.com/documentation/HyperSpec/Body/07_.htm Chapter 7: ''Objects'']		* ''[[Common Lisp HyperSpec]]'', [http://www.lispworks.com/documentation/HyperSpec/Body/07_.htm Chapter 7: ''Objects'']

imported>TheAwesomeHwyh: /* CLOS in other programming languages */ missed two, whoops

2025-06-27T19:48:09Z

CLOS in other programming languages: missed two, whoops

← Previous revision		Revision as of 19:48, 27 June 2025
Line 2:		Line 2:
	{{Other uses\|Clos (disambiguation)}}		{{Other uses\|Clos (disambiguation)}}
	[[File:Method-combination.png\|thumb\|right\|Standard method combination in ANSI common lisp]]		[[File:Method-combination.png\|thumb\|right\|Standard method combination in ANSI common lisp]]
	The '''Common Lisp Object System (CLOS)''' is the facility for [[object-oriented programming]] in [[American National Standards Institute\|ANSI]] [[Common Lisp]]. CLOS is a ~~powerful~~ [[dynamic programming language\|dynamic]] object system which differs radically from the OOP facilities found in more [[static language]]s such as [[C++]] or [[Java (programming language)\|Java]]. CLOS was inspired by earlier Lisp object systems such as [[Flavors (computer science)\|MIT Flavors]] and [[CommonLoops]], although it is more general than either. Originally proposed as an add-on, CLOS was adopted as part of the ANSI standard for Common Lisp and has been adapted into other Lisp dialects such as [[EuLisp]] or [[Emacs Lisp]].<ref>"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." p. 110 of Veitch 1998</ref>		The '''Common Lisp Object System (CLOS)''' is the facility for [[object-oriented programming]] in [[American National Standards Institute\|ANSI]] [[Common Lisp]]. CLOS is a [[dynamic programming language\|dynamic]] object system which differs radically from the OOP facilities found in more [[static language]]s such as [[C++]] or [[Java (programming language)\|Java]]. CLOS was inspired by earlier Lisp object systems such as [[Flavors (computer science)\|MIT Flavors]] and [[CommonLoops]], although it is more general than either. Originally proposed as an add-on, CLOS was adopted as part of the ANSI standard for Common Lisp and has been adapted into other Lisp dialects such as [[EuLisp]] or [[Emacs Lisp]].<ref>"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." p. 110 of Veitch 1998</ref>

	== Features ==		== Features ==
Line 69:		Line 69:
	* [[Dylan (programming language)\|Dylan]]		* [[Dylan (programming language)\|Dylan]]
	* Dynace, a (largely) CLOS implementation in C<ref>[https://github.com/blakemcbride/Dynace Dynace Object Oriented Extension To C]</ref>		* Dynace, a (largely) CLOS implementation in C<ref>[https://github.com/blakemcbride/Dynace Dynace Object Oriented Extension To C]</ref>
	* ~~[https://www.gnu.org/software/emacs/manual/html_mono/eieio.html~~ EIEIO] for Emacs Lisp		* EIEIO for Emacs Lisp
	* ~~[http://practical-scheme.net/gauche/~~ Gauche], Scheme with CLOS		* Gauche, Scheme with CLOS
	* ~~[https://www.gnu.org/software/guile/manual/html_node/~~GOOPS~~.html#GOOPS GOOPS]~~ in [[GNU Guile]]		* GOOPS in [[GNU Guile]]
	* ILOS in [[ISLISP]]		* ILOS in [[ISLISP]]
	* ~~[https://pages.lip6.fr/Christian.Queinnec/WWW/~~Meroon~~.html Meroon]~~, an Object System in Scheme		* Meroon, an Object System in Scheme
	* ~~[https://ktakashi.github.io/sagittarius-ref.html~~ Sagittarius], a Scheme with CLOS		* Sagittarius, a Scheme with CLOS
	* ~~[http://www.ccs.neu.edu/home/dorai/scmobj/scmobj.html~~ ScmObj], for Scheme		* ScmObj, for Scheme
	* ~~[https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-sos/~~ SOS] for MIT Scheme		* SOS for MIT Scheme
	* ~~[http://www.stklos.net~~ STklos], a Scheme with CLOS		* STklos, a Scheme with CLOS
	* ~~[http://docs.racket-lang.org/swindle/~~ Swindle] in Racket		* Swindle in Racket
	* ~~[http://wiki.call-cc.org/eggref/4/coops~~ COOPS] in Chicken Scheme		* COOPS in Chicken Scheme
	* VCLOS for [[Cadence SKILL\|Skill]]<ref>{{cite journal \|last1=Newton \|first1=Jim \|last2=Rhodes \|first2=Christophe \|date=2008-11-28 \|df=dmy \|title=Custom Specializers in Object-Oriented Lisp \|work=[[Journal of Universal Computer Science]] \|volume=14 \|issue=20 \|pages=3370-3388 \|doi=10.3217/jucs-014-20-3370 \|citeseerx=10.1.1.523.2413 \|s2cid=12032836 \|doi-access=free \|url=https://www.jucs.org/jucs_14_20/custom_specializers_in_object.html \|access-date=2022-03-17}}</ref>		* VCLOS for [[Cadence SKILL\|Skill]]<ref>{{cite journal \|last1=Newton \|first1=Jim \|last2=Rhodes \|first2=Christophe \|date=2008-11-28 \|df=dmy \|title=Custom Specializers in Object-Oriented Lisp \|work=[[Journal of Universal Computer Science]] \|volume=14 \|issue=20 \|pages=3370-3388 \|doi=10.3217/jucs-014-20-3370 \|citeseerx=10.1.1.523.2413 \|s2cid=12032836 \|doi-access=free \|url=https://www.jucs.org/jucs_14_20/custom_specializers_in_object.html \|access-date=2022-03-17}}</ref>
	* Tiny CLOS<ref>[http://community.schemewiki.org/?Tiny-CLOS Tiny CLOS, developed by Gregor Kiczales ]</ref>		* Tiny CLOS<ref>[http://community.schemewiki.org/?Tiny-CLOS Tiny CLOS, developed by Gregor Kiczales ]</ref>

185.7.93.150 at 11:21, 6 April 2025

2025-04-06T11:21:51Z

New page

{{Short description|Feature in the programming language Lisp}}
{{Other uses|Clos (disambiguation)}}
[[File:Method-combination.png|thumb|right|Standard method combination in ANSI common lisp]]
The '''Common Lisp Object System (CLOS)''' is the facility for [[object-oriented programming]] in [[American National Standards Institute|ANSI]] [[Common Lisp]]. CLOS is a powerful [[dynamic programming language|dynamic]] object system which differs radically from the OOP facilities found in more [[static language]]s such as [[C++]] or [[Java (programming language)|Java]]. CLOS was inspired by earlier Lisp object systems such as [[Flavors (computer science)|MIT Flavors]] and [[CommonLoops]], although it is more general than either. Originally proposed as an add-on, CLOS was adopted as part of the ANSI standard for Common Lisp and has been adapted into other Lisp dialects such as [[EuLisp]] or [[Emacs Lisp]].<ref>"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." p. 110 of Veitch 1998</ref>

== Features ==
The basic building blocks of CLOS are [[method (computer programming)|method]]s, [[Class (computer programming)|class]]es, instances of those classes, and [[generic function]]s.
CLOS provides macros to define those: <code>defclass</code>, <code>defmethod</code>, and <code>defgeneric</code>. Instances are created with the method <code>make-instance</code>.

Classes can have multiple [[superclass (computer science)|superclass]]es, a list of slots (member variables in C++/Java parlance) and a special [[metaclass]]. Slots can be allocated by class (all instances of a class share the slot) or by instance. Each slot has a name and the value of a slot can be accessed by that name using the function <code>slot-value</code>. Additionally special generic functions can be defined to write or read values of slots. Each slot in a CLOS class must have a unique name.

CLOS is a [[multiple dispatch]] system. This means that [[Method (computer science)|method]]s can be specialized upon any or all of their required arguments. Most OO languages are single-dispatch, meaning that methods are only specialized on the first argument. Another unusual feature is that methods do not "belong" to classes; classes do not provide a namespace for generic functions or methods. Methods are defined separately from classes, and they have no special access (e.g. "this", "self", or "protected") to class slots.

Methods in CLOS are grouped into [[generic function]]s. A generic function is an object which is callable like a function and which associates a collection of methods with a shared name and argument structure, each specialized for different arguments. Since Common Lisp provides non-CLOS classes for structures and built-in data types (numbers, strings, characters, symbols, ...), CLOS dispatch works also with these non-CLOS classes. CLOS also supports dispatch over individual objects (eql specializers). CLOS does not by default support dispatch over all Common Lisp data types (for example dispatch does not work for fully specialized array types or for types introduced by <code>deftype</code>). However, most Common Lisp implementations provide a [[metaobject protocol]] which allows generic functions to provide application specific specialization and dispatch rules.

Dispatch in CLOS is also different from most OO languages:

# Given a list of arguments, a list of applicable methods is determined.
# This list is sorted according to the specificity of their parameter specializers.
# Selected methods from this list are then combined into an effective method using the method combination used by the generic function.
# The effective method is then called with the original arguments.

This dispatch mechanism works at runtime. Adding or removing methods thus may lead to changed effective methods (even when the generic function is called with the same arguments) at runtime. Changing the method combination also may lead to different effective methods.

For example,
<syntaxhighlight lang="lisp">
; Declare the common argument structure prototype.
(defgeneric f (x y))

; Define an implementation for (f integer y), where y matches all types.
(defmethod f ((x integer) y)
1)

(f 1 2.0) => 1

; Define an implementation for (f integer real).
(defmethod f ((x integer) (y real))
2)

(f 1 2.0) => 2 ; Dispatch changed at runtime.
</syntaxhighlight>

Like the OO systems in most [[Dynamic programming language|dynamic languages]], CLOS does not enforce [[Encapsulation (computer science)|encapsulation]]. Any slot can be accessed using the <code>slot-value</code> function or via (optionally auto-generated) [[accessor method]]s. To access it via <code>slot-value</code> you have to know the name of the slot. CL programmers use the language's [[Namespace|package]] facility to declare which functions or data structures are intended for export.

Apart from normal ("primary") methods, there also are <code>:before</code>, <code>:after</code>, and <code>:around</code> "auxiliary" methods. The former two are invoked prior to, or after the primary method, in a particular order based on the class hierarchy. An <code>:around</code> method can control whether the primary method is executed at all. Additionally, the programmer can specify whether all possible primary methods along the [[Hierarchy (object-oriented programming)|class hierarchy]] should be called or just the one providing the closest match.

The ''Standard Method-Combination'' provides the primary, before, after and around methods explained above. There are other Method-Combinations with other method types. New (both simple and complex) Method-Combinations and method types can be defined.

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 problem|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 <code>change-class</code> operator. CLOS also allows one to add, redefine and remove methods at runtime. The [[Circle-ellipse problem|Circle-Ellipse Problem]] is readily solved in CLOS, and most OOP [[Design pattern (computer science)|design patterns]] either disappear or are qualitatively simpler.<ref>In the [http://norvig.com/design-patterns/ Design Patterns in Dynamic Languages] slides, Peter Norvig presents his findings that 16 out of 23 design patterns taken from various textbooks are either "invisible or simpler" in Dylan or Common Lisp than in C++.</ref>

CLOS is not a [[Prototype-based language|prototype language]]: classes must be defined before objects can be instantiated as members of that class.

== Metaobject Protocol ==
Outside of the ANSI Common Lisp standard, there is a widely implemented extension to CLOS called the [[Metaobject]] Protocol (MOP). The MOP defines a standard interface to the underpinnings of the CLOS implementation, treating classes, slot-descriptions, generic-functions and methods themselves as instances of [[metaclass]]es, and allows the definition of new metaclasses and the modification of all CLOS 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]]. The MOP defines the behavior of the whole object system by a set of protocols. These are defined in terms of CLOS. Thus it is possible to create new object-systems by extending or changing the provided CLOS functionality. The book [[The Art of the Metaobject Protocol]] describes the use and implementation of the CLOS MOP.

The various Common Lisp implementations have slightly different support for the Meta-Object Protocol. The ''Closer''<ref>[http://common-lisp.net/project/closer/closer-mop.html Closer Project: Closer to MOP]</ref> project aims to provide the missing features.

== Influences from older Lisp-based object systems ==
[[Flavors (programming language)|Flavors]] (and its successor New Flavors) was the object system on the MIT [[Lisp Machine]]. Large parts of the Lisp Machine operating systems and many applications for it use Flavors or New Flavors. Flavors introduced [[multiple inheritance]] and [[mixins]], among other features. Flavors is mostly obsolete, though implementations for Common Lisp do exist. Flavors was using the message passing paradigm. New Flavors introduced generic functions.

[[CommonLoops]] was the successor of LOOPS (from Xerox [[Interlisp]]-D). CommonLoops was implemented for Common Lisp. A portable implementation called Portable CommonLoops (PCL) was the first implementation of CLOS. PCL is widely ported and still provides the base for the CLOS implementation of several [[Common Lisp]] implementations. PCL is implemented mostly in portable Common Lisp with only a few system dependent parts.

== CLOS in other programming languages ==
Because of the power and expressivity of CLOS, as well as the historical availability of Tiny CLOS (a simplified portable CLOS implementation written by [[Gregor Kiczales]] for use with Scheme), CLOS-like MOP-based object systems have become the ''de facto'' norm in most Lisp dialect implementations, as well as finding their way into some other languages' [[object-oriented programming|OOP]] facilities:

* COS, the C Object System<ref>{{cite conference |last=Deniau |first=Laurent |date=2010-03-12 |df=dmy |title=The C Object System: Using C as a High-Level Object-Oriented Language |arxiv=1003.2547 |citeseerx=10.1.1.763.7946 |doi= |url=https://ldeniau.web.cern.ch/ldeniau/html/cos-oopsla09-draft.pdf |access-date=2022-03-17}}</ref>
* [[Dylan (programming language)|Dylan]]
* Dynace, a (largely) CLOS implementation in C<ref>[https://github.com/blakemcbride/Dynace Dynace Object Oriented Extension To C]</ref>
* [https://www.gnu.org/software/emacs/manual/html_mono/eieio.html EIEIO] for Emacs Lisp
* [http://practical-scheme.net/gauche/ Gauche], Scheme with CLOS
* [https://www.gnu.org/software/guile/manual/html_node/GOOPS.html#GOOPS GOOPS] in [[GNU Guile]]
* ILOS in [[ISLISP]]
* [https://pages.lip6.fr/Christian.Queinnec/WWW/Meroon.html Meroon], an Object System in Scheme
* [https://ktakashi.github.io/sagittarius-ref.html Sagittarius], a Scheme with CLOS
* [http://www.ccs.neu.edu/home/dorai/scmobj/scmobj.html ScmObj], for Scheme
* [https://www.gnu.org/software/mit-scheme/documentation/mit-scheme-sos/ SOS] for MIT Scheme
* [http://www.stklos.net STklos], a Scheme with CLOS
* [http://docs.racket-lang.org/swindle/ Swindle] in Racket
* [http://wiki.call-cc.org/eggref/4/coops COOPS] in Chicken Scheme
* VCLOS for [[Cadence SKILL|Skill]]<ref>{{cite journal |last1=Newton |first1=Jim |last2=Rhodes |first2=Christophe |date=2008-11-28 |df=dmy |title=Custom Specializers in Object-Oriented Lisp |work=[[Journal of Universal Computer Science]] |volume=14 |issue=20 |pages=3370-3388 |doi=10.3217/jucs-014-20-3370 |citeseerx=10.1.1.523.2413 |s2cid=12032836 |doi-access=free |url=https://www.jucs.org/jucs_14_20/custom_specializers_in_object.html |access-date=2022-03-17}}</ref>
* Tiny CLOS<ref>[http://community.schemewiki.org/?Tiny-CLOS Tiny CLOS, developed by Gregor Kiczales ]</ref>
* S4 classes in [[S_(programming_language)#S4|S]] and [[R_(programming_language)|R]] programming languages

== Further reading ==
* {{cite conference |last1=Bobrow |first1=Daniel G. |author-link1=Daniel G. Bobrow |last2=Kahn |first2=Kenneth |last3=Kiczales |first3=Gregor |author-link3=Gregor Kiczales |last4=Masinter |first4=Larry |author-link4=Larry Masinter |last5=Stefik |first5=Mark |last6=Zdybel |first6=Frank |date=June 1986 |title=CommonLoops: Merging Lisp and Object-Oriented Programming |book-title=Conference proceedings on Object-oriented Programming Systems Languages and Applications |pages=17–29 |isbn=978-0-89791-204-4 |conference=[[OOPSLA]] '86 |doi=10.1145/28697.28700 |s2cid=62631315 |url=https://interlisp.org/docs/1986-commonloops.pdf |access-date=2022-03-17 |archive-url=https://web.archive.org/web/20220817140051/https://interlisp.org/docs/1986-commonloops.pdf |archive-date=2022-08-17 |url-status=dead}}
* {{cite book |last1=Veitch |first1=Jim |date=1998 |chapter=A History and Description of CLOS |editor-last1=Salus |editor-first1=Peter H. |editor-link1=Peter H. Salus |title=Handbook of Programming Languages, Volume IV: Functional and Logic Programming Languages |edition=1st |pages=107–158 |publisher=Macmillan Technical Publishing |isbn=1-57870-011-6}}

== References ==
<references/>

== Literature ==
* [[Sonya Keene]], ''[[Object-Oriented Programming in Common Lisp: A Programmer's Guide to CLOS]]'', 1988, Addison-Wesley. {{ISBN|0-201-17589-4}}
* [[Gregor Kiczales]], [[Jim des Rivieres]], and [[Daniel G. Bobrow]], ''[[The Art of the Metaobject Protocol]]'', 1991, MIT Press. {{ISBN|0-262-61074-4}}
* [[Jo A. Lawless]] and [[Molly M. Miller]], ''[[Understanding CLOS: the Common Lisp Object System]]'', 1991, Digital Press, {{ISBN|1-55558-064-5}}
* [[Andreas Paepcke]], ''[[Object-Oriented Programming: the CLOS Perspective]]'', 1993, The MIT Press. {{ISBN|0-262-16136-2}}
* [http://www.dreamsongs.com/Files/ECOOP.pdf The Common Lisp Object System: An Overview] by [[Richard P. Gabriel]] and [[Linda DeMichiel]] provides a good introduction to the motivation for defining classes by means of generic functions.
* [http://cl-cookbook.sourceforge.net/clos-tutorial/ Fundamentals of CLOS] by [[Nick Levine]] provides a step-by-step exposure to the implementation of OO concepts in CLOS, and how to utilize them. It is intended for anybody with a basic knowledge of Lisp or Scheme.
* ''[[Common Lisp HyperSpec]]'', [http://www.lispworks.com/documentation/HyperSpec/Body/07_.htm Chapter 7: ''Objects'']

{{Common Lisp}}
{{Lisp programming language}}

[[Category:Common Lisp]]
[[Category:Object-oriented programming]]
[[Category:Lisp (programming language)]]