Помогите разобраться с мультиметодами.

public class Demo {
	public static void main ( String [] args ) {
		Point p = new Point2d( 1, 2 );
		Visitor v = new Chebyshev();
		p.accept( v );
		System.out.println( p.getMetric() );
	}
}

interface Visitor {
	public void visit ( Point2d p );
	public void visit ( Point3d p );
}

abstract class Point {
	public abstract void accept ( Visitor v );
	private double metric = -1;
	public double getMetric () {
		return metric;
	}
	public void setMetric ( double metric ) {
		this.metric = metric;
	}
}

class Point2d extends Point {
	public Point2d ( double x, double y ) {
		this.x = x;
        this.y = y;
	}
	
	public void accept ( Visitor v ) {
		v.visit( this );
	}
	
	private double x;
	public double getX () { return x; }
	
	private double y;
	public double getY () { return y; }
}

class Point3d extends Point {
	public Point3d ( double x, double y, double z ) {
		this.x = x;
        this.y = y;
        this.z = z;
	}
	public void accept ( Visitor v ) {
		v.visit( this );
	}
	
	private double x;
	public double getX () { return x; }
	
	private double y;
	public double getY () { return y; }
	
	private double z;
	public double getZ () { return z; }
}

class Euclid implements Visitor {
	public void visit ( Point2d p ) {
		p.setMetric( Math.sqrt( p.getX()*p.getX() + p.getY()*p.getY() ) );
	}
	public void visit ( Point3d p ) {
		p.setMetric( Math.sqrt( p.getX()*p.getX() + p.getY()*p.getY() + p.getZ()*p.getZ() ) );
	}
}

class Chebyshev implements Visitor {
	public void visit ( Point2d p ) {
		double ax = Math.abs( p.getX() );
		double ay = Math.abs( p.getY() );
		p.setMetric( ax>ay ? ax : ay );
	}
	public void visit ( Point3d p ) {
		double ax = Math.abs( p.getX() );
		double ay = Math.abs( p.getY() );
		double az = Math.abs( p.getZ() );
		double max = ax>ay ? ax : ay;
		if ( max<az ) max = az;
		p.setMetric( max );
	}
}

