Data.Ord

Orderings

Documentation

class Eq a => Ord a where

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Methods

compare :: a -> a -> Ordering

(<) :: a -> a -> Bool infix 4

(<=) :: a -> a -> Bool infix 4

(>) :: a -> a -> Bool infix 4

(>=) :: a -> a -> Bool infix 4

max :: a -> a -> a

min :: a -> a -> a

Instances

Ord Bool

Ord Char

Ord Double

Ord Float

Ord Int

Ord Int8

Ord Int16

Ord Int32

Ord Int64

Ord Integer

Ord Ordering

Ord Word

Ord Word8

Ord Word16

Ord Word32

Ord Word64

Ord TypeRep

Ord ()

Ord BigNat

Ord GeneralCategory

Ord Fingerprint

Ord TyCon

Ord Associativity

Ord Fixity

Ord Arity

Ord Any

Ord All

Ord ArithException

Ord ErrorCall

Ord CUIntMax

Ord CIntMax

Ord CUIntPtr

Ord CIntPtr

Ord CSUSeconds

Ord CUSeconds

Ord CTime

Ord CClock

Ord CSigAtomic

Ord CWchar

Ord CSize

Ord CPtrdiff

Ord CDouble

Ord CFloat

Ord CULLong

Ord CLLong

Ord CULong

Ord CLong

Ord CUInt

Ord CInt

Ord CUShort

Ord CShort

Ord CUChar

Ord CSChar

Ord CChar

Ord IntPtr

Ord WordPtr

Ord SeekMode

Ord NewlineMode

Ord Newline

Ord BufferMode

Ord ExitCode

Ord ArrayException

Ord AsyncException

Ord Fd

Ord CRLim

Ord CTcflag

Ord CSpeed

Ord CCc

Ord CUid

Ord CNlink

Ord CGid

Ord CSsize

Ord CPid

Ord COff

Ord CMode

Ord CIno

Ord CDev

Ord ThreadStatus

Ord BlockReason

Ord ThreadId

Ord IOMode

Ord Version

Ord Natural

Ord SomeSymbol

Ord SomeNat

Ord Unique

Ord Void

Ord a => Ord [a]

Integral a => Ord (Ratio a)

Ord (Ptr a)

Ord (FunPtr a)

Ord (U1 p)

Ord p => Ord (Par1 p)

Ord a => Ord (Maybe a)

Ord a => Ord (Down a)

Ord a => Ord (Last a)

Ord a => Ord (First a)

Ord a => Ord (Product a)

Ord a => Ord (Sum a)

Ord a => Ord (Dual a)

Ord (ForeignPtr a)

Ord a => Ord (ZipList a)

Ord (Fixed a)

Ord a => Ord (Identity a)

(Ord a, Ord b) => Ord (Either a b)

Ord (f p) => Ord (Rec1 f p)

(Ord a, Ord b) => Ord (a, b)

Ord (Proxy k s)

Ord a => Ord (Const a b)

Ord c => Ord (K1 i c p)

(Ord (f p), Ord (g p)) => Ord ((:+:) f g p)

(Ord (f p), Ord (g p)) => Ord ((:*:) f g p)

Ord (f (g p)) => Ord ((:.:) f g p)

(Ord a, Ord b, Ord c) => Ord (a, b, c)

Ord ((:~:) k a b)

Ord (Coercion k a b)

Ord (f a) => Ord (Alt k f a)

Ord (f p) => Ord (M1 i c f p)

(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)

(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

data Ordering :: *

Constructors

LT

EQ

GT

Instances

Bounded Ordering

Enum Ordering

Eq Ordering

Data Ordering

Ord Ordering

Read Ordering

Show Ordering

Ix Ordering

Generic Ordering

Monoid Ordering

type Rep Ordering

type (==) Ordering a b

newtype Down a

The Down type allows you to reverse sort order conveniently. A value of type Down a contains a value of type a (represented as Down a). If a has an Ord instance associated with it then comparing two values thus wrapped will give you the opposite of their normal sort order. This is particularly useful when sorting in generalised list comprehensions, as in: then sortWith by Down x

Provides Show and Read instances (since: 4.7.0.0).

Since: 4.6.0.0

Constructors

Down a

Instances

Eq a => Eq (Down a)

Ord a => Ord (Down a)

Read a => Read (Down a)

Show a => Show (Down a)

comparing :: Ord a => (b -> a) -> b -> b -> Ordering

comparing p x y = compare (p x) (p y)

Useful combinator for use in conjunction with the xxxBy family of functions from Data.List, for example:

  ... sortBy (comparing fst) ...