Ordering

This is the companion object for the scala.math.Ordering trait.

It contains many implicit orderings as well as well as methods to construct new orderings.

Companion
class
Source
Ordering.scala
class Object
trait Matchable
class Any

Type members

Classlikes

object BigInt extends BigIntOrdering
object Byte extends ByteOrdering
sealed trait CachedReverse[T] extends Ordering[T]

An ordering which caches the value of its reverse.

object Char extends CharOrdering
@migration(" The default implicit ordering for doubles now maintains consistency\n".+(" between its `compare` method and its `lt`, `min`, `equiv`, etc., methods,\n").+(" which means nonconforming to IEEE 754\'s behavior for -0.0 and NaN.\n").+(" The sort order of doubles remains the same, however, with NaN at the end.\n").+(" Import Ordering.Double.IeeeOrdering to recover the previous behavior.\n").+(" See also https://www.scala-lang.org/api/current/scala/math/Ordering$$Double$.html."), "2.13.0")
@migration(" The default implicit ordering for floats now maintains consistency\n".+(" between its `compare` method and its `lt`, `min`, `equiv`, etc., methods,\n").+(" which means nonconforming to IEEE 754\'s behavior for -0.0F and NaN.\n").+(" The sort order of floats remains the same, however, with NaN at the end.\n").+(" Import Ordering.Float.IeeeOrdering to recover the previous behavior.\n").+(" See also https://www.scala-lang.org/api/current/scala/math/Ordering$$Float$.html."), "2.13.0")
object Double

Orderings for Doubles.

The behavior of the comparison operations provided by the default (implicit) ordering on Double changed in 2.10.0 and 2.13.0. Prior to Scala 2.10.0, the Ordering instance used semantics consistent with java.lang.Double.compare.

Scala 2.10.0 changed the implementation of lt, equiv, min, etc., to be IEEE 754 compliant, while keeping the compare method NOT compliant, creating an internally inconsistent instance. IEEE 754 specifies that 0.0 == -0.0. In addition, it requires all comparisons with Double.NaN return false thus 0.0 < Double.NaN, 0.0 > Double.NaN, and Double.NaN == Double.NaN all yield false, analogous None in flatMap.

Recognizing the limitation of the IEEE 754 semantics in terms of ordering, Scala 2.13.0 created two instances: Ordering.Double.IeeeOrdering, which retains the IEEE 754 semantics from Scala 2.12.x, and Ordering.Double.TotalOrdering, which brings back the java.lang.Double.compare semantics for all operations. The default extends TotalOrdering.

List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).sorted // List(-Infinity, 0.0, 1.0, NaN) List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).min // -Infinity implicitly[Ordering[Double]].lt(0.0, 0.0 / 0.0) // true { import Ordering.Double.IeeeOrdering List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).sorted // List(-Infinity, 0.0, 1.0, NaN) List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).min // NaN implicitly[Ordering[Double]].lt(0.0, 0.0 / 0.0) // false }
object Float

Orderings for Floats.

The behavior of the comparison operations provided by the default (implicit) ordering on Float changed in 2.10.0 and 2.13.0. Prior to Scala 2.10.0, the Ordering instance used semantics consistent with java.lang.Float.compare.

Scala 2.10.0 changed the implementation of lt, equiv, min, etc., to be IEEE 754 compliant, while keeping the compare method NOT compliant, creating an internally inconsistent instance. IEEE 754 specifies that 0.0F == -0.0F. In addition, it requires all comparisons with Float.NaN return false thus 0.0F < Float.NaN, 0.0F > Float.NaN, and Float.NaN == Float.NaN all yield false, analogous None in flatMap.

Recognizing the limitation of the IEEE 754 semantics in terms of ordering, Scala 2.13.0 created two instances: Ordering.Float.IeeeOrdering, which retains the IEEE 754 semantics from Scala 2.12.x, and Ordering.Float.TotalOrdering, which brings back the java.lang.Float.compare semantics for all operations. The default extends TotalOrdering.

List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).sorted // List(-Infinity, 0.0, 1.0, NaN) List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).min // -Infinity implicitly[Ordering[Float]].lt(0.0F, 0.0F / 0.0F) // true { import Ordering.Float.IeeeOrdering List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).sorted // List(-Infinity, 0.0, 1.0, NaN) List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).min // NaN implicitly[Ordering[Float]].lt(0.0F, 0.0F / 0.0F) // false }
object Implicits extends ExtraImplicits

An object containing implicits which are not in the default scope.

object Int extends IntOrdering with CachedReverse[Int]
trait IntOrdering extends Ordering[Int]
object Long extends LongOrdering
trait OptionOrdering[T] extends Ordering[Option[T]]
object Short extends ShortOrdering
object String extends StringOrdering
object Symbol extends SymbolOrdering
object Unit extends UnitOrdering

Inherited types

type AsComparable[A] = A => Comparable[_ >: A]

Value members

Concrete methods

def apply[T](ord: Ordering[T]): Ordering[T]
def by[T, S](f: T => S)(ord: Ordering[S]): Ordering[T]

Given f, a function from T into S, creates an Ordering[T] whose compare function is equivalent to:

def compare(x:T, y:T) = Ordering[S].compare(f(x), f(y))

This function is an analogue to Ordering.on where the Ordering[S] parameter is passed implicitly.

def fromLessThan[T](cmp: (T, T) => Boolean): Ordering[T]

Construct an Ordering[T] given a function lt.

Implicits

Implicits

implicit def Option[T](ord: Ordering[T]): Ordering[Option[T]]
implicit def Tuple2[T1, T2](ord1: Ordering[T1], ord2: Ordering[T2]): Ordering[(T1, T2)]
implicit def Tuple3[T1, T2, T3](ord1: Ordering[T1], ord2: Ordering[T2], ord3: Ordering[T3]): Ordering[(T1, T2, T3)]
implicit def Tuple4[T1, T2, T3, T4](ord1: Ordering[T1], ord2: Ordering[T2], ord3: Ordering[T3], ord4: Ordering[T4]): Ordering[(T1, T2, T3, T4)]
implicit def Tuple5[T1, T2, T3, T4, T5](ord1: Ordering[T1], ord2: Ordering[T2], ord3: Ordering[T3], ord4: Ordering[T4], ord5: Ordering[T5]): Ordering[(T1, T2, T3, T4, T5)]
implicit def Tuple6[T1, T2, T3, T4, T5, T6](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)]
implicit def Tuple7[T1, T2, T3, T4, T5, T6, T7](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)]
implicit def Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](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)]
implicit def Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](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)]

Deprecated implicits

@deprecated("Iterables are not guaranteed to have a consistent order; if using a type with a ".+("consistent order (e.g. Seq), use its Ordering (found in the Ordering.Implicits object)"), since = "2.13.0")
implicit def Iterable[T](ord: Ordering[T]): Ordering[Iterable[T]]
Deprecated
[Since version 2.13.0]

Iterables are not guaranteed to have a consistent order, so the Ordering returned by this method may not be stable or meaningful. If you are using a type with a consistent order (such as Seq), use its Ordering (found in the Implicits object) instead.

Source
Ordering.scala

Inherited implicits

implicit def ordered[A](asComparable: () => A): Ordering[A]

This would conflict with all the nice implicit Orderings available, but thanks to the magic of prioritized implicits via subclassing we can make Ordered[A] => Ordering[A] only turn up if nothing else works. Since Ordered[A] extends Comparable[A] anyway, we can throw in some Java interop too.