> if(object instanceof Person) {
>   Person person = (Person)object;
>   String name = person.getName();
>   int age = person.getAge();
>   ...
> }
> 

> case Person(name, age) => ...
> 

>   case class Power(l: Term, exp: Term)
> 

>   x**z * y**z = (x*y) ** z
> 

>   class PowerSimplifier extends Simplifier {
>     override def apply(term: Term): Term = term match {
>       case Mul(Power(x, z1), Power(y, z2)) if z1 == z2 =>
>         Power(Mul(x, y), z1)
>       case _ =>
>         super.apply(term)
>     }
>   }
> 

  class Simplifier {
    def apply(term: Term): Term = term match {
      ...
    }
  }

  class MySimplifier extends Simplifier {
    def apply(term: Term): Term = term match {
      case ... => ...
      case ... => ...
      case _ => super.apply(term)
    }
  }

  class YourSimplifier extends Simplifier {
    def apply(term: Term): Term = term match {
      case ... => ...
      case ... => ...
      case _ => super.apply(term)
    }
  }

  class CombinedSimplifier 
  extends MySimplifier with YourSimplifier

  (new CombinedSimplifier).apply(aterm)

case class Num(f:float) : extends Term
case class RealNum(f:float) : extends Num

def simplify(term: Term) = term match {
  case Num(x) => Num(0)            
  case RealNum(x) => Floor(x)
  case _ => term
}

  class RealNum(val v: float) extends Num(x.toInt)

  new RealNum(1.1) match {
    case Num(x) => System.out.println(x)
  } 

  def simplify(term: Term) = term match {
    case Num(x) => Num(0)            
    case x: RealNum => Floor(x.value)
    case _ => term
  }

public interface TermMD extends pec.compile.multipledispatch.MultipleDispatch {  // The methods in this interface are Multiply Dispatched
    Term binarySimplify( Term toTheLeft, Term toTheRight );
    Term unarySimplify( Term toTheRight );
}
public interface Term extends TermMD {  // The method in this interface is Singly Dispatched
    Term simplify();
}
public abstract class TerminalTerm implements Term {
    public final Term binarySimplify( Term toTheLeft, Term toTheRight ) { throw new AssertionError(); } // Method body replaced by PEC - with a multiple dispatch call
    public static final Term binarySimplify( final Term kind, final Term toTheLeft, final Term toTheRight ) { return kind; } // Default simplifier for unary terms - do nothing
    public final Term unarySimplify( Term toTheRight ) { throw new AssertionError(); } // Method body replaced by PEC - with a multiple dispatch call
    public static final Term unarySimplify( final Term kind, final Term toTheRight ) {  return kind; } // Default simplifier for binary terms - do nothing
    public Term simplify() { return this; } // Nothing to simplify for a terminal!
}
public abstract class UnaryTerm extends TerminalTerm {
    protected final Term toTheRight;
    protected UnaryTerm( final Term toTheRight ) { this.toTheRight = toTheRight.simplify(); }
    public Term simplify() { return unarySimplify( toTheRight ); }
}
public abstract class BinaryTerm extends UnaryTerm {
    protected final Term toTheLeft;
    protected BinaryTerm( final Term toTheLeft, final Term toTheRight ) {
        super( toTheRight );
        this.toTheLeft = toTheLeft.simplify();
    }
    public Term simplify() { return binarySimplify( toTheLeft, toTheRight ); }
}
public final class Zero extends TerminalTerm {}
public final class NaN extends TerminalTerm {}
public final class Var extends TerminalTerm {}
public final class Mult extends BinaryTerm {
    public Mult( final Term toTheLeft, final Term toTheRight ) { super( toTheLeft, toTheRight ); }
    public static final Term binarySimplify( final Mult m, final Zero z, final Term t ) { return z; } // 0 * x = 0
    public static final Term binarySimplify( final Mult m, final Term t, final Zero z ) { return z; } // x * 0 = 0
    public static final Term binarySimplify( final Mult m, final Zero z, final Zero z2 ) { return z; } // 0 * 0 = 0, needed to resolve conflict
    public static final Term binarySimplify( final Mult m, final NaN n, final Term t ) { return n; } // NaN * x = NaN
    public static final Term binarySimplify( final Mult m, final Term t, final NaN n ) { return n; } // x * NaN = NaN
    public static final Term binarySimplify( final Mult m, final NaN n, final NaN n2 ) { return n; } // NaN * NaN = NaN, needed to resolve conflict
    public static final Term binarySimplify( final Mult m, final NaN n, final Zero z ) { return n; } // NaN * 0 = NaN, needed to resolve conflict
    public static final Term binarySimplify( final Mult m, final Zero z, final NaN n ) { return n; } // 0 * NaN = NaN, needed to resolve conflict
}

public final class Power extends BinaryTerm {
    public Power( final Term toTheLeft, final Term toTheRight ) { super( toTheLeft, toTheRight ); }
    public static final Term binarySimplify( final Mult m, final Power pL, final Power pR ) { // x**z * y**z = (x * y)**z
        if ( pL.toTheRight == pR.toTheRight ) return (new Power( new Mult( pL.toTheLeft, pR.toTheLeft ), pL.toTheRight )).simplify();
        return m;
    }
}