Каков партнер Scala по борьбе с дискриминацией в F #?

Question

Как можно было бы преобразовать Дискриминационный Союз в F # в 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

Существует аналогичный пост, в котором говорится о ADT в F # и Scala , но, похоже, я не за этим.

Answer 1

Это делается с наследованием в scala (возможно, к сожалению, поскольку оно более многословно)

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
...

Вы можете набрать

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]

, сопоставляя шаблон с

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, вероятно, будет лучше в качестве метода в 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

Я полностью согласен с Didier Dupont , но если вам нужен более высокий уровень абстракции, реализация типа параметра в Scala дает хорошую интуицию:

sealed trait Option[+E]

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

Источник: https://mauricio.github.io/2013/12/25/learning-scala-by-building-scala-lists-part-3.html