Test cases

Author: odersky

tests/pos/flowops1.scala

@@ -20,6 +20,10 @@ object Test {
     def xx(i: Int): f.Repr[Out = O] = f.map(identity)
   }
 
+  class xalt[O, M, F <: FO](val f: F[Out = O, Mat = M]) extends AnyVal {
+    def xx(i: Int): FO[Out = O, Mat = M] = ???
+  }
+
   val s1 = new Source[Int, NotUsed].xx(12)
   val s2: Source[Int, NotUsed] = s1
   val f1 = x[Int, NotUsed, Flow[In = Int]](new Flow[Int, Int, NotUsed]).xx(12)
@@ -30,4 +34,6 @@ object Test {
   val f4: Flow[Int, Int, NotUsed] = f3
   val f5 = new Flow[Int, Int, NotUsed].xx(12)
   val f6: Flow[Int, Int, NotUsed] = f5
+  val f7 = new xalt(new Flow[Int, Int, NotUsed]).xx(12)
+  val f8: FO[Int, NotUsed] = f7
 }

tests/pos/named-params.scala

@@ -29,9 +29,39 @@ object Test {
   val z3 = d2[E = Int](1)
   val z4 = d2[V = Int]("AAA")
   val z5 = d2[E = Int][V = String](1)
+
+// Testing type inference
+
+  def f[X <: C](x: X[Int, Int]): X[String, String] = ???
+  val arg1: C[Int, Int] = ???
+  val res1 = f(arg1)
+  val chk1: C[String, String] = res1
+
+  class C1[type Elem, type Value](x: Elem) extends C[Elem, Value](x)
+  class CC extends C1[Int, Int](1)
+  val arg2: CC = ???
+  val res2 = f(arg2)
+  val chk2: C[String, String] = res2
+
+  class D1[type Elem, type Value](x: Elem) extends C[Elem, Value](x)
+  class DD extends D1[Int, Int](2)
+  val arg3: CC & DD = ???
+  val res3 = f(arg3)
+  val chk3: (C1 & D1) { type Elem = String; type Value = String } = res3
+  val arg4: CC | DD = ???
+  val res4 = f(arg4)
+  val chk4: C[String, String] = ???
+
+  class CX[type Elem](x: Elem) extends C1[Elem, Int](x)
+  class DX[type Value]() extends D1[Int, Value](2)
+  val arg5: CX[Int] & DX[Int] = ???
+  val res5 = f(arg5)
+  val chk5: (C1 & D1) { type Elem = String; type Value = String } = res5
+  val chk6: C1[String, String] & D1[String, String] = chk5
+  val chk7: (C1 & D1) { type Elem = String; type Value = String } = chk6
 }
 
-// Adapated from i94-nada
+// Adapted from i94-nada, somewhat non-sensical
 trait Test1 {
   trait Monad[type Elem] {
     def unit: Elem
@@ -40,7 +70,21 @@ trait Test1 {
   case class Left[A,B](unit: A) extends Either[A,B] with Monad[A]
   case class Right[A,B](unit: B) extends Either[A,B] with Monad[B]
   def flatMap[X,Y,M <: Monad](m: M[Elem = X], f: X => M[Elem = Y]): M[Elem = Y] = f(m.unit)
-  println(flatMap(Left(1), {x: Int => Left(x)}))
+  val res = flatMap(Left(1), {x: Int => Left(x)})
+  val chk: Either[Int, Nothing] & Monad & Product1[Int] = res
+}
+
+// Adapted from i94-nada, this time with more sense
+trait Test2 {
+  trait Monad[type Elem] {
+    def unit: Elem
+  }
+  sealed abstract class Either[A,B]
+  case class Left[type Elem, B](unit: Elem) extends Either[Elem,B] with Monad[Elem]
+  case class Right[A, type Elem](unit: Elem) extends Either[A,Elem] with Monad[Elem]
+  def flatMap[X,Y,M <: Monad](m: M[Elem = X], f: X => M[Elem = Y]): M[Elem = Y] = f(m.unit)
+  val res = flatMap(Left(1), {x: Int => Left(x)})
+  val chk: Left[Int, Nothing] = res
 }