blob: bd84b1a6a2ccaabe16fb974b3a3434a39718da62 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2009, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.math
/** A trait for totally ordered data.
*
* Note that since version 2006-07-24 this trait is no longer covariant in a.
*
* It is important that the equals method for an instance of
* Ordered[A] be consistent with the compare method. However,
* due to limitations inherent in the type erasure semantics,
* there is no reasonable way to provide a default implementation
* of equality for instances of Ordered[A]. Therefore, if you need
* to be able to use equality on an instance of Ordered[A] you must
* provide it yourself either when inheiriting or instantiating.
*
* It is important that the hashCode method for an instance of
* Ordered[A] be consistent with the compare method. However,
* it is not possible to provide a sensible default implementation.
* Therefore, if you need to be able compute the hash of an
* instance of Ordered[A] you must provide it yourself either when
* inheiriting or instantiating.
*
* @author Martin Odersky
* @version 1.1, 2006-07-24
*/
trait Ordered[A] extends java.lang.Comparable[A] {
/** Result of comparing <code>this</code> with operand <code>that</code>.
* returns <code>x</code> where
* <code>x < 0</code> iff <code>this < that</code>
* <code>x == 0</code> iff <code>this == that</code>
* <code>x > 0</code> iff <code>this > that</code>
*/
def compare(that: A): Int
def < (that: A): Boolean = (this compare that) < 0
def > (that: A): Boolean = (this compare that) > 0
def <= (that: A): Boolean = (this compare that) <= 0
def >= (that: A): Boolean = (this compare that) >= 0
def compareTo(that: A): Int = compare(that)
}
object Ordered {
/** 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) }
}
|
