Scala 3/API/scala.math/Ordering

Ordering

object Ordering extends LowPriorityOrderingImplicits

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

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
class Object
trait Matchable
class Any

Type members

Classlikes

object BigDecimal extends BigDecimalOrdering
trait BigDecimalOrdering extends Ordering[BigDecimal]
object BigInt extends BigIntOrdering
trait BigIntOrdering extends Ordering[BigInt]
object Boolean extends BooleanOrdering
trait BooleanOrdering extends Ordering[Boolean]
object Byte extends ByteOrdering
trait ByteOrdering extends Ordering[Byte]
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.

object Char extends CharOrdering
trait CharOrdering extends Ordering[Char]
@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")
object DeprecatedDoubleOrdering extends TotalOrdering
@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 DeprecatedFloatOrdering extends TotalOrdering
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
}
trait ExtraImplicits
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
}
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.

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

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:

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.

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.

Inherited implicits

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

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