(defun demo ()
  (let ((p (make-instance 'point2d :x 1 :y 2))
        (v (make-instance 'chebyshev)))
    (visit p v)
    (print (metric p v))))

(defclass point ()
  ((metric :initform -1 :accessor metric)))

(defclass point2d (point)
  ((x :initarg :x :reader get-x)
   (y :initarg :y :reader get-y)))

(defclass point3d (point)
  ((x :initarg :x :reader get-x)
   (y :initarg :y :reader get-y)
   (z :initarg :z :reader get-z)))

(defclass euclid () ())

(defmethod visit ((p point2d) (euclid v))
   ...)

(defmethod visit ((p point3d) (euclid v))
   ...)

(defclass chebyshev () ())

(defmethod visit ((p point2d) (chebyshev v))
   ...)

(defmethod visit ((p point3d) (chebyshev v))
   ...)

(defgeneric convert
    (<destination> <origin> object)
  (:documentation "Convert an OBJECT
  following interface <ORIGIN> into a new object
  following interface <DESTINATION>."))

(define-interface <alist>
    (<map-empty-as-nil>
     <map-decons-from-first-key-value-drop>
     <map-update-key-from-lookup-insert-drop>
     <map-divide/list-from-divide>
     <map-map/2-from-fold-left-lookup-insert-drop>
     <map-join-from-fold-left-insert>
     <map-join/list-from-join>
     <map>)
  ((key-interface :type <eq>
    :initarg :key-interface
    :reader key-interface))
  (:parametric (&optional (eq <eql>))
     (make-interface :key-interface eq))
  (:singleton))

Number10orMore := Object clone do(
    clone := method(initNumber,
       if(initNumber < 10, Exception raise("init number < 10"); return)
       n := resend; n value := initNumber; n
    )
   * := method(n, Number10orMore clone(value * n value)) 
   print := method(self value print)
)


write ( Number10orMore clone(10) * (Number10orMore clone(20)) ) // #>>>>200

Asteroid := Object clone do(
 collide := method(o,
 if(o type == "Asteroid", /*астероид сталкивается с астероидом*/)
 if(o type == "Spaceship", /*астероид сталкивается с космическим кораблем*/)
 )
)
Spaceship := Object clone do(
 collide := method(o, 
 if(o type == "Spaceship", /*космический корабль сталкивается с космическим кораблем*/)
 if(o type == "Asteroid", /*космический корабль сталкивается с астероидом*/)
 )
)

MultyMethod := List clone do(
     dispatch := method(args,
        argTypes := args map(type)
        self foreach(block, if(block argumentNames == argTypes, return block callWithArgList(args)))
     )
)

/////////////////////////////////////////////

Asteroid := Object clone 
SpaseShip := Object clone 

asteroid := Asteroid clone
spaceShip := SpaseShip clone


multyMethod := MultyMethod clone
collide := method(multyMethod dispatch(call evalArgs))

multyMethod push(block(Asteroid, SpaseShip, writeln("asteroid collide with spaceship")))
multyMethod push(block(SpaseShip, Asteroid,  writeln("spaceship collide with asteroid")))

collide(asteroid, spaceShip) #>>>>asteroid collide with spaceship
collide(spaceShip, asteroid) #>>>>spaceship collide with asteroid

// come from library

Collidable := Object clone do(
   collide := method(o,
      doMessage(o type asMessage)
   )
)

Asteroid := Collidable clone do(
   Spaceship := method(writeln("asteroid collide with spaceship"))
)
Spaceship := Collidable clone do(
   Asteroid := method(writeln("spaceship collide with asteroid"))
)

// come from library

Planet := Collidable clone

Asteroid Planet := method(writeln("asteroid collide with planet")) // extend behavor

asteroid := Asteroid clone
spaceship := Spaceship clone
planet := Planet clone 

asteroid collide(spaceship) #>>>> asteroid collide with spaceship
asteroid collide(planet)    #>>>> asteroid collide with planet
spaceship collide(asteroid) #>>>> spaceship collide with asteroid

collide(type, subtype)
collide(subtype, type)

// come from library

Collidable := Object clone do(
   collide := method(o,
      doMessage(o type asMessage)
   )
)

Asteroid := Collidable clone do(
   Spaceship := method(writeln("asteroid collide with spaceship"))
)
Spaceship := Collidable clone do(
   Asteroid := method(writeln("spaceship collide with asteroid"))
)

// come from library

Planet := Collidable clone do( // own object
   Asteroid := method(writeln("planet collide with asteroid"))
)

Asteroid Planet := method(writeln("asteroid collide with planet")) // extend behavor

asteroid := Asteroid clone
spaceship := Spaceship clone
planet := Planet clone 

asteroid collide(spaceship) #>>>> asteroid collide with spaceship
asteroid collide(planet)    #>>>> asteroid collide with planet
spaceship collide(asteroid) #>>>> spaceship collide with asteroid
planet collide(asteroid)    #>>>> planet collide with asteroid

Collidable := Object clone do(
   collide := method(
      call evalArgs foreach(o, doMessage(o type asMessage) )
   )
)

Asteroid := Collidable clone do(
   Spaceship := method(writeln("asteroid collide with spaceship"))
)
Spaceship := Collidable clone do(
   Asteroid := method(writeln("spaceship collide with asteroid"))
)

// come from library

Planet := Collidable clone do( // own object
   Asteroid := method(writeln("planet collide with asteroid"))
)

Asteroid Planet := method(writeln("asteroid collide with planet")) // extend behavor

asteroid := Asteroid clone
spaceship := Spaceship clone
planet := Planet clone 

asteroid collide(planet, spaceship)

#>>>> asteroid collide with planet
#>>>> asteroid collide with spaceship

Collidable := Object clone do(
   collide := method(
      call evalArgs foreach(o, o isKindOf(self proto) ifTrue(return); doMessage(o type asMessage) )
   )
)

Asteroid := Collidable clone do(
   Asteroid := method(writeln("asteroid collide with asteroid"))
   Spaceship := method(writeln("asteroid collide with spaceship"))
   Planet := method(writeln("asteroid collide with planet"))
)

Spaceship := Collidable clone
Planet := Collidable clone


asteroid1 := Asteroid clone
asteroid2 := Asteroid clone
spaceship1 := Spaceship clone
spaceship2 := Spaceship clone
planet1 := Planet clone 
planet2 := Planet clone 

writeln("call with break on asteroid2", ": ")
asteroid1 collide(planet1, planet2, asteroid2, spaceship1, spaceship2)
writeln
writeln("call with break on asteroid2, on another place", ": ")
asteroid1 collide(planet1, planet2, spaceship1, asteroid2, spaceship2)
writeln
writeln("call with no break, cause no asteroid instance in arglist", ": ")
asteroid1 collide(planet1, planet2, spaceship1, spaceship2)




#>>>> call with break on asteroid2: 
#>>>> asteroid collide with planet
#>>>> asteroid collide with planet
#>>>> 
#>>>> call with break on asteroid2, on another place: 
#>>>> asteroid collide with planet
#>>>> asteroid collide with planet
#>>>> asteroid collide with spaceship
#>>>> 
#>>>> call with no break, cause no asteroid instance in arglist: 
#>>>> asteroid collide with planet
#>>>> asteroid collide with planet
#>>>> asteroid collide with spaceship
#>>>> asteroid collide with spaceship

(defmethod collide ((asteroid o1) (spaceship o2))
  (print "asteroid collide with spaceship"))

(defmethod collide ((spaceship o1) (asteroid o2))
  (print "spaceship collide with asteroid"))

(defmethod fire (o1 o2)
  (print "it cannot fire"))

(defmethod fire ((spaceship o1) (asteroid o2))
  (print "spaceship destroyed asteroid")) 

(let ((asteroid (make-instance 'asteroid))
      (spaceship (make-instance 'spaceship)))
  (collide asteroid spaceship) ;; asteroid collide with spaceship
  (collide spaceship asteroid) ;; spaceship collide with asteroid
  (fire spaceship asteroid) ;; spaceship destroyed asteroid
  (fire asteroid spaceship)) ;; it cannot fire

MultiMethod := List clone do(
    add := method(appendSeq(call evalArgs))
    call := method(args,
       types := args map(type)
       detect(argumentNames == types) clone setScope(call sender) callWithArgList(args)
    )
)

Object setMultimethod := method(name,
   mName := ("_" .. name)
   self setSlot(mName, MultiMethod clone)
   self setSlot(name, doString("method(#{mName} call(call evalArgs) )" interpolate))
)

/////////////////////////////////////////////////////////////////////////////////////////


Asteroid := Object clone do(
   setMultimethod("collide")
   _collide add(block(Spaceship, "asteroid collide with spaceship" println))
   setMultimethod("fire")
   _fire add(block(Spaceship, "asteroid destroyed spaceship" println))
)
Spaceship := Object clone do(
  setMultimethod("collide")
  _collide add(block(Asteroid, "spaceship collide with asteroid" println))
  setMultimethod("fire")
  _fire add(block(Asteroid, "it cannot fire" println))
)

asteroid := Asteroid clone
spaceship := Spaceship clone

asteroid collide(spaceship)  #>>>> asteroid collide with spaceship
spaceship collide(asteroid)  #>>>> spaceship collide with asteroid
asteroid fire(spaceship)     #>>>> asteroid destroyed spaceship
spaceship fire(asteroid)     #>>>> it cannot fire

MultiMethod := List clone do(
    add := method(appendSeq(call evalArgs))
    call := method(args,
       types := args map(type)
       detect(argumentNames == types) clone setScope(call sender self) callWithArgList(args)
    )
)

Object setMultimethod := method(name,
   mName := ("_" .. name)
   self setSlot(mName, MultiMethod clone)
   self setSlot(name, doString("method(#{mName} call(call evalArgs) )" interpolate))
)

/////////////////////////////////////////////////////////////////////////////////////////

show := method(o1, o2, event, effect,
   writeln(o1 .. " " .. event .. " " .. o2 .. "; " .. effect .. " around here!!!")
   
)

SpaceObject := Object clone do(
   setMultimethod("collide")
   _collide add(
     block(Spaceship, show(self type, "Spaceship", "collide", sound)),
     block(Asteroid, show(self type, "Asteroid", "collide", sound))
    )
   setMultimethod("fire")
   _fire add(
    block(Spaceship, show(self type, "Spaceship", "fire", flame)),
    block(Asteroid, show(self type, "Asteroid", "fire", flame))
   )
)

Asteroid := SpaceObject clone do (sound := "boom" ; flame := "green flame")
Spaceship := SpaceObject clone do (sound := "baam"; flame := "red flame")

asteroid1 := Asteroid clone 
asteroid2 := Asteroid clone 
spaceship1 := Spaceship clone
spaceship2 := Spaceship clone

asteroid1 collide(spaceship1)    #>>>>Asteroid collide Spaceship; boom around here!!!
spaceship1 collide(asteroid1)    #>>>>Spaceship collide Asteroid; baam around here!!!
asteroid1 collide(asteroid2)     #>>>>Asteroid collide Asteroid; boom around here!!!
spaceship1 collide(spaceship2)   #>>>>Spaceship collide Spaceship; baam around here!!!
asteroid1 fire(spaceship1)       #>>>>Asteroid fire Spaceship; green flame around here!!!
spaceship1 fire(asteroid1)       #>>>>Spaceship fire Asteroid; red flame around here!!!
asteroid1 fire(asteroid2)        #>>>>Asteroid fire Asteroid; green flame around here!!!
spaceship1 fire(spaceship2)      #>>>>Spaceship fire Spaceship; red flame around here!!!

SpaceObject := Object clone do(
   setMultimethod("collide")
   setMultimethod("fire")
   
)

Asteroid := SpaceObject clone do (sound := "boom" ; flame := "green flame")
Spaceship := SpaceObject clone do (sound := "baam"; flame := "red flame"
   _collide add(
     block(Spaceship, show(self type, "Spaceship", "collide", sound)),
     block(Asteroid, show(self type, "Asteroid", "collide", sound))
    )
_fire add(
    block(Spaceship, show(self type, "Spaceship", "fire", flame)),
    block(Asteroid, show(self type, "Asteroid", "fire", flame))
   )
)