What is Scala's counterpart of Discriminated Union in F#?

Question

How would one go about transforming an Discriminated Union in F# to Scala:

type Expr =     | Val     of String     | Integer of Int32     | Lower   of Expr * Expr     | Greater of Expr * Expr     | And     of Expr * Expr     | Or      of Expr * Expr 

There is a similar post talking about ADTs in F# and Scala, but that doesn't seem to be what I am after.

Answer 1

This is done with inheritance in scala (maybe unfortunately as it is more verbose)

sealed trait Expr case class Val(s: String) extends Expr case class Integer(i: Int) extends Expr case class Lower(left: Expr, right: Expr) extends Expr case class Greater(left: Expr, right: Expr) extends Expr ... 

You could type further

sealed trait Expr[A] case class Val(s: String) extends Expr[String] case class Integer(i: Int) extends Expr[Int] case class Lower[X](left: Expr[X], right: Expr[X])(implicit val ordering: Ordering[X]) extends Expr[Boolean] 

pattern matching with

def valueOf[A](expr: Expr[A]) : A = expr match {    case Val(s) => s    case Integer(i) => i    case l @ Lower(a,b) => l.ordering.lt(valueOf(a), valueOf(b))    ... } 

valueOf would probably be better as a method in Expr

sealed trait Expr[A] {def value: A} case class Val(value: String) extends Expr[String] case class Integer(value: Int) extends Expr[Int] case class Lower[X: Ordering](left: Expr[A], right: Expr[A]) extends Expr[Bool] {    def value = implicitly[Ordering[X]].lt(left.value, right.value) } ... 

Answer 2

I totally agree with Didier Dupont, but if you need higher level of abstraction, implementation of the option type in Scala gives a good intuition:

sealed trait Option[+E]  case class Some[+E]( element : E ) extends Option[E] case object None extends Option[Nothing] 

Source: https://mauricio.github.io/2013/12/25/learning-scala-by-building-scala-lists-part-3.html