add GADT test cases

Author: liufengyun

tests/patmat/gadt-basic.scala

@@ -0,0 +1,23 @@
+object O1 {
+  sealed trait Expr[T]
+  case class BExpr(bool: Boolean) extends Expr[Boolean]
+  case class IExpr(int: Int) extends Expr[Int]
+
+  def join[T](e1: Expr[T], e2: Expr[T]): Expr[T] = (e1, e2) match {
+    case (IExpr(i1), IExpr(i2)) => IExpr(i1 + i2)
+    case (BExpr(b1), BExpr(b2)) => BExpr(b1 & b2)
+  }
+}
+
+object O2 {
+  sealed trait GADT[A, B]
+  case object IntString extends GADT[Int, String]
+  case object IntFloat extends GADT[Int, Float]
+  case object FloatFloat extends GADT[Float, Float]
+
+  def m[A, B](g1: GADT[A, B], g2: GADT[A, B]) = (g1, g2) match {
+    case (IntString, IntString) => ;
+    case (IntFloat, IntFloat) => ;
+    case (FloatFloat, FloatFloat) => ;
+  }
+}

tests/patmat/gadt-covariant.check

@@ -0,0 +1 @@
+6: Pattern Match Exhaustivity: (BExpr(_), IExpr(_)), (IExpr(_), BExpr(_))

tests/patmat/gadt-covariant.scala

@@ -0,0 +1,10 @@
+object O {
+   sealed trait Expr[+T]
+   case class IExpr(x: Int) extends Expr[Int]
+   case class BExpr(b: Boolean) extends Expr[Boolean]
+
+   def foo[T](x: Expr[T], y: Expr[T]) = (x, y) match {
+      case (IExpr(_), IExpr(_)) => true
+      case (BExpr(_), BExpr(_)) => false
+   }
+}

tests/patmat/gadt-invariant.scala

@@ -0,0 +1,10 @@
+object O {
+   sealed trait Expr[T]
+   case class IExpr(x: Int) extends Expr[Int]
+   case class BExpr(b: Boolean) extends Expr[Boolean]
+
+   def foo[T](x: Expr[T], y: Expr[T]) = (x, y) match {
+      case (IExpr(_), IExpr(_)) => true
+      case (BExpr(_), BExpr(_)) => false
+   }
+}

tests/patmat/gadt-nontrivial.check

@@ -0,0 +1 @@
+7: Pattern Match Exhaustivity: (IntExpr(_), AddExpr(_, _))

tests/patmat/gadt-nontrivial.scala

@@ -0,0 +1,12 @@
+object O {
+  sealed trait Expr[T]
+  case class BoolExpr(v: Boolean) extends Expr[Boolean]
+  case class IntExpr(v: Int) extends Expr[Int]
+  case class AddExpr(e1: Expr[Int], e2: Expr[Int]) extends Expr[Int]
+
+  def join[T](e1: Expr[T], e2: Expr[T]): Expr[T] = (e1, e2) match {
+    case (BoolExpr(b1), BoolExpr(b2)) => BoolExpr(b1 && b2)
+    case (IntExpr(i1), IntExpr(i2)) => IntExpr(i1 + i2)
+    case (AddExpr(ei1, ei2), ie) => join(join(ei1, ei2), ie)
+  }
+}

tests/patmat/gadt-nontrivial2.scala

@@ -0,0 +1,16 @@
+object O {
+  sealed trait Nat
+  type Zero = Nat
+  sealed trait Succ[N <: Nat] extends Nat
+
+  sealed trait NVec[N <: Nat, +A]
+  case object NEmpty extends NVec[Zero, Nothing]
+  case class NCons[N <: Nat, +A](head: A, tail: NVec[N, A]) extends NVec[Succ[N], A]
+
+  def nzip[N <: Nat, A, B](v1: NVec[N, A], v2: NVec[N, B]): NVec[N, (A, B)] =
+    (v1, v2) match {
+      case (NEmpty, NEmpty) => NEmpty
+      case (NCons(a, atail), NCons(b, btail)) =>
+        NCons((a, b), nzip(atail, btail))
+    }
+}

tests/patmat/t9926.scala

@@ -0,0 +1,23 @@
+object Model {
+  sealed trait Field[T]
+  case object StringField extends Field[String]
+  case object BoolField extends Field[Boolean]
+
+  sealed trait Value[T]
+  case class Literal(v: String) extends Value[String]
+  case class Bool(v: Boolean) extends Value[Boolean]
+
+  sealed trait Expression[T]
+  case class Equality[T](field: Field[T], value: Value[T]) extends Expression[T]
+
+  def interpret[T](expr: Expression[T]): Int = expr match {
+    case Equality(StringField, Literal(v)) => 1
+    case Equality(BoolField, Bool(v)) => 2
+  }
+
+  // T - T(s1, s2, ...)
+  // if T contains type parameter, get its dimension types.
+  //
+  // actively decompose its dimensions, and then do subtype checking to
+  // see if the type paramter can be instantiated.
+}