Dependent method tests

2 files changed, 7 insertions, 46 deletions

diff --git a/tests/pending/pos/depmet_implicit_norm_ret.scala b/tests/pending/pos/depmet_implicit_norm_ret.scala
index 85be750b4..42bfb9fe1 100644
--- a/tests/pending/pos/depmet_implicit_norm_ret.scala
+++ b/tests/pending/pos/depmet_implicit_norm_ret.scala
@@ -17,6 +17,8 @@ object Test{
     }
   }
 
+  import ZipWith._
+
   trait ZipWith[S] {
     type T
     def zipWith : S => T = sys.error("")
@@ -24,6 +26,9 @@ object Test{
 
   // bug: inferred return type = (Stream[A]) => java.lang.Object with Test.ZipWith[B]{type T = Stream[B]}#T
   // this seems incompatible with vvvvvvvvvvvvvvvvvvvvvv   -- #3731
-  def map[A,B](f : A => B)   /* : Stream[A] => Stream[B]*/ = ZipWith(f)
-  val tst: Stream[Int] = map{x: String => x.length}(Stream("a"))
+  def map1[A,B](f : A => B) = ZipWith(f)(SuccZipWith) // this typechecks but fails in -Ycheck:first
+  val tst1: Stream[Int] = map1[String, Int]{x: String => x.length}.apply(Stream("a"))
+
+  def map2[A,B](f : A => B) = ZipWith(f) // this finds ZeroZipWith where scalac finds SuccZipWith and fails typechecking in the next line.
+  val tst2: Stream[Int] = map2{x: String => x.length}.apply(Stream("a"))
 }
diff --git a/tests/pending/pos/depmet_implicit_oopsla_zipwith.scala b/tests/pending/pos/depmet_implicit_oopsla_zipwith.scala
deleted file mode 100644
index 83171f865..000000000
--- a/tests/pending/pos/depmet_implicit_oopsla_zipwith.scala
+++ /dev/null
@@ -1,44 +0,0 @@
-case class Zero()
-case class Succ[N](x: N)
-import Stream.{cons, continually}
-
-trait ZipWith[N, S] {
-  type T
-
-  def manyApp: N => Stream[S] => T
-  def zipWith: N => S => T = n => f => manyApp(n)(continually(f))
-}
-object ZipWith {
-  implicit def ZeroZipWith[S]: ZipWith[Zero,S]{type T = Stream[S]} = new ZipWith[Zero, S] {
-    type T = Stream[S]
-
-    def manyApp = n => xs => xs
-  }
-
-  implicit def SuccZipWith[N, S, R](implicit zw: ZipWith[N, R]): ZipWith[Succ[N],S => R]{type T = Stream[S] => zw.T; def zapp[A, B](xs: Stream[A => B],ys: Stream[A]): Stream[B]} =
-    new ZipWith[Succ[N],S => R] {
-      type T = Stream[S] => zw.T
-
-      def zapp[A, B](xs: Stream[A => B], ys: Stream[A]): Stream[B] = (xs, ys) match {
-        case (cons(f, fs), cons(s, ss)) => cons(f(s),zapp(fs, ss))
-        case (_, _) => Stream.empty
-      }
-
-      def manyApp = n => xs => ss => n match {
-        case Succ(i) => zw.manyApp(i)(zapp(xs, ss))
-      }
-    }
-}
-
-object Test {
-  def zWith[N, S](n: N, s: S)(implicit zw: ZipWith[N, S]): zw.T = zw.zipWith(n)(s)
-
-  def zipWith0: Stream[Int] = zWith(Zero(),0)
-
-// (Stream[A]) => java.lang.Object with ZipWith[Zero,B]{type T = Stream[B]}#T
-// should normalise to: Stream[A] => Stream[B]
-  def map[A, B](f: A => B) = zWith(Succ(Zero()),f)
-
-  def zipWith3[A, B, C, D](f: A => B => C => D) = //: Stream[A] => Stream[B] => Stream[C] => Stream[D] = // BUG why do we need a return type?
-    zWith(Succ(Succ(Succ(Zero()))),f)
-}