scala.math

# Ordering

#### object Ordering extends LowPriorityOrderingImplicits with Serializable

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.

Linear Supertypes
Serializable, java.io.Serializable, LowPriorityOrderingImplicits, AnyRef, Any
Content Hierarchy Learn more about scaladoc diagrams
Ordering

1. Alphabetic
2. By inheritance

Inherited

1. Ordering
2. Serializable
3. Serializable
4. LowPriorityOrderingImplicits
5. AnyRef
6. Any

1. Hide All
2. Show all

Learn more about member selection
Visibility

1. Public
2. All

### Type Members

1. #### trait BigDecimalOrdering extends Ordering[BigDecimal]

2. #### trait BigIntOrdering extends Ordering[BigInt]

3. #### trait BooleanOrdering extends Ordering[Boolean]

4. #### trait ByteOrdering extends Ordering[Byte]

5. #### trait CharOrdering extends Ordering[Char]

6. #### trait DoubleOrdering extends Ordering[Double]

7. #### trait ExtraImplicits extends AnyRef

8. #### trait FloatOrdering extends Ordering[Float]

9. #### trait IntOrdering extends Ordering[Int]

10. #### trait LongOrdering extends Ordering[Long]

11. #### trait OptionOrdering[T] extends Ordering[Option[T]]

12. #### trait ShortOrdering extends Ordering[Short]

13. #### trait StringOrdering extends Ordering[String]

14. #### trait UnitOrdering extends Ordering[Unit]

### Value Members

1. #### final def !=(arg0: Any): Boolean

   Definition Classes
     AnyRef → Any

2. #### final def ##(): Int

   Definition Classes
     AnyRef → Any

3. #### final def ==(arg0: Any): Boolean

   Definition Classes
     AnyRef → Any

4. #### implicit object BigDecimal extends BigDecimalOrdering

5. #### implicit object BigInt extends BigIntOrdering

6. #### implicit object Boolean extends BooleanOrdering

7. #### implicit object Byte extends ByteOrdering

8. #### implicit object Char extends CharOrdering

9. #### implicit object Double extends DoubleOrdering

10. #### implicit object Float extends FloatOrdering

11. #### object Implicits extends ExtraImplicits

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

12. #### implicit object Int extends IntOrdering

13. #### implicit def Iterable[T](implicit ord: Ordering[T]): Ordering[Iterable[T]]

14. #### implicit object Long extends LongOrdering

15. #### implicit def Option[T](implicit ord: Ordering[T]): Ordering[Option[T]]

16. #### implicit object Short extends ShortOrdering

17. #### implicit object String extends StringOrdering

18. #### implicit def Tuple2[T1, T2](implicit ord1: Ordering[T1], ord2: Ordering[T2]): Ordering[(T1, T2)]

19. #### implicit def Tuple3[T1, T2, T3](implicit ord1: Ordering[T1], ord2: Ordering[T2], ord3: Ordering[T3]): Ordering[(T1, T2, T3)]

20. #### 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)]

21. #### 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)]

22. #### 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)]

23. #### 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)]

24. #### 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)]

25. #### 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)]

26. #### implicit object Unit extends UnitOrdering

27. #### def apply[T](implicit ord: Ordering[T]): Ordering[T]

28. #### final def asInstanceOf[T0]: T0

    Definition Classes
      Any

29. #### 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.

30. #### def clone(): AnyRef

    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

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

    Definition Classes
      LowPriorityOrderingImplicits

32. #### final def eq(arg0: AnyRef): Boolean

    Definition Classes
      AnyRef

33. #### def equals(arg0: Any): Boolean

    Definition Classes
      AnyRef → Any

34. #### def finalize(): Unit

    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )

35. #### def fromLessThan[T](cmp: (T, T) ⇒ Boolean): Ordering[T]

    Construct an Ordering[T] given a function `lt`.

36. #### final def getClass(): Class[_]

    Definition Classes
      AnyRef → Any

37. #### def hashCode(): Int

    Definition Classes
      AnyRef → Any

38. #### final def isInstanceOf[T0]: Boolean

    Definition Classes
      Any

39. #### final def ne(arg0: AnyRef): Boolean

    Definition Classes
      AnyRef

40. #### final def notify(): Unit

    Definition Classes
      AnyRef

41. #### final def notifyAll(): Unit

    Definition Classes
      AnyRef

42. #### implicit def ordered[A](implicit arg0: (A) ⇒ Comparable[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.

    Definition Classes
      LowPriorityOrderingImplicits

43. #### final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
      AnyRef

44. #### def toString(): String

    Definition Classes
      AnyRef → Any

45. #### final def wait(): Unit

    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

46. #### final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

47. #### final def wait(arg0: Long): Unit

    Definition Classes
      AnyRef
    Annotations
      @throws( ... )

### Inherited from Serializable

### Inherited from java.io.Serializable

### Inherited from LowPriorityOrderingImplicits

### Inherited from AnyRef

### Inherited from Any

### Ungrouped