Further development of the Numeric and Ordering...

Further development of the Numeric and Ordering traits. Replaced Predef
implicits from everything => Ordered with a single implicit from
Ordering => Ordered.

1 files changed, 3 insertions, 100 deletions

diff --git a/src/dotnet-library/scala/Predef.scala b/src/dotnet-library/scala/Predef.scala
index bfcbc461b3..3212ae50b5 100644
--- a/src/dotnet-library/scala/Predef.scala
+++ b/src/dotnet-library/scala/Predef.scala
@@ -201,106 +201,9 @@ object Predef {
   implicit def classWrapper(clazz: Class[_]): runtime.RichClass =
     new runtime.RichClass(clazz)
 
-  implicit def unit2ordered(x: Unit): Ordered[Unit] = new Ordered[Unit] with Proxy {
-    def self: Any = x
-    def compare(y: Unit): Int = 0
-  }
-
-  implicit def iterable2ordered[A <% Ordered[A]](xs: Iterable[A]): Ordered[Iterable[A]] =
-    new Ordered[Iterable[A]] with Proxy {
-      val self = xs
-      def compare(that: Iterable[A]): Int = {
-        var res = 0
-        val these = xs.iterator
-        val those = that.iterator
-        while (res == 0 && these.hasNext)
-          res = if (those.hasNext) these.next compare those.next else 1
-        if (res == 0) {
-          if (those.hasNext) -1 else 0
-        } else
-          res
-      }
-    }
-
-  implicit def tuple22ordered[A1 <% Ordered[A1], A2 <% Ordered[A2]](x: Tuple2[A1, A2]): Ordered[Tuple2[A1, A2]] =
-    new Ordered[Tuple2[A1, A2]] with Proxy {
-      val self = x
-      def compare(y: Tuple2[A1, A2]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) x._2 compare y._2
-        else res
-      }
-    }
-
-  implicit def tuple32ordered[A1 <% Ordered[A1], A2 <% Ordered[A2], A3 <% Ordered[A3]](x: Tuple3[A1, A2, A3]): Ordered[Tuple3[A1, A2, A3]] =
-    new Ordered[Tuple3[A1, A2, A3]] with Proxy {
-      val self = x
-      def compare(y: Tuple3[A1, A2, A3]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) Tuple2(x._2, x._3) compare Tuple2(y._2, y._3)
-        else res
-      }
-    }
-
-  implicit def tuple42ordered[A1 <% Ordered[A1], A2 <% Ordered[A2], A3 <% Ordered[A3], A4 <% Ordered[A4]](x: Tuple4[A1, A2, A3, A4]): Ordered[Tuple4[A1, A2, A3, A4]] =
-    new Ordered[Tuple4[A1, A2, A3, A4]] with Proxy {
-      val self = x
-      def compare(y: Tuple4[A1, A2, A3, A4]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) Tuple3(x._2, x._3, x._4) compare Tuple3(y._2, y._3, y._4)
-        else res
-      }
-    }
-
-  implicit def tuple52ordered[A1 <% Ordered[A1], A2 <% Ordered[A2], A3 <% Ordered[A3], A4 <% Ordered[A4], A5 <% Ordered[A5]](x: Tuple5[A1, A2, A3, A4, A5]): Ordered[Tuple5[A1, A2, A3, A4, A5]] =
-    new Ordered[Tuple5[A1, A2, A3, A4, A5]] with Proxy {
-      val self = x
-      def compare(y: Tuple5[A1, A2, A3, A4, A5]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) Tuple4(x._2, x._3, x._4, x._5) compare Tuple4(y._2, y._3, y._4, y._5)
-        else res
-      }
-    }
-
-  implicit def tuple62ordered[A1 <% Ordered[A1], A2 <% Ordered[A2], A3 <% Ordered[A3], A4 <% Ordered[A4], A5 <% Ordered[A5], A6 <% Ordered[A6]](x: Tuple6[A1, A2, A3, A4, A5, A6]): Ordered[Tuple6[A1, A2, A3, A4, A5, A6]] =
-    new Ordered[Tuple6[A1, A2, A3, A4, A5, A6]] with Proxy {
-      val self = x
-      def compare(y: Tuple6[A1, A2, A3, A4, A5, A6]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) Tuple5(x._2, x._3, x._4, x._5, x._6) compare Tuple5(y._2, y._3, y._4, y._5, y._6)
-        else res
-      }
-    }
-
-  implicit def tuple72ordered[A1 <% Ordered[A1], A2 <% Ordered[A2], A3 <% Ordered[A3], A4 <% Ordered[A4], A5 <% Ordered[A5], A6 <% Ordered[A6], A7 <% Ordered[A7]](x: Tuple7[A1, A2, A3, A4, A5, A6, A7]): Ordered[Tuple7[A1, A2, A3, A4, A5, A6, A7]] =
-    new Ordered[Tuple7[A1, A2, A3, A4, A5, A6, A7]] with Proxy {
-      val self = x
-      def compare(y: Tuple7[A1, A2, A3, A4, A5, A6, A7]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) Tuple6(x._2, x._3, x._4, x._5, x._6, x._7) compare Tuple6(y._2, y._3, y._4, y._5, y._6, y._7)
-        else res
-      }
-    }
-
-  implicit def tuple82ordered[A1 <% Ordered[A1], A2 <% Ordered[A2], A3 <% Ordered[A3], A4 <% Ordered[A4], A5 <% Ordered[A5], A6 <% Ordered[A6], A7 <% Ordered[A7], A8 <% Ordered[A8]](x: Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]): Ordered[Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]] =
-    new Ordered[Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]] with Proxy {
-      val self = x
-      def compare(y: Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) Tuple7(x._2, x._3, x._4, x._5, x._6, x._7, x._8) compare Tuple7(y._2, y._3, y._4, y._5, y._6, y._7, y._8)
-        else res
-      }
-    }
-
-  implicit def tuple92ordered[A1 <% Ordered[A1], A2 <% Ordered[A2], A3 <% Ordered[A3], A4 <% Ordered[A4], A5 <% Ordered[A5], A6 <% Ordered[A6], A7 <% Ordered[A7], A8 <% Ordered[A8], A9 <% Ordered[A9]](x: Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]): Ordered[Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]] =
-    new Ordered[Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]] with Proxy {
-      val self = x
-      def compare(y: Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]): Int = {
-        val res = x._1 compare y._1
-        if (res == 0) Tuple8(x._2, x._3, x._4, x._5, x._6, x._7, x._8, x._9) compare Tuple8(y._2, y._3, y._4, y._5, y._6, y._7, y._8, y._9)
-        else res
-      }
-    }
+  /** Lens from Ordering[T] to Ordered[T] */
+  implicit def orderingToOrdered[T](x: T)(implicit ord: Ordering[T]): Ordered[T] =
+    new Ordered[T] { def compare(that: T): Int = ord.compare(x, that) }
 
   implicit def byte2short(x: Byte): Short = x.toShort
   implicit def byte2int(x: Byte): Int = x.toInt