Object Ordering.Ordering

object Ordering extends LowPriorityOrderingImplicits

Это объект-компаньон для тракта scala.math.Ordering.

Он содержит множество неявных упорядочений, а также методы для построения новых упорядочений.

Классы

Исходный код

object BigDecimal extends BigDecimalOrdering

Исходный код

Тракт BigDecimalOrdering extends Ordering[BigDecimal]

Исходный код

object BigInt extends BigIntOrdering

Исходный код

Тракт BigIntOrdering extends Ordering[BigInt]

Исходный код

object Boolean extends BooleanOrdering

Исходный код

Тракт BooleanOrdering extends Ordering[Boolean]

Исходный код

object Byte extends ByteOrdering

Исходный код

Тракт ByteOrdering extends Ordering[Byte]

Исходный код

Закрытый тракт CachedReverse[T] extends Ordering[T]

Упорядочение, которое кэширует значение своего обратного упорядочения.

Исходный код

object Char extends CharOrdering

Исходный код

Тракт CharOrdering extends Ordering[Char]

Исходный код

object DeprecatedDoubleOrdering extends TotalOrdering

Исходный код

object DeprecatedFloatOrdering extends TotalOrdering

Исходный код

object Double

Ordering для Double.

Поведение операций сравнения, предоставляемых по умолчанию (неявным) упорядочением для Double изменилось в версиях 2.10.0 и 2.13.0. До Scala 2.10.0, экземпляр Ordering использовал семантику, согласующуюся с java.lang.Double.compare.

В Scala 2.10.0 реализация lt, equiv, min, и т. д., была изменена для соответствия стандарту IEEE 754, при этом метод compare НЕ соответствует этому стандарту, создавая внутренне несогласованный экземпляр. Стандарт IEEE 754 определяет, что 0.0 == -0.0. Кроме того, он требует, чтобы все сравнения с Double.NaN возвращали false, таким образом 0.0 < Double.NaN, 0.0 > Double.NaN, и Double.NaN == Double.NaN все возвращают false, аналогично None в flatMap.

Признавая ограничения семантики IEEE 754 в отношении упорядочения, Scala 2.13.0 создала два экземпляра: Ordering.Double.IeeeOrdering, который сохраняет семантику IEEE 754 из Scala 2.12.x, и Ordering.Double.TotalOrdering, который возвращает семантику java.lang.Double.compare для всех операций. По умолчанию используется 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
}

Исходный код

Тракт ExtraImplicits

Исходный код

object Float

Ordering для Float.

Поведение операций сравнения, предоставляемых по умолчанию (неявным) упорядочением для Float изменилось в версиях 2.10.0 и 2.13.0. До Scala 2.10.0, экземпляр Ordering использовал семантику, согласующуюся с java.lang.Float.compare.

В Scala 2.10.0 реализация lt, equiv, min, и т. д., была изменена для соответствия стандарту IEEE 754, при этом метод compare НЕ соответствует этому стандарту, создавая внутренне несогласованный экземпляр. Стандарт IEEE 754 определяет, что 0.0F == -0.0F. Кроме того, он требует, чтобы все сравнения с Float.NaN возвращали false, таким образом 0.0F < Float.NaN, 0.0F > Float.NaN, и Float.NaN == Float.NaN все возвращают false, аналогично None в flatMap.

Признавая ограничения семантики IEEE 754 в отношении упорядочения, Scala 2.13.0 создала два экземпляра: Ordering.Float.IeeeOrdering, который сохраняет семантику IEEE 754 из Scala 2.12.x, и Ordering.Float.TotalOrdering, который возвращает семантику java.lang.Float.compare для всех операций. По умолчанию используется 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

Объект, содержащий неявные параметры, которые не входят в стандартный охват.

Исходный код

object Int extends IntOrdering with CachedReverse[Int]

Исходный код

Тракт IntOrdering extends Ordering[Int]

Исходный код

object Long extends LongOrdering

Исходный код

Тракт LongOrdering extends Ordering[Long]

Исходный код

Тракт OptionOrdering[T] extends Ordering[Option[T]]

Исходный код

object Short extends ShortOrdering

Исходный код

Тракт ShortOrdering extends Ordering[Short]

Исходный код

object String extends StringOrdering

Исходный код

Тракт StringOrdering extends Ordering[String]

Исходный код

object Symbol extends SymbolOrdering

Источник

trait SymbolOrdering extends Ordering[Символ]

Источник

object Единица extends UnitOrdering

Источник

trait UnitOrdering extends Ordering[Единица]

Наследуемые типы

Источник

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

Конкретные методы

Источник

def apply[T](implicit ord: Ordering[T]): Ordering[T]

Источник

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

Исходя из f, функции из T в S, создаёт Ordering[T], функция сравнения которого эквивалентна:

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

Эта функция является аналогом Ordering.on, где параметр Ordering[S] передаётся неявно.

Источник

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

Конструирует Ordering[T], заданный функцией lt.

Неявные параметры

Источник

implicit def Option[T](implicit ord: Ordering[T]): Ordering[Некоторый[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)]

Наследуемые неявные параметры

Источник

implicit def comparatorToOrdering[A](implicit cmp: Comparator[A]): Ordering[A]

Источник

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

Это бы вступило в конфликт со всеми замечательными неявными Ordering, но благодаря магии приоритетных неявных параметров с помощью наследования, мы можем получить Ordered[A] => Ordering[A] только в случае, если ничего другого не работает. Поскольку Ordered[A] всё равно расширяет Comparable[A], мы также можем добавить немного Java-совместимости.