part 2 of the dependent method refactoring: imp...

part 2 of the dependent method refactoring: improved interaction with
implicit search (needed for oopsla paper)

more to come in this area, see e.g. #3346 (stanford edsl stuff)

reopens #13, which wasn't fixed properly before imo, anyway (have a look at -Xprint:typer output before this commit: a type that's not expressible in surface syntax is inferred -- also removed duplicate test file)

closes #3731: co-evolve type alias type symbols when their rhs is
updated and they are referenced by type selections (see typemap)

review by odersky

1 files changed, 29 insertions, 0 deletions

diff --git a/test/files/pos/depmet_implicit_norm_ret.scala b/test/files/pos/depmet_implicit_norm_ret.scala
new file mode 100644
index 0000000000..4cdb2931c6
--- /dev/null
+++ b/test/files/pos/depmet_implicit_norm_ret.scala
@@ -0,0 +1,29 @@
+object Test{
+  def ?[S <: AnyRef](implicit w : S) : w.type = w
+
+  // fallback, lower priority (overloading rules apply: pick alternative in subclass lowest in subtyping lattice)
+  class ZipWithDefault {
+    implicit def ZeroZipWith[S] = new ZipWith[S] {
+      type T = Stream[S]
+    }
+  }
+
+  object ZipWith extends ZipWithDefault {
+    // def apply[S: ZipWith](s : S) = ?[ZipWith[S]].zipWith(s) // TODO: bug return type should be inferred
+    def apply[S](s : S)(implicit zw: ZipWith[S]): zw.T = zw.zipWith(s)
+
+    implicit def SuccZipWith[S,R](implicit zWith : ZipWith[R]) = new ZipWith[S => R] {
+      type T = Stream[S] => zWith.T // dependent types replace the associated types functionality
+    }
+  }
+
+  trait ZipWith[S] {
+    type T
+    def zipWith : S => T = error("")
+  }
+
+  // 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"))
+}
\ No newline at end of file