====== L16. Case classes ======

<code scala>
/*
Clase in Scala
 */
class Point(a: Int, b: Int)  {
  def getA: Int = a
  def getB: Int = b

  def higher(p: Point): Boolean =
    a >= p.getA

  //string interpolation
  override def toString = s"(${a},${b})"
}

new Point(1,2)
new Point(2,1) == new Point(2,1)

trait TwoDimensionalObject{
  def distanceFromOrigin: Int
}

trait FTree

case class FNode (key: Int,
                  left: FTree,
                  right: FTree)
  extends FTree
  // o singura instanta a FEmpty
  // vezi singleton
case object FEmpty extends FTree

val t1 = FNode(3,
            FNode(2,FEmpty,
                    FEmpty),
            FNode(5, FEmpty,
                     FEmpty))

FEmpty == FEmpty
FNode(1,FEmpty,FEmpty) == FNode(1,FEmpty,FEmpty)

/* Cum putem introspecta arbori? */

def isEmpty(t: FTree): Boolean =
  t match {
    case FEmpty => true
    case _ => false

  }

def size (t: FTree): Int =
  t match {
    case FEmpty => 0
    case FNode(_,l,r) => 1 + size(l) + size(r)
  }

def contains(k: Int, t: FTree): Boolean =
  t match {
    case FEmpty => false
    case FNode(key,left,right) => k == key ||
                                  contains(k,left) ||
                                  contains(k,right)
  }

/* Putem defini operatiile pe arbori
SI ALTFEL?
 */

trait OOTree {
  def isEmpty: Boolean
  def size: Int
  def contains(k: Int): Boolean
}

case object OOEmpty extends OOTree{

  override def isEmpty:Boolean = true
  override def size:Int = 0
  override def contains(k: Int) = false

}
case class Leaf(key: Int) extends OOTree {
  override def isEmpty: Boolean = ???
  override def size: Int = ???
  override def contains(k: Int): Boolean = ???
}
case class OONode(key: Int,
                  left: OOTree,
                  right: OOTree)
            extends OOTree {

  override def isEmpty: Boolean = false
  override def size: Int = 1 + left.size + right.size
  override def contains(k: Int) =
    k == key || left.contains(k) || right.contains(k)
}
// Object-Oriented decomposition
trait Expr {
  def eval: Int
  def show: String
}

case class Val (i: Int) extends Expr {
  override def eval: Int = i
  override def show: String = s"${i}"
}

case class Var (s: String) extends Expr {
  override def eval: Int = ???
  override def show: String = s
}

case class Plus(e1: Expr, e2: Expr) extends Expr{
  override def eval: Int = e1.eval + e2.eval

  override def show: String = s"${e1.show} + ${e2.show}"

}

case class Mult(e1: Expr, e2: Expr) extends Expr{
  override def eval: Int = e1.eval * e2.eval
  override def show: String = s"${e1.show} * ${e2.show}"

}

Plus(Val(2),Mult(Val(3),Val(4))).eval
</code>