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

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.

An ordering which caches the value of its reverse.

Source
Ordering.scala
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.

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
}
Source
Ordering.scala
object Float

Orderings for Floats.

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
}
Source
Ordering.scala
object Implicits extends ExtraImplicits

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

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

Source
Ordering.scala
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

Value members

Concrete methods

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

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

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.

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

Construct an Ordering[T] given a function lt.

Construct an Ordering[T] given a function lt.

Source
Ordering.scala

Implicits

Implicits

implicit
def Option[T](implicit ord: Ordering[T]): Ordering[Option[T]]
implicit
def Tuple2[T1, T2](implicit ord1: Ordering[T1], ord2: Ordering[T2]): Ordering[(T1, T2)]
implicit
def Tuple3[T1, T2, T3](implicit ord1: Ordering[T1], ord2: Ordering[T2], ord3: Ordering[T3]): Ordering[(T1, T2, T3)]
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)]
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)]
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)]
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)]
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)]
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)]

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](implicit 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 comparatorToOrdering[A](implicit cmp: Comparator[A]): Ordering[A]
implicit
def ordered[A](implicit 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.

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.

Inherited from
LowPriorityOrderingImplicits
Source
Ordering.scala