CLOS - Main differences between other OO languages

CLOS is the Common LISP Object System.  OO in LISP is more general that
OO in other languages in a couple key ways:
 - inheritance mechanisms can be user-defined, as per meta-object protocol
 - methods can be polymorphic on all parameters (multiple dispatch)

Classes are instances of "meta-classes".  The meta-class that a class
belongs to defines how member of that class work with reespect to
inheritance, etc.  There is a standard meta-class, but you can define
your own meta-classes, and thus use your own inheritance model (even
multiple models in one program).  Powerful stuff.

Multi-methods allow for polymorphism on all objects of a method call.
Most OO languages are single-target: the first parameter fixes which
among polymorphic methods will be called.  A typical polymorphic example
shows how we can create Shapes (like Circles and Squares) and then tell
shapes to draw themselves:

   myShape.drawSelf()   // depends on type (Circle, Square, etc)

In LISP, of course, the syntax for such a call would be more like

   (draw my-shape)

Suppose we want to be polymorphic on multiple parameters, though.
Consider "Battle Chess".  Each time a piece takes another piece, you get
to watch a little fight between the chessmen.  Each combination of
players has a different fight scene.  Thus

   (chess-battle  piece1  piece2)

depends on the type of _both_ pieces to determine which among a set of
methods it will run.  

CLOS can do this with multi-methods.  In other OO languages, you'd wind
up writing "case" statements to handle different types of pieces in each
class.