Implement BST using Scala Pattern Matching - scala

Question

I am new to scala and was trying to implement a BST using Pattern Matching Concept in scala.
Edit: I have modified the insert function and now it is behaving in the expected manner, can someone help me to make it tail recursive?
Also, any other code improvements would be appreciated.
trait IntTree {
def contains(v: Int): Boolean
def insert(x: Int): IntTree
}
case object EmptyTree extends IntTree {
override def insert(x: Int): IntTree = Node(x, EmptyTree, EmptyTree)
override def contains(v: Int): Boolean = false
}
case class Node(elem: Int, left: IntTree, right: IntTree) extends IntTree {
override def contains(v: Int): Boolean = {
#scala.annotation.tailrec
def contains(t: IntTree, v: Int): Boolean = t match {
case Node(data, _, _) if (data == v) => true
case Node(data, l, r) => if (data > v) contains(l, v) else contains(r, v)
case _ => false
}
contains(this, v)
}
override def insert(x: Int): IntTree = {
def insert(t: IntTree, x: Int): IntTree = t match {
case Node(data, l, r) if (data > x) => Node(data, insert(l, x), r)
case Node(data, l, r) if (data < x) => Node(data, l, insert(r, x))
case EmptyTree => t insert x
case _ => t
}
insert(this, x)
}
}

Answer 1

It would require a revisit and update of the parent nodes after you go down the leaf:
sealed trait IntTree {
def contains(v: Int): Boolean
def insert(x: Int): Node // better to return Node here
}
def insert(x: Int): Node = {
#annotation.tailrec
def insert(t: IntTree, x: Int, parents: List[Node]): Node = t match {
case EmptyTree =>
parents.foldLeft(t insert x) { case (n, p) =>
if (p.elem >= n.elem) p.copy(left = n)
else p.copy(right = n)
}
case Node(data, l, r) =>
insert(if(data >= x) l else r, x, t :: parents)
}
insert(this, x, List.empty)
}