Order<T> class abstract

The Order type class is used to define a total ordering on some type A.

An order is defined by a relation <=, which obeys the following laws:

  • either x <= y or y <= x (totality)
  • if x <= y and y <= x, then x == y (antisymmetry)
  • if x <= y and y <= z, then x <= z (transitivity)

The truth table for compare is defined as follows:

x <= y x >= y int
true true = 0 (corresponds to x == y)
true false < 0 (corresponds to x < y)
false true > 0 (corresponds to x > y)

By the totality law, x <= y and y <= x cannot be both false.

Inheritance

Constructors

Order()
const

Properties

hashCode → int
The hash code for this object.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited

Methods

compare(T x, T y) → int
Result of comparing x with y. Returns an Int whose sign is:
eqv(T x, T y) → bool
Returns true if x == y, false otherwise.
override
gt(T x, T y) → bool
Returns true if x > y, false otherwise.
override
gteqv(T x, T y) → bool
Returns true if x >= y, false otherwise.
override
lt(T x, T y) → bool
Returns true if x < y, false otherwise.
override
lteqv(T x, T y) → bool
Returns true if x <= y, false otherwise.
override
max(T x, T y) → T
If x > y, return x, else return y.
min(T x, T y) → T
If x < y, return x, else return y.
neqv(T x, T y) → bool
Returns false if x and y are equivalent, true otherwise.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
partialCompare(T x, T y) → double
Result of comparing x with y.
override
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

allEqual<A>() → Order<A>
An Order instance that considers all A instances to be equal (compare always returns 0).
override
by<A, B>(B f(A a), Order<B> ord) → Order<A>
Convert an implicit Order<B> to an Order<A> using the given function f.
override
from<A>(int f(A a1, A a2)) → Order<A>
Define an Order<A> using the given function f.
override
fromLessThan<A>(bool f(A a1, A a2)) → Order<A>
Define an Order<A> using the given 'less than' function f.
reverse<A>(Order<A> ord) → Order<A>
Defines an ordering on A from the given order such that all arrows switch direction.
override
whenEqual<A>(Order<A> first, Order<A> second) → Order<A>
Returns a new Order<A> instance that first compares by the first Order instance and uses the second Order instance to "break ties".