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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.math
/** A trait for data that have a single, natural ordering. See
* [[scala.math.Ordering]] before using this trait for
* more information about whether to use [[scala.math.Ordering]] instead.
*
* Classes that implement this trait can be sorted with
* [[scala.utils.Sorting]] and can be compared with standard comparison operators
* (e.g. > and <).
*
* Ordered should be used for data with a single, natural ordering (like
* integers) while Ordering allows for multiple ordering implementations.
* An Ordering instance will be implicitly created if necessary.
*
* [[scala.math.Ordering]] is an alternative to this trait that allows multiple orderings to be
* defined for the same type.
*
* [[scala.math.PartiallyOrdered]] is an alternative to this trait for partially ordered data.
*
* For example, to create a simple class that implements Ordered and then sort it with [[scala.utils.Sorting]]:
* {{{
* class OrderedClass(n:Int) extends Ordered[OrderedClass] {
* def compare(that: OrderedClass) = this.n - that.n
* }
*
* val x = List(new MyClass(1), new MyClass(5), new MyClass(3))
* val result = scala.utils.Sorting.quickSort(x)
* }}}
*
* 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 inheriting 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 inheriting or instantiating.
*
* @see [[scala.math.Ordering]], [[scala.math.PartiallyOrdered]]
* @author Martin Odersky
* @version 1.1, 2006-07-24
*/
trait Ordered[A] extends java.lang.Comparable[A] {
/** Result of comparing `this` with operand `that`.
*
* Implement this method to determine how instances of A will be sorted.
*
* Returns `x` where:
*
* - `x < 0` when `this < that`
*
* - `x == 0` when `this == that`
*
* - `x > 0` when `this > that`
*
*/
def compare(that: A): Int
/** Returns true if `this` is less than `that`
*/
def < (that: A): Boolean = (this compare that) < 0
/** Returns true if `this` is greater than `that`.
*/
def > (that: A): Boolean = (this compare that) > 0
/** Returns true if `this` is less than or equal to `that`.
*/
def <= (that: A): Boolean = (this compare that) <= 0
/** Returns true if `this` is greater than or equal to `that`.
*/
def >= (that: A): Boolean = (this compare that) >= 0
/** Result of comparing `this` with operand `that`.
*/
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) }
}
|