Scala: Printing a Binary Tree That's a Class - scala

Question

Hello I am new to Scala and I'm having a hard time getting my class to print some values out.
class TreeDemo[T](implicit o : T => Ordered[T]) {
sealed trait BinaryTree
case object Empty extends BinaryTree
case class Node(left:BinaryTree, d:T, right:BinaryTree) extends BinaryTree
// construct a "leaf" node
def Leaf(d : T) : BinaryTree = Node(Empty,d,Empty)
// remove all nodes equal to x from tree t
def remove(t : BinaryTree, x : T) : BinaryTree = {
replace(t, x, Empty)
}
val myTree = Node(Node(Leaf(1),2,Leaf(3)),4,Leaf(5))
val x = remove(myTree, 2)
def main (args: Array[String]) {
println(x)
}
}
From the code above I am trying to print the remove def but I am getting errors.

Answer 1

If you want remove to remove nodes in place from the tree, then you will want var values. I was not sure because replace is missing from your snippet
As comments point out, Node can only take T until you instantiate an actual TreeDemo, so at the time of definition of the class, you cannot create Nodes of specific types, such as Leaf(1) etc. because it would be a type mismatch.
It seems the type variable should be on BinaryTree itself, since you want your demo to try out specific trees, and it can be covariant (+T) to allow for Empty to be any other valid BinaryTree.
Left and right trees of a node should have the same types as the node.
You can override toString to allow for more informative printing
A method called main inside of a class doesn't serve as an entry-point. In Java, only a static void main will serve as an application entry-point. In Scala, main should also be in static (in an object instead of a class) in order to run.
sealed trait BinaryTree[+T]
case object Empty extends BinaryTree[Nothing]
class Node[T](var left:BinaryTree[T], var d:T, var right:BinaryTree[T])(implicit val ordering: Ordering[T]) extends BinaryTree[T] {
override def toString: String = (left, right) match {
case (Empty, Empty) => s"(${d})"
case (Empty, right) => s"(${left},${d})"
case (left, Empty) => s"(${d}, ${right})"
case _ => s"(${left}, ${d}, ${right})"
}
}
object Node{
// define remove here (if static) or in the class
def apply[T:Ordering](t: T) = new Node[T](Empty, t, Empty)
def apply[T:Ordering](left:BinaryTree[T], t: T) = new Node[T](left, t, Empty)
def apply[T:Ordering](left:BinaryTree[T], t: T, right:BinaryTree[T]) = new Node[T](left, t, right)
def apply[T:Ordering](t: T, right:BinaryTree[T]) = new Node[T](Empty, t, right)
}
// either extend App, or have a main method, but use an object
object TreeApp extends App {
val myTree = Node(Node(Node(1),2,Node(3)),4,Node(5))
println(myTree)
}