Portability	portable
Stability	stable
Maintainer	libraries@haskell.org
Safe Haskell	Trustworthy

Data.Ord

Description

Orderings

Synopsis

class Eq a => Ord a where
- compare :: a -> a -> Ordering
- (<) :: a -> a -> Bool
- (>=) :: a -> a -> Bool
- (>) :: a -> a -> Bool
- (<=) :: a -> a -> Bool
- max :: a -> a -> a
- min :: a -> a -> a
data Ordering
- = LT
- | EQ
- | GT
newtype Down a = Down a
comparing :: Ord a => (b -> a) -> b -> b -> Ordering

Documentation

class Eq a => Ord a whereSource

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.

Methods

compare :: a -> a -> Ordering Source

(<) :: a -> a -> Bool Source

(>=) :: a -> a -> Bool Source

(>) :: a -> a -> Bool Source

(<=) :: a -> a -> Bool Source

max :: a -> a -> aSource

min :: a -> a -> aSource

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 ()

Ord TyCon

Ord TypeRep

Ord ArithException

Ord Fingerprint

Ord IOMode

Ord SeekMode

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 GeneralCategory

Ord TypeRepKey

Ord Associativity

Ord Fixity

Ord Arity

Ord IntPtr

Ord WordPtr

Ord Any

Ord All

Ord Newline

Ord ExitCode

Ord ThreadId

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 Unique

Ord Version

Ord a => Ord [a]

Integral a => Ord (Ratio a)

Ord (Ptr a)

Ord (FunPtr a)

Ord a => Ord (Maybe a)

Ord a => Ord (Down a)

Ord (ForeignPtr 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 (Fixed a)

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

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

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

(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 Source

Constructors

LT

EQ

GT

Instances

Eq Ordering

Ord Ordering

Ix Ordering

newtype Down a Source

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

Constructors

Down a

Instances

Eq a => Eq (Down a)

Ord a => Ord (Down a)

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

 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) ...