Provide explicit type arguments for Lst

This is needed since otherwise Nothing would be inferred, which screws up
use-site type inference.

Author: odersky

tests/run/lst/Lst.scala

@@ -60,16 +60,16 @@ class Lst[+T](val elems: Any) extends AnyVal {
   }
 
   /** `f` is pulled out, not duplicated */
-  @inline def map[U](@inline f: T => U): Lst[U] = {
+  inline def map[U](inline f: T => U): Lst[U] = {
     def op(x: T) = f(x)
     elems match {
       case null => Empty
       case elems: Array[Any] => def elem(i: Int) = elems(i).asInstanceOf[T]
         val newElems = new Array[Any](elems.length)
         var i = 0
         while (i < elems.length) { newElems(i) = op(elem(i)); i += 1 }
-        new Lst(newElems)
-      case elem: T @ unchecked => new Lst(op(elem))
+        new Lst[U](newElems)
+      case elem: T @ unchecked => new Lst[U](op(elem))
     }
   }
 
@@ -89,8 +89,8 @@ class Lst[+T](val elems: Any) extends AnyVal {
         }
         i += 1
       }
-      if (newElems == null) this.asInstanceOf[Lst[U]] else new Lst(newElems)
-    case elem: T @ unchecked => new Lst(f(elem))
+      if (newElems == null) this.asInstanceOf[Lst[U]] else new Lst[U](newElems)
+    case elem: T @ unchecked => new Lst[U](f(elem))
   }
 
   def flatMap[U](f: T => Lst[U]): Lst[U] = elems match {
@@ -109,21 +109,21 @@ class Lst[+T](val elems: Any) extends AnyVal {
       else if (len == 1) {
         i = 0
         while (newElemss(i) == null) i += 1
-        new Lst(newElemss(i))
+        new Lst[U](newElemss(i))
       }
       else {
         val newElems = new Array[Any](len)
         i = 0
         var j = 0
         while (i < newElemss.length) {
-          val ys = new Lst(newElemss(i))
+          val ys = new Lst[U](newElemss(i))
           ys.copyToArray(newElems, j)
           j += ys.length
           i += 1
         }
-        new Lst(newElems)
+        new Lst[U](newElems)
       }
-    case elem: T @ unchecked => new Lst(f(elem).elems)
+    case elem: T @ unchecked => new Lst[U](f(elem).elems)
   }
 
   def filter(p: T => Boolean): Lst[T] = elems match {
@@ -214,7 +214,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
         newElems(elems.length - 1 - i) = elem(i)
         i += 1
       }
-      new Lst(newElems)
+      new Lst[T](newElems)
     case _ => this
   }
 
@@ -252,7 +252,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
       val newElems = new Array[Any](len1 + len2)
       this.copyToArray(newElems, 0)
       that.copyToArray(newElems, len1)
-      new Lst(newElems)
+      new Lst[U](newElems)
     }
 
   def zipWith[U, V](that: Lst[U])(op: (T, U) => V): Lst[V] =
@@ -264,7 +264,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
           case elems2: Array[Any] => def elem2(i: Int) = elems2(i).asInstanceOf[U]
             val len = elems1.length min elems2.length
             if (len == 0) Empty
-            else if (len == 1) new Lst(op(elem1(0), elem2(0)))
+            else if (len == 1) new Lst[V](op(elem1(0), elem2(0)))
             else {
               var newElems: Array[Any] = null
               var i = 0
@@ -279,17 +279,17 @@ class Lst[+T](val elems: Any) extends AnyVal {
                 }
                 i += 1
               }
-              new Lst(newElems)
+              new Lst[V](newElems)
             }
           case elem2: U @unchecked =>
-            new Lst(op(elem1(0), elem2))
+            new Lst[V](op(elem1(0), elem2))
         }
       case elem1: T @unchecked =>
         that.elems match {
           case null => Empty
           case elems2: Array[Any] => def elem2(i: Int) = elems2(i).asInstanceOf[U]
-            new Lst(op(elem1, elem2(0)))
-          case elem2: U @unchecked => new Lst(op(elem1, elem2))
+            new Lst[V](op(elem1, elem2(0)))
+          case elem2: U @unchecked => new Lst[V](op(elem1, elem2))
         }
     }
 
@@ -301,9 +301,9 @@ class Lst[+T](val elems: Any) extends AnyVal {
       val newElems = new Array[Any](elems.length)
       var i = 0
       while (i < elems.length) { newElems(i) = (elem(i), i); i += 1 }
-      new Lst(newElems)
+      new Lst[(T, Int)](newElems)
     case elem: T @unchecked =>
-      new Lst((elem, 0))
+      new Lst[(T, Int)]((elem, 0))
   }
 
   def corresponds[U](that: Lst[U])(p: (T, U) => Boolean): Boolean =
@@ -377,25 +377,25 @@ object Lst {
   private def eq(x: Any, y: Any) = x.asInstanceOf[AnyRef] `eq` y.asInstanceOf[AnyRef]
   private val eqFn = (x: Any, y: Any) => eq(x, y)
 
-  val Empty = new Lst(null)
+  val Empty = new Lst[Nothing](null)
 
   def apply[T](): Lst[T] = Empty
 
-  def apply[T](x0: T): Lst[T] = new Lst(x0)
+  def apply[T](x0: T): Lst[T] = new Lst[T](x0)
 
   def apply[T](x0: T, x1: T): Lst[T] = {
     val elems = new Arr(2)
     elems(0) = x0
     elems(1) = x1
-    new Lst(elems)
+    new Lst[T](elems)
   }
 
   def apply[T](x0: T, x1: T, x2: T): Lst[T] = {
     val elems = new Arr(3)
     elems(0) = x0
     elems(1) = x1
     elems(2) = x2
-    new Lst(elems)
+    new Lst[T](elems)
   }
 
   def apply[T](x0: T, x1: T, x2: T, x3: T): Lst[T] = {
@@ -404,7 +404,7 @@ object Lst {
     elems(1) = x1
     elems(2) = x2
     elems(3) = x3
-    new Lst(elems)
+    new Lst[T](elems)
   }
 
   def apply[T](x0: T, x1: T, x2: T, x3: T, x4: T, xs: T*): Lst[T] = {
@@ -415,14 +415,14 @@ object Lst {
     elems(3) = x3
     elems(4) = x4
     xs.copyToArray(elems, 5)
-    new Lst(elems)
+    new Lst[T](elems)
   }
 
   def fill[T](n: Int)(elem: => T) = {
     val elems = new Arr(n)
     var i = 0
     while (i < n) { elems(i) = elem; i += 1}
-    new Lst(elems)
+    new Lst[T](elems)
   }
 
   class Buffer[T] {
@@ -471,7 +471,7 @@ object Lst {
 
     def toLst: Lst[T] =
       if (len == 0) Empty
-      else if (len == 1) new Lst(elem)
+      else if (len == 1) new Lst[T](elem)
       else _fromArray(elems, 0, len)
 
     def clear() =
@@ -481,12 +481,12 @@ object Lst {
   private def _fromArray[T](elems: Arr, start: Int, end: Int): Lst[T] = {
     val len = end - start
     if (len <= 0) Empty
-    else if (len == 1) new Lst(elems(start))
-    else if (start == 0 && end == elems.length) new Lst(elems)
+    else if (len == 1) new Lst[T](elems(start))
+    else if (start == 0 && end == elems.length) new Lst[T](elems)
     else {
       val newElems = new Arr(len)
       System.arraycopy(elems, start, newElems, 0, len)
-      new Lst(newElems)
+      new Lst[T](newElems)
     }
   }