From ffac03ab718637c414f5e23524f458b4f4e8f817 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 23 Jun 2015 11:59:28 +0200 Subject: Handle normalization of implicit dependent methods. Now handles included test if toplevel implicit is given, but not yet without. --- tests/pending/pos/depmet_implicit_chaining_zw.scala | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'tests/pending') diff --git a/tests/pending/pos/depmet_implicit_chaining_zw.scala b/tests/pending/pos/depmet_implicit_chaining_zw.scala index a9da1e976..f0e8a373b 100644 --- a/tests/pending/pos/depmet_implicit_chaining_zw.scala +++ b/tests/pending/pos/depmet_implicit_chaining_zw.scala @@ -22,7 +22,11 @@ object ZipWith { // thus, I present ?: implicitly on steroids! def ?[T <: AnyRef](implicit w: T): w.type = w + type _0 = Zero + type _1 = Succ[Zero] type _2 = Succ[Succ[Zero]] - val zw = ?[ZipWith[_2, Int => String => Boolean]].x // : Stream[Int] => Stream[String] => Stream[Boolean] + val zw = ?[ZipWith[_2, Int => String => Boolean]]( + SuccZipWith[_1, Int, String => Boolean]( + SuccZipWith[_0, String, Boolean])).x // val zw = implicitly[ZipWith[Succ[Succ[Zero]], Int => String => Boolean]{type T = Stream[Int] => Stream[String] => Stream[Boolean]}].x } -- cgit v1.2.3 From 1e9ffd45ed3c7782ae2f21ed0361e776a122897b Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 25 Jun 2015 09:47:26 +0200 Subject: Add test from pending. --- .../pending/pos/depmet_implicit_chaining_zw.scala | 32 ---------------------- tests/pos/depmet_implicit_chaining_zw.scala | 32 ++++++++++++++++++++++ 2 files changed, 32 insertions(+), 32 deletions(-) delete mode 100644 tests/pending/pos/depmet_implicit_chaining_zw.scala create mode 100644 tests/pos/depmet_implicit_chaining_zw.scala (limited to 'tests/pending') diff --git a/tests/pending/pos/depmet_implicit_chaining_zw.scala b/tests/pending/pos/depmet_implicit_chaining_zw.scala deleted file mode 100644 index f0e8a373b..000000000 --- a/tests/pending/pos/depmet_implicit_chaining_zw.scala +++ /dev/null @@ -1,32 +0,0 @@ -trait Zero -trait Succ[N] - -trait ZipWith[N, S] { - type T - val x: T = sys.error("") -} - -object ZipWith { - implicit def ZeroZipWith[S]: ZipWith[Zero,S]{type T = Stream[S]} = new ZipWith[Zero, S] { - type T = Stream[S] - } - - implicit def SuccZipWith[N, S, R](implicit zWith : ZipWith[N, R]): ZipWith[Succ[N],S => R]{type T = Stream[S] => zWith.T} = new ZipWith[Succ[N], S => R] { - type T = Stream[S] => zWith.T // dependent types replace the associated types functionality - } - - // can't use implicitly[ZipWith[Succ[Succ[Zero]], Int => String => Boolean]], - // since that will chop of the {type T = ... } refinement in adapt (pt = ZipWith[Succ[Succ[Zero]], Int => String => Boolean]) - // this works - // def zipWith(implicit zw: ZipWith[Succ[Succ[Zero]], Int => String => Boolean]): zw.T = zw.x - // thus, I present ?: implicitly on steroids! - def ?[T <: AnyRef](implicit w: T): w.type = w - - type _0 = Zero - type _1 = Succ[Zero] - type _2 = Succ[Succ[Zero]] - val zw = ?[ZipWith[_2, Int => String => Boolean]]( - SuccZipWith[_1, Int, String => Boolean]( - SuccZipWith[_0, String, Boolean])).x - // val zw = implicitly[ZipWith[Succ[Succ[Zero]], Int => String => Boolean]{type T = Stream[Int] => Stream[String] => Stream[Boolean]}].x -} diff --git a/tests/pos/depmet_implicit_chaining_zw.scala b/tests/pos/depmet_implicit_chaining_zw.scala new file mode 100644 index 000000000..f0e8a373b --- /dev/null +++ b/tests/pos/depmet_implicit_chaining_zw.scala @@ -0,0 +1,32 @@ +trait Zero +trait Succ[N] + +trait ZipWith[N, S] { + type T + val x: T = sys.error("") +} + +object ZipWith { + implicit def ZeroZipWith[S]: ZipWith[Zero,S]{type T = Stream[S]} = new ZipWith[Zero, S] { + type T = Stream[S] + } + + implicit def SuccZipWith[N, S, R](implicit zWith : ZipWith[N, R]): ZipWith[Succ[N],S => R]{type T = Stream[S] => zWith.T} = new ZipWith[Succ[N], S => R] { + type T = Stream[S] => zWith.T // dependent types replace the associated types functionality + } + + // can't use implicitly[ZipWith[Succ[Succ[Zero]], Int => String => Boolean]], + // since that will chop of the {type T = ... } refinement in adapt (pt = ZipWith[Succ[Succ[Zero]], Int => String => Boolean]) + // this works + // def zipWith(implicit zw: ZipWith[Succ[Succ[Zero]], Int => String => Boolean]): zw.T = zw.x + // thus, I present ?: implicitly on steroids! + def ?[T <: AnyRef](implicit w: T): w.type = w + + type _0 = Zero + type _1 = Succ[Zero] + type _2 = Succ[Succ[Zero]] + val zw = ?[ZipWith[_2, Int => String => Boolean]]( + SuccZipWith[_1, Int, String => Boolean]( + SuccZipWith[_0, String, Boolean])).x + // val zw = implicitly[ZipWith[Succ[Succ[Zero]], Int => String => Boolean]{type T = Stream[Int] => Stream[String] => Stream[Boolean]}].x +} -- cgit v1.2.3