Object Orientation and CLOS

Lee Spector, lspector@hampshire.edu, 1995-1998


Object orientation: What is it?

CLOS: classes & instances, generic functions & methods

some of common lisp's types are also classes

(describe 'number)
Symbol: NUMBER
Type Specifier, Class Name
EXTERNAL in package: #<Package "COMMON-LISP">
Print name: "NUMBER"
Value: #<Unbound>
Function: #<Unbound>
Plist: NIL
Class: #<BUILT-IN-CLASS NUMBER>
--> NIL

(describe 'symbol)
Type Specifier, Class Name
EXTERNAL in package: #<Package "COMMON-LISP">
Print name: "SYMBOL"
Value: #<Unbound>
Function: #<Unbound>
Plist: NIL
Class: #<BUILT-IN-CLASS SYMBOL>
--> NIL


Suppose I want to write a function that does different 
things to numbers and symbols

(defun double (x)
  (typecase x
    (number (* 2 x))
    (symbol (list x x))))
--> DOUBLE


(double 33)
--> 66

(double 'foo)
--> (FOO FOO)


The CLOS way to do this:

first get rid of the function we just defined:

(fmakunbound 'double)
--> DOUBLE

Now define it as a generic function:

(defgeneric double (thing)
  (:documentation "Doubles its argument."))
--> #<STANDARD-GENERIC-FUNCTION DOUBLE #x10A2FBE>

(defmethod double ((thing number))
  "The doubling method for numbers."
  (* thing 2))
--> #<STANDARD-METHOD DOUBLE (NUMBER)>




(defmethod double ((thing symbol))
  "The doubling method for symbols."
  (list thing thing))
--> #<STANDARD-METHOD DOUBLE (SYMBOL)>

(double 33)
--> 66

(double 'foo)
--> (FOO FOO)


The real power of CLOS comes from combining this 
"generic function dispatch" with user-definable classes. 
Defclass is like a super defstruct.

(defstruct person
  (name 'bill)
  (age 10))
--> PERSON

(make-person :name 'george :age 12)
--> #S(PERSON :NAME GEORGE :AGE 12)


This uses defclass for a similar effect:

(defclass person ()
     ((name :accessor name
            :initform 'bill
            :initarg :name)
      (age :accessor age
           :initform 10
           :initarg :age)))
--> #<STANDARD-CLASS PERSON>

You have a lot more options with the defclass -- you 
have more flexibility with names, with what can be 
initialized, etc. You can also add doc strings for 
each slot.

Instances of classes are made with make-instance:

(make-instance 'person :age 100)
--> #<PERSON #x1098419>


(defvar x)
--> X

(setq x (make-instance 'person :age 100))
--> #<PERSON #x1098831>

(describe x)
Class: #<STANDARD-CLASS PERSON>
Wrapper: #<CCL::CLASS-WRAPPER PERSON #x10983E9>
Instance slots
NAME: BILL
AGE: 100
--> NIL

You can access and change slots with the "accessors" 
you specified in the defclass:

(age x)
--> 100
(setf (age x) 55)
--> 55
(age x)
--> 55

Objects are generally printed with PRINT-OBJECT, which 
is a generic function that we can specialize:

x
--> #<PERSON #x1098831>

(defmethod print-object ((p person) stream)
  (format stream "Person: ~A, age: ~A"
          (name p) (age p)))
--> #<STANDARD-METHOD PRINT-OBJECT (PERSON T)>

x
--> Person: BILL, age: 55
You can specialize classes -- child classes inherit 
structure and behavior from their parents:

(defclass teacher (person)
  ((subject :accessor subject
            :initarg :subject)))
--> #<STANDARD-CLASS TEACHER>

(defclass math-teacher (teacher)
  ((subject :initform "Mathematics")))
--> #<STANDARD-CLASS MATH-TEACHER>

(setq p2 (make-instance 'math-teacher
           :name 'john
           :age 34))
--> Person: JOHN, age: 34

We could provide a new definition of print-object for 
teachers, but CLOS lets us use and add to the behavior 
of the parent's definition:

(defmethod print-object :after ((p teacher) stream)
  (format stream ", subject: ~A"
          (subject p)))
--> #<STANDARD-METHOD PRINT-OBJECT AFTER (TEACHER T)>

p2
--> Person: JOHN, age: 34, subject: Mathematics

Here's a silly :before method for math teachers:
(defmethod print-object
           :before ((p math-teacher) stream)
  (format stream "Axiomatically, I present: "))
--> #<STANDARD-METHOD PRINT-OBJECT BEFORE (MATH-TEACHER T)>



p2
--> Axiomatically, I present: Person: JOHN, age: 34, 
    subject: Mathematics

There are many ways in which multiple methods may be 
used in one generic function call -- see docs for details.