From aa2f9078d76a21d828a06b8e324d31a502ee505c Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Wed, 8 Mar 2017 22:06:22 +0100 Subject: Drop special case around Function1 Now only Scala2 mode treats Function1's as implicit conversions. Instead we introduce a new subclass ImplicitConverter of Function1, instances of which are turned into implicit conversions. --- tests/pos-scala2/typerep-stephane.scala | 48 +++++++++++++++++++++++++++++++++ tests/pos-scala2/viewtest1.scala | 42 +++++++++++++++++++++++++++++ tests/pos/t0786.scala | 2 +- tests/pos/typerep-stephane.scala | 48 --------------------------------- tests/pos/viewtest1.scala | 42 ----------------------------- tests/run/iterator-from.scala | 6 +++-- tests/run/t8280.scala | 6 ++--- 7 files changed, 98 insertions(+), 96 deletions(-) create mode 100644 tests/pos-scala2/typerep-stephane.scala create mode 100644 tests/pos-scala2/viewtest1.scala delete mode 100644 tests/pos/typerep-stephane.scala delete mode 100644 tests/pos/viewtest1.scala (limited to 'tests') diff --git a/tests/pos-scala2/typerep-stephane.scala b/tests/pos-scala2/typerep-stephane.scala new file mode 100644 index 000000000..2cb899591 --- /dev/null +++ b/tests/pos-scala2/typerep-stephane.scala @@ -0,0 +1,48 @@ +object typerep { + + class TypeRep[T] { + def getType: TypeRep[T] = this + } + + object BooleanRep extends TypeRep[Boolean] { + override def toString = "Boolean" + } + object CharRep extends TypeRep[Char] { + override def toString = "Char" + } + object IntRep extends TypeRep[Int] { + override def toString = "Int" + } + object LongRep extends TypeRep[Long] { + override def toString = "Long" + } + object FloatRep extends TypeRep[Float] { + override def toString = "Float" + } + object DoubleRep extends TypeRep[Double] { + override def toString = "Double" + } + class ListRep[U, T <: List[U]](val elemRep: TypeRep[U]) extends TypeRep[T] { + override def toString = "List[" + elemRep + "]" + } + + implicit def typeRep(x: Boolean): TypeRep[Boolean] = BooleanRep + implicit def typeRep(x: Char ): TypeRep[Char ] = CharRep + implicit def typeRep(x: Long ): TypeRep[Long ] = LongRep + implicit def typeRep(x: Float ): TypeRep[Float ] = FloatRep + implicit def typeRep(x: Double ): TypeRep[Double ] = DoubleRep + implicit def typeRep(x: Int ): TypeRep[Int ] = IntRep +/* + implicit def typeRep[T](xs: List[T])(implicit rep: T => TypeRep[T]): TypeRep[List[T]] = + new ListRep(rep(xs.head)) +*/ + implicit def typeRep[T <% TypeRep[T]](xs: List[T]): TypeRep[List[T]] = + new ListRep(xs.head) + +} + +object test extends App { + import typerep._ + println(3.getType) + println(List(3).getType) +} diff --git a/tests/pos-scala2/viewtest1.scala b/tests/pos-scala2/viewtest1.scala new file mode 100644 index 000000000..38945ad2f --- /dev/null +++ b/tests/pos-scala2/viewtest1.scala @@ -0,0 +1,42 @@ +package test + +trait Ordered[a] { + def < (x: a): Boolean +} + +object O { + implicit def view (x: String): Ordered[String] = new Ordered[String] { + def < (y: String) = x.compareTo(y) < 0 + } +} + +object Empty extends Tree[Nothing] +case class Node[c <% Ordered[c]](elem: c, l: Tree[c], r: Tree[c]) extends Tree[c] + +abstract class Tree[+a <% Ordered[a]] { + def insert[b >: a <% Ordered[b]](x: b): Tree[b] = this match { + case Empty => + new Node(x, Empty, Empty) + case Node(elem, l, r) => + if (x == elem) this + else if (x < elem) Node(elem, l insert x, r) + else Node(elem, l, r insert x) + } + def elements: List[a] = this match { + case Empty => List() + case Node(elem, l, r) => + l.elements ::: List(elem) ::: r.elements + } +} + +object Test { + import O.view + + def main(args: Array[String]): Unit = { + var t: Tree[String] = Empty + for (s <- args) { + t = t insert s + } + println(t.elements) + } +} diff --git a/tests/pos/t0786.scala b/tests/pos/t0786.scala index b320de0ed..9346afdff 100644 --- a/tests/pos/t0786.scala +++ b/tests/pos/t0786.scala @@ -15,7 +15,7 @@ object ImplicitProblem { def eval = f(nullval[T]).eval + 1 } - def depth[T](n: T)(implicit ev: T => Rep[T]) = n.eval + def depth[T](n: T)(implicit ev: T => Rep[T]) = ev(n).eval def main(args: Array[String]): Unit = { println(depth(nullval[M[Int]])) // (1) this works diff --git a/tests/pos/typerep-stephane.scala b/tests/pos/typerep-stephane.scala deleted file mode 100644 index 2cb899591..000000000 --- a/tests/pos/typerep-stephane.scala +++ /dev/null @@ -1,48 +0,0 @@ -object typerep { - - class TypeRep[T] { - def getType: TypeRep[T] = this - } - - object BooleanRep extends TypeRep[Boolean] { - override def toString = "Boolean" - } - object CharRep extends TypeRep[Char] { - override def toString = "Char" - } - object IntRep extends TypeRep[Int] { - override def toString = "Int" - } - object LongRep extends TypeRep[Long] { - override def toString = "Long" - } - object FloatRep extends TypeRep[Float] { - override def toString = "Float" - } - object DoubleRep extends TypeRep[Double] { - override def toString = "Double" - } - class ListRep[U, T <: List[U]](val elemRep: TypeRep[U]) extends TypeRep[T] { - override def toString = "List[" + elemRep + "]" - } - - implicit def typeRep(x: Boolean): TypeRep[Boolean] = BooleanRep - implicit def typeRep(x: Char ): TypeRep[Char ] = CharRep - implicit def typeRep(x: Long ): TypeRep[Long ] = LongRep - implicit def typeRep(x: Float ): TypeRep[Float ] = FloatRep - implicit def typeRep(x: Double ): TypeRep[Double ] = DoubleRep - implicit def typeRep(x: Int ): TypeRep[Int ] = IntRep -/* - implicit def typeRep[T](xs: List[T])(implicit rep: T => TypeRep[T]): TypeRep[List[T]] = - new ListRep(rep(xs.head)) -*/ - implicit def typeRep[T <% TypeRep[T]](xs: List[T]): TypeRep[List[T]] = - new ListRep(xs.head) - -} - -object test extends App { - import typerep._ - println(3.getType) - println(List(3).getType) -} diff --git a/tests/pos/viewtest1.scala b/tests/pos/viewtest1.scala deleted file mode 100644 index 38945ad2f..000000000 --- a/tests/pos/viewtest1.scala +++ /dev/null @@ -1,42 +0,0 @@ -package test - -trait Ordered[a] { - def < (x: a): Boolean -} - -object O { - implicit def view (x: String): Ordered[String] = new Ordered[String] { - def < (y: String) = x.compareTo(y) < 0 - } -} - -object Empty extends Tree[Nothing] -case class Node[c <% Ordered[c]](elem: c, l: Tree[c], r: Tree[c]) extends Tree[c] - -abstract class Tree[+a <% Ordered[a]] { - def insert[b >: a <% Ordered[b]](x: b): Tree[b] = this match { - case Empty => - new Node(x, Empty, Empty) - case Node(elem, l, r) => - if (x == elem) this - else if (x < elem) Node(elem, l insert x, r) - else Node(elem, l, r insert x) - } - def elements: List[a] = this match { - case Empty => List() - case Node(elem, l, r) => - l.elements ::: List(elem) ::: r.elements - } -} - -object Test { - import O.view - - def main(args: Array[String]): Unit = { - var t: Tree[String] = Empty - for (s <- args) { - t = t insert s - } - println(t.elements) - } -} diff --git a/tests/run/iterator-from.scala b/tests/run/iterator-from.scala index 4f403680c..c7c0f9809 100644 --- a/tests/run/iterator-from.scala +++ b/tests/run/iterator-from.scala @@ -11,7 +11,9 @@ object Test extends dotty.runtime.LegacyApp { val maxKey = 50 val maxValue = 50 - def testSet[A <% Ordered[A]](set: SortedSet[A], list: List[A]): Unit = { + implicit def convertIfView[A](x: A)(implicit view: A => Ordered[A]): Ordered[A] = view(x) + + def testSet[A: Ordering](set: SortedSet[A], list: List[A]): Unit = { val distinctSorted = list.distinct.sorted assertEquals("Set size wasn't the same as list sze", set.size, distinctSorted.size) @@ -24,7 +26,7 @@ object Test extends dotty.runtime.LegacyApp { } } - def testMap[A <% Ordered[A], B](map: SortedMap[A, B], list: List[(A, B)]): Unit = { + def testMap[A: Ordering, B](map: SortedMap[A, B], list: List[(A, B)]): Unit = { val distinctSorted = distinctByKey(list).sortBy(_._1) assertEquals("Map size wasn't the same as list sze", map.size, distinctSorted.size) diff --git a/tests/run/t8280.scala b/tests/run/t8280.scala index 1d2c56b85..5fcbad0a3 100644 --- a/tests/run/t8280.scala +++ b/tests/run/t8280.scala @@ -74,14 +74,14 @@ object Moop3 { // Dotty deviation. This fails for Dotty with ambiguity error for similar reasons as ob1. } object ob2 { - implicit val f1: Int => String = _ => "Int" + implicit val f1: ImplicitConverter[Int, String] = _ => "Int" implicit def f2(x: Long): String = "Long" println(5: String) } object ob3 { - implicit val f1: Int => String = _ => "Int" - implicit val f2: Long => String = _ => "Long" + implicit val f1: ImplicitConverter[Int, String] = _ => "Int" + implicit val f2: ImplicitConverter[Long, String] = _ => "Long" println(5: String) } -- cgit v1.2.3