diff options
author | Paul Phillips <paulp@improving.org> | 2009-05-12 14:30:04 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2009-05-12 14:30:04 +0000 |
commit | e326df2c225eefcfd058e19963d3a7fdf366637d (patch) | |
tree | f057e66f66925670a1aea6761e33e174d95365b0 /src/library/scala/Ordering.scala | |
parent | 93ce8b0c6cb98c3bb9cb1ab67e17c678ff86ab1a (diff) | |
download | scala-e326df2c225eefcfd058e19963d3a7fdf366637d.tar.gz scala-e326df2c225eefcfd058e19963d3a7fdf366637d.tar.bz2 scala-e326df2c225eefcfd058e19963d3a7fdf366637d.zip |
This patch includes the following:
1) Default Ordering implementations for various built-in types,
supplied by DrMacIver. Ticket #1303. 2) Implicits for scala.Numeric
and scala.Ordering so classes implementing those can use punctuation
and, more importantly,
infix notation. Compare "minus(plus(x, y), z)" to "x + y - z".
3) A generic implementation of Range, but leaving the original
Int-only Range untouched. A LongRange.
4) Numeric and Ordering implementations of BigInt, as required
for the new BigIntRange. Ticket #931.
5) Numeric implementations for built-in types changed to the
trait + implicit-object-extends-trait model so the implementation
can be mixed into other objects - in particular one might easily
want to combine Numeric[T] and Ordering[T] in one object.
6) Assorted tweaks to support all the above.
Diffstat (limited to 'src/library/scala/Ordering.scala')
-rw-r--r-- | src/library/scala/Ordering.scala | 245 |
1 files changed, 245 insertions, 0 deletions
diff --git a/src/library/scala/Ordering.scala b/src/library/scala/Ordering.scala index 9b18cb7e0c..663af258dd 100644 --- a/src/library/scala/Ordering.scala +++ b/src/library/scala/Ordering.scala @@ -71,4 +71,249 @@ trait Ordering[T] extends PartialOrdering[T] { * <code>y</code> in the ordering. */ override def equiv(x: T, y: T): Boolean = compare(x, y) == 0 + + class Ops(lhs: T) { + def <(rhs: T) = lt(lhs, rhs) + def <=(rhs: T) = lteq(lhs, rhs) + def >(rhs: T) = gt(lhs, rhs) + def >=(rhs: T) = gteq(lhs, rhs) + def ===(rhs: T) = equiv(lhs, rhs) + def !==(rhs: T) = !equiv(lhs, rhs) + } + implicit def mkOrderingOps(lhs: T): Ops = new Ops(lhs) +} + +object Ordering +{ + def apply[T](implicit ord : Ordering[T]) = ord + + implicit val Unit : Ordering[Unit] = new Ordering[Unit] { + def compare(x : Unit, y : Unit) = 0; + } + + implicit val Boolean : Ordering[Boolean] = new Ordering[Boolean] { + def compare(x : Boolean, y : Boolean) = (x, y) match { + case (false, true) => -1; + case (true, false) => 1; + case _ => 0; + } + } + + implicit val Byte : Ordering[Byte] = new Ordering[Byte] { + def compare(x : Byte, y : Byte) = x.toInt - y.toInt; + } + + implicit val Char : Ordering[Char] = new Ordering[Char] { + def compare(x : Char, y : Char) = x.toInt - y.toInt; + } + + implicit val Short : Ordering[Short] = new Ordering[Short] { + def compare(x : Short, y : Short) = x.toInt - y.toInt; + } + + implicit val Int : Ordering[Int] = new Ordering[Int] { + def compare(x : Int, y : Int) = + if(x < y) -1; + else if (x == y) 0; + else 1 + } + + implicit val Long : Ordering[Long] = new Ordering[Long] { + def compare(x : Long, y : Long) = + if(x < y) -1; + else if (x == y) 0; + else 1 + } + + implicit val Float : Ordering[Float] = new Ordering[Float] { + def compare(x : Float, y : Float) = + if(x < y) -1; + else if (x == y) 0; + else 1 + } + + implicit val Double : Ordering[Double] = new Ordering[Double] { + def compare(x : Double, y : Double) = + if(x < y) -1; + else if (x == y) 0; + else 1 + } + + implicit val BigInt : Ordering[BigInt] = new Ordering[BigInt] { + def compare(x : BigInt, y : BigInt) = x.compare(y); + } + + implicit val String : Ordering[String] = new Ordering[String] { + def compare(x : String, y : String) = x.compareTo(y); + } + + implicit def Option[T](implicit ord : Ordering[T]) : Ordering[Option[T]] = + new Ordering[Option[T]] { + def compare(x : Option[T], y : Option[T]) = (x, y) match { + case (None, None) => 0; + case (None, _) => -1; + case (_, None) => 1 + case (Some(x), Some(y)) => ord.compare(x, y); + } + } + + implicit def Iterable[T](implicit ord : Ordering[T]) : Ordering[Iterable[T]] = + new Ordering[Iterable[T]] { + def compare(x : Iterable[T], y : Iterable[T]) : Int = { + val xe = x.elements; + val ye = y.elements; + + while (xe.hasNext && ye.hasNext){ + val res = ord.compare(xe.next, ye.next); + if (res != 0) return res; + } + + Boolean.compare(xe.hasNext, ye.hasNext); + } + } + + implicit def Tuple2[T1, T2](implicit ord1 : Ordering[T1], ord2 : Ordering[T2]) : Ordering[(T1, T2)] = + new Ordering[(T1, T2)]{ + def compare(x : Tuple2[T1, T2], y : Tuple2[T1, T2]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + 0; + } + } + + implicit def Tuple3[T1, T2, T3](implicit ord1 : Ordering[T1], ord2 : Ordering[T2], ord3 : Ordering[T3]) : Ordering[(T1, T2, T3)] = + new Ordering[(T1, T2, T3)]{ + def compare(x : Tuple3[T1, T2, T3], y : Tuple3[T1, T2, T3]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + val compare3 = ord3.compare(x._3, y._3); + if (compare3 != 0) return compare3; + 0; + } + } + + implicit def Tuple4[T1, T2, T3, T4](implicit ord1 : Ordering[T1], ord2 : Ordering[T2], ord3 : Ordering[T3], ord4 : Ordering[T4]) : Ordering[(T1, T2, T3, T4)] = + new Ordering[(T1, T2, T3, T4)]{ + def compare(x : Tuple4[T1, T2, T3, T4], y : Tuple4[T1, T2, T3, T4]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + val compare3 = ord3.compare(x._3, y._3); + if (compare3 != 0) return compare3; + val compare4 = ord4.compare(x._4, y._4); + if (compare4 != 0) return compare4; + 0; + } + } + + implicit def Tuple5[T1, T2, T3, T4, T5](implicit ord1 : Ordering[T1], ord2 : Ordering[T2], ord3 : Ordering[T3], ord4 : Ordering[T4], ord5 : Ordering[T5]) : Ordering[(T1, T2, T3, T4, T5)] = + new Ordering[(T1, T2, T3, T4, T5)]{ + def compare(x : Tuple5[T1, T2, T3, T4, T5], y : Tuple5[T1, T2, T3, T4, T5]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + val compare3 = ord3.compare(x._3, y._3); + if (compare3 != 0) return compare3; + val compare4 = ord4.compare(x._4, y._4); + if (compare4 != 0) return compare4; + val compare5 = ord5.compare(x._5, y._5); + if (compare5 != 0) return compare5; + 0; + } + } + + implicit def Tuple6[T1, T2, T3, T4, T5, T6](implicit ord1 : Ordering[T1], ord2 : Ordering[T2], ord3 : Ordering[T3], ord4 : Ordering[T4], ord5 : Ordering[T5], ord6 : Ordering[T6]) : Ordering[(T1, T2, T3, T4, T5, T6)] = + new Ordering[(T1, T2, T3, T4, T5, T6)]{ + def compare(x : Tuple6[T1, T2, T3, T4, T5, T6], y : Tuple6[T1, T2, T3, T4, T5, T6]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + val compare3 = ord3.compare(x._3, y._3); + if (compare3 != 0) return compare3; + val compare4 = ord4.compare(x._4, y._4); + if (compare4 != 0) return compare4; + val compare5 = ord5.compare(x._5, y._5); + if (compare5 != 0) return compare5; + val compare6 = ord6.compare(x._6, y._6); + if (compare6 != 0) return compare6; + 0; + } + } + + implicit def Tuple7[T1, T2, T3, T4, T5, T6, T7](implicit ord1 : Ordering[T1], ord2 : Ordering[T2], ord3 : Ordering[T3], ord4 : Ordering[T4], ord5 : Ordering[T5], ord6 : Ordering[T6], ord7 : Ordering[T7]) : Ordering[(T1, T2, T3, T4, T5, T6, T7)] = + new Ordering[(T1, T2, T3, T4, T5, T6, T7)]{ + def compare(x : Tuple7[T1, T2, T3, T4, T5, T6, T7], y : Tuple7[T1, T2, T3, T4, T5, T6, T7]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + val compare3 = ord3.compare(x._3, y._3); + if (compare3 != 0) return compare3; + val compare4 = ord4.compare(x._4, y._4); + if (compare4 != 0) return compare4; + val compare5 = ord5.compare(x._5, y._5); + if (compare5 != 0) return compare5; + val compare6 = ord6.compare(x._6, y._6); + if (compare6 != 0) return compare6; + val compare7 = ord7.compare(x._7, y._7); + if (compare7 != 0) return compare7; + 0; + } + } + + implicit def Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](implicit ord1 : Ordering[T1], ord2 : Ordering[T2], ord3 : Ordering[T3], ord4 : Ordering[T4], ord5 : Ordering[T5], ord6 : Ordering[T6], ord7 : Ordering[T7], ord8 : Ordering[T8]) : Ordering[(T1, T2, T3, T4, T5, T6, T7, T8)] = + new Ordering[(T1, T2, T3, T4, T5, T6, T7, T8)]{ + def compare(x : Tuple8[T1, T2, T3, T4, T5, T6, T7, T8], y : Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + val compare3 = ord3.compare(x._3, y._3); + if (compare3 != 0) return compare3; + val compare4 = ord4.compare(x._4, y._4); + if (compare4 != 0) return compare4; + val compare5 = ord5.compare(x._5, y._5); + if (compare5 != 0) return compare5; + val compare6 = ord6.compare(x._6, y._6); + if (compare6 != 0) return compare6; + val compare7 = ord7.compare(x._7, y._7); + if (compare7 != 0) return compare7; + val compare8 = ord8.compare(x._8, y._8); + if (compare8 != 0) return compare8; + 0; + } + } + + implicit def Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](implicit ord1 : Ordering[T1], ord2 : Ordering[T2], ord3 : Ordering[T3], ord4 : Ordering[T4], ord5 : Ordering[T5], ord6 : Ordering[T6], ord7 : Ordering[T7], ord8 : Ordering[T8], ord9 : Ordering[T9]) : Ordering[(T1, T2, T3, T4, T5, T6, T7, T8, T9)] = + new Ordering[(T1, T2, T3, T4, T5, T6, T7, T8, T9)]{ + def compare(x : Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9], y : Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) : Int = { + val compare1 = ord1.compare(x._1, y._1); + if (compare1 != 0) return compare1; + val compare2 = ord2.compare(x._2, y._2); + if (compare2 != 0) return compare2; + val compare3 = ord3.compare(x._3, y._3); + if (compare3 != 0) return compare3; + val compare4 = ord4.compare(x._4, y._4); + if (compare4 != 0) return compare4; + val compare5 = ord5.compare(x._5, y._5); + if (compare5 != 0) return compare5; + val compare6 = ord6.compare(x._6, y._6); + if (compare6 != 0) return compare6; + val compare7 = ord7.compare(x._7, y._7); + if (compare7 != 0) return compare7; + val compare8 = ord8.compare(x._8, y._8); + if (compare8 != 0) return compare8; + val compare9 = ord9.compare(x._9, y._9); + if (compare9 != 0) return compare9; + 0; + } + } + } |