Copyright	(c) The University of Glasgow 2005
License	BSD-style (see the file libraries/base/LICENSE)
Maintainer	libraries@haskell.org
Stability	stable
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

Data.Ord

Description

Orderings

Synopsis

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
Methods compare :: Bool -> Bool -> Ordering (<) :: Bool -> Bool -> Bool (<=) :: Bool -> Bool -> Bool (>) :: Bool -> Bool -> Bool (>=) :: Bool -> Bool -> Bool max :: Bool -> Bool -> Bool min :: Bool -> Bool -> Bool
Ord Char
Methods compare :: Char -> Char -> Ordering (<) :: Char -> Char -> Bool (<=) :: Char -> Char -> Bool (>) :: Char -> Char -> Bool (>=) :: Char -> Char -> Bool max :: Char -> Char -> Char min :: Char -> Char -> Char
Ord Double
Methods compare :: Double -> Double -> Ordering (<) :: Double -> Double -> Bool (<=) :: Double -> Double -> Bool (>) :: Double -> Double -> Bool (>=) :: Double -> Double -> Bool max :: Double -> Double -> Double min :: Double -> Double -> Double
Ord Float
Methods compare :: Float -> Float -> Ordering (<) :: Float -> Float -> Bool (<=) :: Float -> Float -> Bool (>) :: Float -> Float -> Bool (>=) :: Float -> Float -> Bool max :: Float -> Float -> Float min :: Float -> Float -> Float
Ord Int
Methods compare :: Int -> Int -> Ordering (<) :: Int -> Int -> Bool (<=) :: Int -> Int -> Bool (>) :: Int -> Int -> Bool (>=) :: Int -> Int -> Bool max :: Int -> Int -> Int min :: Int -> Int -> Int
Ord Int8
Methods compare :: Int8 -> Int8 -> Ordering (<) :: Int8 -> Int8 -> Bool (<=) :: Int8 -> Int8 -> Bool (>) :: Int8 -> Int8 -> Bool (>=) :: Int8 -> Int8 -> Bool max :: Int8 -> Int8 -> Int8 min :: Int8 -> Int8 -> Int8
Ord Int16
Methods compare :: Int16 -> Int16 -> Ordering (<) :: Int16 -> Int16 -> Bool (<=) :: Int16 -> Int16 -> Bool (>) :: Int16 -> Int16 -> Bool (>=) :: Int16 -> Int16 -> Bool max :: Int16 -> Int16 -> Int16 min :: Int16 -> Int16 -> Int16
Ord Int32
Methods compare :: Int32 -> Int32 -> Ordering (<) :: Int32 -> Int32 -> Bool (<=) :: Int32 -> Int32 -> Bool (>) :: Int32 -> Int32 -> Bool (>=) :: Int32 -> Int32 -> Bool max :: Int32 -> Int32 -> Int32 min :: Int32 -> Int32 -> Int32
Ord Int64
Methods compare :: Int64 -> Int64 -> Ordering (<) :: Int64 -> Int64 -> Bool (<=) :: Int64 -> Int64 -> Bool (>) :: Int64 -> Int64 -> Bool (>=) :: Int64 -> Int64 -> Bool max :: Int64 -> Int64 -> Int64 min :: Int64 -> Int64 -> Int64
Ord Integer
Methods compare :: Integer -> Integer -> Ordering (<) :: Integer -> Integer -> Bool (<=) :: Integer -> Integer -> Bool (>) :: Integer -> Integer -> Bool (>=) :: Integer -> Integer -> Bool max :: Integer -> Integer -> Integer min :: Integer -> Integer -> Integer
Ord Ordering
Methods compare :: Ordering -> Ordering -> Ordering (<) :: Ordering -> Ordering -> Bool (<=) :: Ordering -> Ordering -> Bool (>) :: Ordering -> Ordering -> Bool (>=) :: Ordering -> Ordering -> Bool max :: Ordering -> Ordering -> Ordering min :: Ordering -> Ordering -> Ordering
Ord Word
Methods compare :: Word -> Word -> Ordering (<) :: Word -> Word -> Bool (<=) :: Word -> Word -> Bool (>) :: Word -> Word -> Bool (>=) :: Word -> Word -> Bool max :: Word -> Word -> Word min :: Word -> Word -> Word
Ord Word8
Methods compare :: Word8 -> Word8 -> Ordering (<) :: Word8 -> Word8 -> Bool (<=) :: Word8 -> Word8 -> Bool (>) :: Word8 -> Word8 -> Bool (>=) :: Word8 -> Word8 -> Bool max :: Word8 -> Word8 -> Word8 min :: Word8 -> Word8 -> Word8
Ord Word16
Methods compare :: Word16 -> Word16 -> Ordering (<) :: Word16 -> Word16 -> Bool (<=) :: Word16 -> Word16 -> Bool (>) :: Word16 -> Word16 -> Bool (>=) :: Word16 -> Word16 -> Bool max :: Word16 -> Word16 -> Word16 min :: Word16 -> Word16 -> Word16
Ord Word32
Methods compare :: Word32 -> Word32 -> Ordering (<) :: Word32 -> Word32 -> Bool (<=) :: Word32 -> Word32 -> Bool (>) :: Word32 -> Word32 -> Bool (>=) :: Word32 -> Word32 -> Bool max :: Word32 -> Word32 -> Word32 min :: Word32 -> Word32 -> Word32
Ord Word64
Methods compare :: Word64 -> Word64 -> Ordering (<) :: Word64 -> Word64 -> Bool (<=) :: Word64 -> Word64 -> Bool (>) :: Word64 -> Word64 -> Bool (>=) :: Word64 -> Word64 -> Bool max :: Word64 -> Word64 -> Word64 min :: Word64 -> Word64 -> Word64
Ord TypeRep
Methods compare :: TypeRep -> TypeRep -> Ordering (<) :: TypeRep -> TypeRep -> Bool (<=) :: TypeRep -> TypeRep -> Bool (>) :: TypeRep -> TypeRep -> Bool (>=) :: TypeRep -> TypeRep -> Bool max :: TypeRep -> TypeRep -> TypeRep min :: TypeRep -> TypeRep -> TypeRep
Ord ()
Methods compare :: () -> () -> Ordering (<) :: () -> () -> Bool (<=) :: () -> () -> Bool (>) :: () -> () -> Bool (>=) :: () -> () -> Bool max :: () -> () -> () min :: () -> () -> ()
Ord BigNat
Methods compare :: BigNat -> BigNat -> Ordering (<) :: BigNat -> BigNat -> Bool (<=) :: BigNat -> BigNat -> Bool (>) :: BigNat -> BigNat -> Bool (>=) :: BigNat -> BigNat -> Bool max :: BigNat -> BigNat -> BigNat min :: BigNat -> BigNat -> BigNat
Ord GeneralCategory
Methods compare :: GeneralCategory -> GeneralCategory -> Ordering (<) :: GeneralCategory -> GeneralCategory -> Bool (<=) :: GeneralCategory -> GeneralCategory -> Bool (>) :: GeneralCategory -> GeneralCategory -> Bool (>=) :: GeneralCategory -> GeneralCategory -> Bool max :: GeneralCategory -> GeneralCategory -> GeneralCategory min :: GeneralCategory -> GeneralCategory -> GeneralCategory
Ord Fingerprint
Methods compare :: Fingerprint -> Fingerprint -> Ordering (<) :: Fingerprint -> Fingerprint -> Bool (<=) :: Fingerprint -> Fingerprint -> Bool (>) :: Fingerprint -> Fingerprint -> Bool (>=) :: Fingerprint -> Fingerprint -> Bool max :: Fingerprint -> Fingerprint -> Fingerprint min :: Fingerprint -> Fingerprint -> Fingerprint
Ord TyCon
Methods compare :: TyCon -> TyCon -> Ordering (<) :: TyCon -> TyCon -> Bool (<=) :: TyCon -> TyCon -> Bool (>) :: TyCon -> TyCon -> Bool (>=) :: TyCon -> TyCon -> Bool max :: TyCon -> TyCon -> TyCon min :: TyCon -> TyCon -> TyCon
Ord Associativity
Methods compare :: Associativity -> Associativity -> Ordering (<) :: Associativity -> Associativity -> Bool (<=) :: Associativity -> Associativity -> Bool (>) :: Associativity -> Associativity -> Bool (>=) :: Associativity -> Associativity -> Bool max :: Associativity -> Associativity -> Associativity min :: Associativity -> Associativity -> Associativity
Ord Fixity
Methods compare :: Fixity -> Fixity -> Ordering (<) :: Fixity -> Fixity -> Bool (<=) :: Fixity -> Fixity -> Bool (>) :: Fixity -> Fixity -> Bool (>=) :: Fixity -> Fixity -> Bool max :: Fixity -> Fixity -> Fixity min :: Fixity -> Fixity -> Fixity
Ord Arity
Methods compare :: Arity -> Arity -> Ordering (<) :: Arity -> Arity -> Bool (<=) :: Arity -> Arity -> Bool (>) :: Arity -> Arity -> Bool (>=) :: Arity -> Arity -> Bool max :: Arity -> Arity -> Arity min :: Arity -> Arity -> Arity
Ord Any
Methods compare :: Any -> Any -> Ordering (<) :: Any -> Any -> Bool (<=) :: Any -> Any -> Bool (>) :: Any -> Any -> Bool (>=) :: Any -> Any -> Bool max :: Any -> Any -> Any min :: Any -> Any -> Any
Ord All
Methods compare :: All -> All -> Ordering (<) :: All -> All -> Bool (<=) :: All -> All -> Bool (>) :: All -> All -> Bool (>=) :: All -> All -> Bool max :: All -> All -> All min :: All -> All -> All
Ord ArithException
Methods compare :: ArithException -> ArithException -> Ordering (<) :: ArithException -> ArithException -> Bool (<=) :: ArithException -> ArithException -> Bool (>) :: ArithException -> ArithException -> Bool (>=) :: ArithException -> ArithException -> Bool max :: ArithException -> ArithException -> ArithException min :: ArithException -> ArithException -> ArithException
Ord ErrorCall
Methods compare :: ErrorCall -> ErrorCall -> Ordering (<) :: ErrorCall -> ErrorCall -> Bool (<=) :: ErrorCall -> ErrorCall -> Bool (>) :: ErrorCall -> ErrorCall -> Bool (>=) :: ErrorCall -> ErrorCall -> Bool max :: ErrorCall -> ErrorCall -> ErrorCall min :: ErrorCall -> ErrorCall -> ErrorCall
Ord CUIntMax
Methods compare :: CUIntMax -> CUIntMax -> Ordering (<) :: CUIntMax -> CUIntMax -> Bool (<=) :: CUIntMax -> CUIntMax -> Bool (>) :: CUIntMax -> CUIntMax -> Bool (>=) :: CUIntMax -> CUIntMax -> Bool max :: CUIntMax -> CUIntMax -> CUIntMax min :: CUIntMax -> CUIntMax -> CUIntMax
Ord CIntMax
Methods compare :: CIntMax -> CIntMax -> Ordering (<) :: CIntMax -> CIntMax -> Bool (<=) :: CIntMax -> CIntMax -> Bool (>) :: CIntMax -> CIntMax -> Bool (>=) :: CIntMax -> CIntMax -> Bool max :: CIntMax -> CIntMax -> CIntMax min :: CIntMax -> CIntMax -> CIntMax
Ord CUIntPtr
Methods compare :: CUIntPtr -> CUIntPtr -> Ordering (<) :: CUIntPtr -> CUIntPtr -> Bool (<=) :: CUIntPtr -> CUIntPtr -> Bool (>) :: CUIntPtr -> CUIntPtr -> Bool (>=) :: CUIntPtr -> CUIntPtr -> Bool max :: CUIntPtr -> CUIntPtr -> CUIntPtr min :: CUIntPtr -> CUIntPtr -> CUIntPtr
Ord CIntPtr
Methods compare :: CIntPtr -> CIntPtr -> Ordering (<) :: CIntPtr -> CIntPtr -> Bool (<=) :: CIntPtr -> CIntPtr -> Bool (>) :: CIntPtr -> CIntPtr -> Bool (>=) :: CIntPtr -> CIntPtr -> Bool max :: CIntPtr -> CIntPtr -> CIntPtr min :: CIntPtr -> CIntPtr -> CIntPtr
Ord CSUSeconds
Methods compare :: CSUSeconds -> CSUSeconds -> Ordering (<) :: CSUSeconds -> CSUSeconds -> Bool (<=) :: CSUSeconds -> CSUSeconds -> Bool (>) :: CSUSeconds -> CSUSeconds -> Bool (>=) :: CSUSeconds -> CSUSeconds -> Bool max :: CSUSeconds -> CSUSeconds -> CSUSeconds min :: CSUSeconds -> CSUSeconds -> CSUSeconds
Ord CUSeconds
Methods compare :: CUSeconds -> CUSeconds -> Ordering (<) :: CUSeconds -> CUSeconds -> Bool (<=) :: CUSeconds -> CUSeconds -> Bool (>) :: CUSeconds -> CUSeconds -> Bool (>=) :: CUSeconds -> CUSeconds -> Bool max :: CUSeconds -> CUSeconds -> CUSeconds min :: CUSeconds -> CUSeconds -> CUSeconds
Ord CTime
Methods compare :: CTime -> CTime -> Ordering (<) :: CTime -> CTime -> Bool (<=) :: CTime -> CTime -> Bool (>) :: CTime -> CTime -> Bool (>=) :: CTime -> CTime -> Bool max :: CTime -> CTime -> CTime min :: CTime -> CTime -> CTime
Ord CClock
Methods compare :: CClock -> CClock -> Ordering (<) :: CClock -> CClock -> Bool (<=) :: CClock -> CClock -> Bool (>) :: CClock -> CClock -> Bool (>=) :: CClock -> CClock -> Bool max :: CClock -> CClock -> CClock min :: CClock -> CClock -> CClock
Ord CSigAtomic
Methods compare :: CSigAtomic -> CSigAtomic -> Ordering (<) :: CSigAtomic -> CSigAtomic -> Bool (<=) :: CSigAtomic -> CSigAtomic -> Bool (>) :: CSigAtomic -> CSigAtomic -> Bool (>=) :: CSigAtomic -> CSigAtomic -> Bool max :: CSigAtomic -> CSigAtomic -> CSigAtomic min :: CSigAtomic -> CSigAtomic -> CSigAtomic
Ord CWchar
Methods compare :: CWchar -> CWchar -> Ordering (<) :: CWchar -> CWchar -> Bool (<=) :: CWchar -> CWchar -> Bool (>) :: CWchar -> CWchar -> Bool (>=) :: CWchar -> CWchar -> Bool max :: CWchar -> CWchar -> CWchar min :: CWchar -> CWchar -> CWchar
Ord CSize
Methods compare :: CSize -> CSize -> Ordering (<) :: CSize -> CSize -> Bool (<=) :: CSize -> CSize -> Bool (>) :: CSize -> CSize -> Bool (>=) :: CSize -> CSize -> Bool max :: CSize -> CSize -> CSize min :: CSize -> CSize -> CSize
Ord CPtrdiff
Methods compare :: CPtrdiff -> CPtrdiff -> Ordering (<) :: CPtrdiff -> CPtrdiff -> Bool (<=) :: CPtrdiff -> CPtrdiff -> Bool (>) :: CPtrdiff -> CPtrdiff -> Bool (>=) :: CPtrdiff -> CPtrdiff -> Bool max :: CPtrdiff -> CPtrdiff -> CPtrdiff min :: CPtrdiff -> CPtrdiff -> CPtrdiff
Ord CDouble
Methods compare :: CDouble -> CDouble -> Ordering (<) :: CDouble -> CDouble -> Bool (<=) :: CDouble -> CDouble -> Bool (>) :: CDouble -> CDouble -> Bool (>=) :: CDouble -> CDouble -> Bool max :: CDouble -> CDouble -> CDouble min :: CDouble -> CDouble -> CDouble
Ord CFloat
Methods compare :: CFloat -> CFloat -> Ordering (<) :: CFloat -> CFloat -> Bool (<=) :: CFloat -> CFloat -> Bool (>) :: CFloat -> CFloat -> Bool (>=) :: CFloat -> CFloat -> Bool max :: CFloat -> CFloat -> CFloat min :: CFloat -> CFloat -> CFloat
Ord CULLong
Methods compare :: CULLong -> CULLong -> Ordering (<) :: CULLong -> CULLong -> Bool (<=) :: CULLong -> CULLong -> Bool (>) :: CULLong -> CULLong -> Bool (>=) :: CULLong -> CULLong -> Bool max :: CULLong -> CULLong -> CULLong min :: CULLong -> CULLong -> CULLong
Ord CLLong
Methods compare :: CLLong -> CLLong -> Ordering (<) :: CLLong -> CLLong -> Bool (<=) :: CLLong -> CLLong -> Bool (>) :: CLLong -> CLLong -> Bool (>=) :: CLLong -> CLLong -> Bool max :: CLLong -> CLLong -> CLLong min :: CLLong -> CLLong -> CLLong
Ord CULong
Methods compare :: CULong -> CULong -> Ordering (<) :: CULong -> CULong -> Bool (<=) :: CULong -> CULong -> Bool (>) :: CULong -> CULong -> Bool (>=) :: CULong -> CULong -> Bool max :: CULong -> CULong -> CULong min :: CULong -> CULong -> CULong
Ord CLong
Methods compare :: CLong -> CLong -> Ordering (<) :: CLong -> CLong -> Bool (<=) :: CLong -> CLong -> Bool (>) :: CLong -> CLong -> Bool (>=) :: CLong -> CLong -> Bool max :: CLong -> CLong -> CLong min :: CLong -> CLong -> CLong
Ord CUInt
Methods compare :: CUInt -> CUInt -> Ordering (<) :: CUInt -> CUInt -> Bool (<=) :: CUInt -> CUInt -> Bool (>) :: CUInt -> CUInt -> Bool (>=) :: CUInt -> CUInt -> Bool max :: CUInt -> CUInt -> CUInt min :: CUInt -> CUInt -> CUInt
Ord CInt
Methods compare :: CInt -> CInt -> Ordering (<) :: CInt -> CInt -> Bool (<=) :: CInt -> CInt -> Bool (>) :: CInt -> CInt -> Bool (>=) :: CInt -> CInt -> Bool max :: CInt -> CInt -> CInt min :: CInt -> CInt -> CInt
Ord CUShort
Methods compare :: CUShort -> CUShort -> Ordering (<) :: CUShort -> CUShort -> Bool (<=) :: CUShort -> CUShort -> Bool (>) :: CUShort -> CUShort -> Bool (>=) :: CUShort -> CUShort -> Bool max :: CUShort -> CUShort -> CUShort min :: CUShort -> CUShort -> CUShort
Ord CShort
Methods compare :: CShort -> CShort -> Ordering (<) :: CShort -> CShort -> Bool (<=) :: CShort -> CShort -> Bool (>) :: CShort -> CShort -> Bool (>=) :: CShort -> CShort -> Bool max :: CShort -> CShort -> CShort min :: CShort -> CShort -> CShort
Ord CUChar
Methods compare :: CUChar -> CUChar -> Ordering (<) :: CUChar -> CUChar -> Bool (<=) :: CUChar -> CUChar -> Bool (>) :: CUChar -> CUChar -> Bool (>=) :: CUChar -> CUChar -> Bool max :: CUChar -> CUChar -> CUChar min :: CUChar -> CUChar -> CUChar
Ord CSChar
Methods compare :: CSChar -> CSChar -> Ordering (<) :: CSChar -> CSChar -> Bool (<=) :: CSChar -> CSChar -> Bool (>) :: CSChar -> CSChar -> Bool (>=) :: CSChar -> CSChar -> Bool max :: CSChar -> CSChar -> CSChar min :: CSChar -> CSChar -> CSChar
Ord CChar
Methods compare :: CChar -> CChar -> Ordering (<) :: CChar -> CChar -> Bool (<=) :: CChar -> CChar -> Bool (>) :: CChar -> CChar -> Bool (>=) :: CChar -> CChar -> Bool max :: CChar -> CChar -> CChar min :: CChar -> CChar -> CChar
Ord IntPtr
Methods compare :: IntPtr -> IntPtr -> Ordering (<) :: IntPtr -> IntPtr -> Bool (<=) :: IntPtr -> IntPtr -> Bool (>) :: IntPtr -> IntPtr -> Bool (>=) :: IntPtr -> IntPtr -> Bool max :: IntPtr -> IntPtr -> IntPtr min :: IntPtr -> IntPtr -> IntPtr
Ord WordPtr
Methods compare :: WordPtr -> WordPtr -> Ordering (<) :: WordPtr -> WordPtr -> Bool (<=) :: WordPtr -> WordPtr -> Bool (>) :: WordPtr -> WordPtr -> Bool (>=) :: WordPtr -> WordPtr -> Bool max :: WordPtr -> WordPtr -> WordPtr min :: WordPtr -> WordPtr -> WordPtr
Ord SeekMode
Methods compare :: SeekMode -> SeekMode -> Ordering (<) :: SeekMode -> SeekMode -> Bool (<=) :: SeekMode -> SeekMode -> Bool (>) :: SeekMode -> SeekMode -> Bool (>=) :: SeekMode -> SeekMode -> Bool max :: SeekMode -> SeekMode -> SeekMode min :: SeekMode -> SeekMode -> SeekMode
Ord NewlineMode
Methods compare :: NewlineMode -> NewlineMode -> Ordering (<) :: NewlineMode -> NewlineMode -> Bool (<=) :: NewlineMode -> NewlineMode -> Bool (>) :: NewlineMode -> NewlineMode -> Bool (>=) :: NewlineMode -> NewlineMode -> Bool max :: NewlineMode -> NewlineMode -> NewlineMode min :: NewlineMode -> NewlineMode -> NewlineMode
Ord Newline
Methods compare :: Newline -> Newline -> Ordering (<) :: Newline -> Newline -> Bool (<=) :: Newline -> Newline -> Bool (>) :: Newline -> Newline -> Bool (>=) :: Newline -> Newline -> Bool max :: Newline -> Newline -> Newline min :: Newline -> Newline -> Newline
Ord BufferMode
Methods compare :: BufferMode -> BufferMode -> Ordering (<) :: BufferMode -> BufferMode -> Bool (<=) :: BufferMode -> BufferMode -> Bool (>) :: BufferMode -> BufferMode -> Bool (>=) :: BufferMode -> BufferMode -> Bool max :: BufferMode -> BufferMode -> BufferMode min :: BufferMode -> BufferMode -> BufferMode
Ord ExitCode
Methods compare :: ExitCode -> ExitCode -> Ordering (<) :: ExitCode -> ExitCode -> Bool (<=) :: ExitCode -> ExitCode -> Bool (>) :: ExitCode -> ExitCode -> Bool (>=) :: ExitCode -> ExitCode -> Bool max :: ExitCode -> ExitCode -> ExitCode min :: ExitCode -> ExitCode -> ExitCode
Ord ArrayException
Methods compare :: ArrayException -> ArrayException -> Ordering (<) :: ArrayException -> ArrayException -> Bool (<=) :: ArrayException -> ArrayException -> Bool (>) :: ArrayException -> ArrayException -> Bool (>=) :: ArrayException -> ArrayException -> Bool max :: ArrayException -> ArrayException -> ArrayException min :: ArrayException -> ArrayException -> ArrayException
Ord AsyncException
Methods compare :: AsyncException -> AsyncException -> Ordering (<) :: AsyncException -> AsyncException -> Bool (<=) :: AsyncException -> AsyncException -> Bool (>) :: AsyncException -> AsyncException -> Bool (>=) :: AsyncException -> AsyncException -> Bool max :: AsyncException -> AsyncException -> AsyncException min :: AsyncException -> AsyncException -> AsyncException
Ord Fd
Methods compare :: Fd -> Fd -> Ordering (<) :: Fd -> Fd -> Bool (<=) :: Fd -> Fd -> Bool (>) :: Fd -> Fd -> Bool (>=) :: Fd -> Fd -> Bool max :: Fd -> Fd -> Fd min :: Fd -> Fd -> Fd
Ord CRLim
Methods compare :: CRLim -> CRLim -> Ordering (<) :: CRLim -> CRLim -> Bool (<=) :: CRLim -> CRLim -> Bool (>) :: CRLim -> CRLim -> Bool (>=) :: CRLim -> CRLim -> Bool max :: CRLim -> CRLim -> CRLim min :: CRLim -> CRLim -> CRLim
Ord CTcflag
Methods compare :: CTcflag -> CTcflag -> Ordering (<) :: CTcflag -> CTcflag -> Bool (<=) :: CTcflag -> CTcflag -> Bool (>) :: CTcflag -> CTcflag -> Bool (>=) :: CTcflag -> CTcflag -> Bool max :: CTcflag -> CTcflag -> CTcflag min :: CTcflag -> CTcflag -> CTcflag
Ord CSpeed
Methods compare :: CSpeed -> CSpeed -> Ordering (<) :: CSpeed -> CSpeed -> Bool (<=) :: CSpeed -> CSpeed -> Bool (>) :: CSpeed -> CSpeed -> Bool (>=) :: CSpeed -> CSpeed -> Bool max :: CSpeed -> CSpeed -> CSpeed min :: CSpeed -> CSpeed -> CSpeed
Ord CCc
Methods compare :: CCc -> CCc -> Ordering (<) :: CCc -> CCc -> Bool (<=) :: CCc -> CCc -> Bool (>) :: CCc -> CCc -> Bool (>=) :: CCc -> CCc -> Bool max :: CCc -> CCc -> CCc min :: CCc -> CCc -> CCc
Ord CUid
Methods compare :: CUid -> CUid -> Ordering (<) :: CUid -> CUid -> Bool (<=) :: CUid -> CUid -> Bool (>) :: CUid -> CUid -> Bool (>=) :: CUid -> CUid -> Bool max :: CUid -> CUid -> CUid min :: CUid -> CUid -> CUid
Ord CNlink
Methods compare :: CNlink -> CNlink -> Ordering (<) :: CNlink -> CNlink -> Bool (<=) :: CNlink -> CNlink -> Bool (>) :: CNlink -> CNlink -> Bool (>=) :: CNlink -> CNlink -> Bool max :: CNlink -> CNlink -> CNlink min :: CNlink -> CNlink -> CNlink
Ord CGid
Methods compare :: CGid -> CGid -> Ordering (<) :: CGid -> CGid -> Bool (<=) :: CGid -> CGid -> Bool (>) :: CGid -> CGid -> Bool (>=) :: CGid -> CGid -> Bool max :: CGid -> CGid -> CGid min :: CGid -> CGid -> CGid
Ord CSsize
Methods compare :: CSsize -> CSsize -> Ordering (<) :: CSsize -> CSsize -> Bool (<=) :: CSsize -> CSsize -> Bool (>) :: CSsize -> CSsize -> Bool (>=) :: CSsize -> CSsize -> Bool max :: CSsize -> CSsize -> CSsize min :: CSsize -> CSsize -> CSsize
Ord CPid
Methods compare :: CPid -> CPid -> Ordering (<) :: CPid -> CPid -> Bool (<=) :: CPid -> CPid -> Bool (>) :: CPid -> CPid -> Bool (>=) :: CPid -> CPid -> Bool max :: CPid -> CPid -> CPid min :: CPid -> CPid -> CPid
Ord COff
Methods compare :: COff -> COff -> Ordering (<) :: COff -> COff -> Bool (<=) :: COff -> COff -> Bool (>) :: COff -> COff -> Bool (>=) :: COff -> COff -> Bool max :: COff -> COff -> COff min :: COff -> COff -> COff
Ord CMode
Methods compare :: CMode -> CMode -> Ordering (<) :: CMode -> CMode -> Bool (<=) :: CMode -> CMode -> Bool (>) :: CMode -> CMode -> Bool (>=) :: CMode -> CMode -> Bool max :: CMode -> CMode -> CMode min :: CMode -> CMode -> CMode
Ord CIno
Methods compare :: CIno -> CIno -> Ordering (<) :: CIno -> CIno -> Bool (<=) :: CIno -> CIno -> Bool (>) :: CIno -> CIno -> Bool (>=) :: CIno -> CIno -> Bool max :: CIno -> CIno -> CIno min :: CIno -> CIno -> CIno
Ord CDev
Methods compare :: CDev -> CDev -> Ordering (<) :: CDev -> CDev -> Bool (<=) :: CDev -> CDev -> Bool (>) :: CDev -> CDev -> Bool (>=) :: CDev -> CDev -> Bool max :: CDev -> CDev -> CDev min :: CDev -> CDev -> CDev
Ord ThreadStatus
Methods compare :: ThreadStatus -> ThreadStatus -> Ordering (<) :: ThreadStatus -> ThreadStatus -> Bool (<=) :: ThreadStatus -> ThreadStatus -> Bool (>) :: ThreadStatus -> ThreadStatus -> Bool (>=) :: ThreadStatus -> ThreadStatus -> Bool max :: ThreadStatus -> ThreadStatus -> ThreadStatus min :: ThreadStatus -> ThreadStatus -> ThreadStatus
Ord BlockReason
Methods compare :: BlockReason -> BlockReason -> Ordering (<) :: BlockReason -> BlockReason -> Bool (<=) :: BlockReason -> BlockReason -> Bool (>) :: BlockReason -> BlockReason -> Bool (>=) :: BlockReason -> BlockReason -> Bool max :: BlockReason -> BlockReason -> BlockReason min :: BlockReason -> BlockReason -> BlockReason
Ord ThreadId
Methods compare :: ThreadId -> ThreadId -> Ordering (<) :: ThreadId -> ThreadId -> Bool (<=) :: ThreadId -> ThreadId -> Bool (>) :: ThreadId -> ThreadId -> Bool (>=) :: ThreadId -> ThreadId -> Bool max :: ThreadId -> ThreadId -> ThreadId min :: ThreadId -> ThreadId -> ThreadId
Ord IOMode
Methods compare :: IOMode -> IOMode -> Ordering (<) :: IOMode -> IOMode -> Bool (<=) :: IOMode -> IOMode -> Bool (>) :: IOMode -> IOMode -> Bool (>=) :: IOMode -> IOMode -> Bool max :: IOMode -> IOMode -> IOMode min :: IOMode -> IOMode -> IOMode
Ord Version
Methods compare :: Version -> Version -> Ordering (<) :: Version -> Version -> Bool (<=) :: Version -> Version -> Bool (>) :: Version -> Version -> Bool (>=) :: Version -> Version -> Bool max :: Version -> Version -> Version min :: Version -> Version -> Version
Ord Natural
Methods compare :: Natural -> Natural -> Ordering (<) :: Natural -> Natural -> Bool (<=) :: Natural -> Natural -> Bool (>) :: Natural -> Natural -> Bool (>=) :: Natural -> Natural -> Bool max :: Natural -> Natural -> Natural min :: Natural -> Natural -> Natural
Ord SomeSymbol
Methods compare :: SomeSymbol -> SomeSymbol -> Ordering (<) :: SomeSymbol -> SomeSymbol -> Bool (<=) :: SomeSymbol -> SomeSymbol -> Bool (>) :: SomeSymbol -> SomeSymbol -> Bool (>=) :: SomeSymbol -> SomeSymbol -> Bool max :: SomeSymbol -> SomeSymbol -> SomeSymbol min :: SomeSymbol -> SomeSymbol -> SomeSymbol
Ord SomeNat
Methods compare :: SomeNat -> SomeNat -> Ordering (<) :: SomeNat -> SomeNat -> Bool (<=) :: SomeNat -> SomeNat -> Bool (>) :: SomeNat -> SomeNat -> Bool (>=) :: SomeNat -> SomeNat -> Bool max :: SomeNat -> SomeNat -> SomeNat min :: SomeNat -> SomeNat -> SomeNat
Ord Unique
Methods compare :: Unique -> Unique -> Ordering (<) :: Unique -> Unique -> Bool (<=) :: Unique -> Unique -> Bool (>) :: Unique -> Unique -> Bool (>=) :: Unique -> Unique -> Bool max :: Unique -> Unique -> Unique min :: Unique -> Unique -> Unique
Ord Void
Methods compare :: Void -> Void -> Ordering (<) :: Void -> Void -> Bool (<=) :: Void -> Void -> Bool (>) :: Void -> Void -> Bool (>=) :: Void -> Void -> Bool max :: Void -> Void -> Void min :: Void -> Void -> Void
Ord a => Ord [a]
Methods compare :: [a] -> [a] -> Ordering (<) :: [a] -> [a] -> Bool (<=) :: [a] -> [a] -> Bool (>) :: [a] -> [a] -> Bool (>=) :: [a] -> [a] -> Bool max :: [a] -> [a] -> [a] min :: [a] -> [a] -> [a]
Integral a => Ord (Ratio a)
Methods compare :: Ratio a -> Ratio a -> Ordering (<) :: Ratio a -> Ratio a -> Bool (<=) :: Ratio a -> Ratio a -> Bool (>) :: Ratio a -> Ratio a -> Bool (>=) :: Ratio a -> Ratio a -> Bool max :: Ratio a -> Ratio a -> Ratio a min :: Ratio a -> Ratio a -> Ratio a
Ord (Ptr a)
Methods compare :: Ptr a -> Ptr a -> Ordering (<) :: Ptr a -> Ptr a -> Bool (<=) :: Ptr a -> Ptr a -> Bool (>) :: Ptr a -> Ptr a -> Bool (>=) :: Ptr a -> Ptr a -> Bool max :: Ptr a -> Ptr a -> Ptr a min :: Ptr a -> Ptr a -> Ptr a
Ord (FunPtr a)
Methods compare :: FunPtr a -> FunPtr a -> Ordering (<) :: FunPtr a -> FunPtr a -> Bool (<=) :: FunPtr a -> FunPtr a -> Bool (>) :: FunPtr a -> FunPtr a -> Bool (>=) :: FunPtr a -> FunPtr a -> Bool max :: FunPtr a -> FunPtr a -> FunPtr a min :: FunPtr a -> FunPtr a -> FunPtr a
Ord (U1 p)
Methods compare :: U1 p -> U1 p -> Ordering (<) :: U1 p -> U1 p -> Bool (<=) :: U1 p -> U1 p -> Bool (>) :: U1 p -> U1 p -> Bool (>=) :: U1 p -> U1 p -> Bool max :: U1 p -> U1 p -> U1 p min :: U1 p -> U1 p -> U1 p
Ord p => Ord (Par1 p)
Methods compare :: Par1 p -> Par1 p -> Ordering (<) :: Par1 p -> Par1 p -> Bool (<=) :: Par1 p -> Par1 p -> Bool (>) :: Par1 p -> Par1 p -> Bool (>=) :: Par1 p -> Par1 p -> Bool max :: Par1 p -> Par1 p -> Par1 p min :: Par1 p -> Par1 p -> Par1 p
Ord a => Ord (Maybe a)
Methods compare :: Maybe a -> Maybe a -> Ordering (<) :: Maybe a -> Maybe a -> Bool (<=) :: Maybe a -> Maybe a -> Bool (>) :: Maybe a -> Maybe a -> Bool (>=) :: Maybe a -> Maybe a -> Bool max :: Maybe a -> Maybe a -> Maybe a min :: Maybe a -> Maybe a -> Maybe a
Ord a => Ord (Down a)
Methods compare :: Down a -> Down a -> Ordering (<) :: Down a -> Down a -> Bool (<=) :: Down a -> Down a -> Bool (>) :: Down a -> Down a -> Bool (>=) :: Down a -> Down a -> Bool max :: Down a -> Down a -> Down a min :: Down a -> Down a -> Down a
Ord a => Ord (Last a)
Methods compare :: Last a -> Last a -> Ordering (<) :: Last a -> Last a -> Bool (<=) :: Last a -> Last a -> Bool (>) :: Last a -> Last a -> Bool (>=) :: Last a -> Last a -> Bool max :: Last a -> Last a -> Last a min :: Last a -> Last a -> Last a
Ord a => Ord (First a)
Methods compare :: First a -> First a -> Ordering (<) :: First a -> First a -> Bool (<=) :: First a -> First a -> Bool (>) :: First a -> First a -> Bool (>=) :: First a -> First a -> Bool max :: First a -> First a -> First a min :: First a -> First a -> First a
Ord a => Ord (Product a)
Methods compare :: Product a -> Product a -> Ordering (<) :: Product a -> Product a -> Bool (<=) :: Product a -> Product a -> Bool (>) :: Product a -> Product a -> Bool (>=) :: Product a -> Product a -> Bool max :: Product a -> Product a -> Product a min :: Product a -> Product a -> Product a
Ord a => Ord (Sum a)
Methods compare :: Sum a -> Sum a -> Ordering (<) :: Sum a -> Sum a -> Bool (<=) :: Sum a -> Sum a -> Bool (>) :: Sum a -> Sum a -> Bool (>=) :: Sum a -> Sum a -> Bool max :: Sum a -> Sum a -> Sum a min :: Sum a -> Sum a -> Sum a
Ord a => Ord (Dual a)
Methods compare :: Dual a -> Dual a -> Ordering (<) :: Dual a -> Dual a -> Bool (<=) :: Dual a -> Dual a -> Bool (>) :: Dual a -> Dual a -> Bool (>=) :: Dual a -> Dual a -> Bool max :: Dual a -> Dual a -> Dual a min :: Dual a -> Dual a -> Dual a
Ord (ForeignPtr a)
Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering (<) :: ForeignPtr a -> ForeignPtr a -> Bool (<=) :: ForeignPtr a -> ForeignPtr a -> Bool (>) :: ForeignPtr a -> ForeignPtr a -> Bool (>=) :: ForeignPtr a -> ForeignPtr a -> Bool max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a
Ord a => Ord (ZipList a)
Methods compare :: ZipList a -> ZipList a -> Ordering (<) :: ZipList a -> ZipList a -> Bool (<=) :: ZipList a -> ZipList a -> Bool (>) :: ZipList a -> ZipList a -> Bool (>=) :: ZipList a -> ZipList a -> Bool max :: ZipList a -> ZipList a -> ZipList a min :: ZipList a -> ZipList a -> ZipList a
Ord (Fixed a)
Methods compare :: Fixed a -> Fixed a -> Ordering (<) :: Fixed a -> Fixed a -> Bool (<=) :: Fixed a -> Fixed a -> Bool (>) :: Fixed a -> Fixed a -> Bool (>=) :: Fixed a -> Fixed a -> Bool max :: Fixed a -> Fixed a -> Fixed a min :: Fixed a -> Fixed a -> Fixed a
Ord a => Ord (Identity a)
Methods compare :: Identity a -> Identity a -> Ordering (<) :: Identity a -> Identity a -> Bool (<=) :: Identity a -> Identity a -> Bool (>) :: Identity a -> Identity a -> Bool (>=) :: Identity a -> Identity a -> Bool max :: Identity a -> Identity a -> Identity a min :: Identity a -> Identity a -> Identity a
(Ord a, Ord b) => Ord (Either a b)
Methods compare :: Either a b -> Either a b -> Ordering (<) :: Either a b -> Either a b -> Bool (<=) :: Either a b -> Either a b -> Bool (>) :: Either a b -> Either a b -> Bool (>=) :: Either a b -> Either a b -> Bool max :: Either a b -> Either a b -> Either a b min :: Either a b -> Either a b -> Either a b
Ord (f p) => Ord (Rec1 f p)
Methods compare :: Rec1 f p -> Rec1 f p -> Ordering (<) :: Rec1 f p -> Rec1 f p -> Bool (<=) :: Rec1 f p -> Rec1 f p -> Bool (>) :: Rec1 f p -> Rec1 f p -> Bool (>=) :: Rec1 f p -> Rec1 f p -> Bool max :: Rec1 f p -> Rec1 f p -> Rec1 f p min :: Rec1 f p -> Rec1 f p -> Rec1 f p
(Ord a, Ord b) => Ord (a, b)
Methods compare :: (a, b) -> (a, b) -> Ordering (<) :: (a, b) -> (a, b) -> Bool (<=) :: (a, b) -> (a, b) -> Bool (>) :: (a, b) -> (a, b) -> Bool (>=) :: (a, b) -> (a, b) -> Bool max :: (a, b) -> (a, b) -> (a, b) min :: (a, b) -> (a, b) -> (a, b)
Ord (Proxy k s)
Methods compare :: Proxy k s -> Proxy k s -> Ordering (<) :: Proxy k s -> Proxy k s -> Bool (<=) :: Proxy k s -> Proxy k s -> Bool (>) :: Proxy k s -> Proxy k s -> Bool (>=) :: Proxy k s -> Proxy k s -> Bool max :: Proxy k s -> Proxy k s -> Proxy k s min :: Proxy k s -> Proxy k s -> Proxy k s
Ord a => Ord (Const a b)
Methods compare :: Const a b -> Const a b -> Ordering (<) :: Const a b -> Const a b -> Bool (<=) :: Const a b -> Const a b -> Bool (>) :: Const a b -> Const a b -> Bool (>=) :: Const a b -> Const a b -> Bool max :: Const a b -> Const a b -> Const a b min :: Const a b -> Const a b -> Const a b
Ord c => Ord (K1 i c p)
Methods compare :: K1 i c p -> K1 i c p -> Ordering (<) :: K1 i c p -> K1 i c p -> Bool (<=) :: K1 i c p -> K1 i c p -> Bool (>) :: K1 i c p -> K1 i c p -> Bool (>=) :: K1 i c p -> K1 i c p -> Bool max :: K1 i c p -> K1 i c p -> K1 i c p min :: K1 i c p -> K1 i c p -> K1 i c p
(Ord (f p), Ord (g p)) => Ord ((:+:) f g p)
Methods compare :: (:+:) f g p -> (:+:) f g p -> Ordering (<) :: (:+:) f g p -> (:+:) f g p -> Bool (<=) :: (:+:) f g p -> (:+:) f g p -> Bool (>) :: (:+:) f g p -> (:+:) f g p -> Bool (>=) :: (:+:) f g p -> (:+:) f g p -> Bool max :: (:+:) f g p -> (:+:) f g p -> (:+:) f g p min :: (:+:) f g p -> (:+:) f g p -> (:+:) f g p
(Ord (f p), Ord (g p)) => Ord ((:*:) f g p)
Methods compare :: (::) f g p -> (::) f g p -> Ordering (<) :: (::) f g p -> (::) f g p -> Bool (<=) :: (::) f g p -> (::) f g p -> Bool (>) :: (::) f g p -> (::) f g p -> Bool (>=) :: (::) f g p -> (::) f g p -> Bool max :: (::) f g p -> (::) f g p -> (::) f g p min :: (::) f g p -> (::) f g p -> (::) f g p
Ord (f (g p)) => Ord ((:.:) f g p)
Methods compare :: (:.:) f g p -> (:.:) f g p -> Ordering (<) :: (:.:) f g p -> (:.:) f g p -> Bool (<=) :: (:.:) f g p -> (:.:) f g p -> Bool (>) :: (:.:) f g p -> (:.:) f g p -> Bool (>=) :: (:.:) f g p -> (:.:) f g p -> Bool max :: (:.:) f g p -> (:.:) f g p -> (:.:) f g p min :: (:.:) f g p -> (:.:) f g p -> (:.:) f g p
(Ord a, Ord b, Ord c) => Ord (a, b, c)
Methods compare :: (a, b, c) -> (a, b, c) -> Ordering (<) :: (a, b, c) -> (a, b, c) -> Bool (<=) :: (a, b, c) -> (a, b, c) -> Bool (>) :: (a, b, c) -> (a, b, c) -> Bool (>=) :: (a, b, c) -> (a, b, c) -> Bool max :: (a, b, c) -> (a, b, c) -> (a, b, c) min :: (a, b, c) -> (a, b, c) -> (a, b, c)
Ord ((:~:) k a b)
Methods compare :: (:~:) k a b -> (:~:) k a b -> Ordering (<) :: (:~:) k a b -> (:~:) k a b -> Bool (<=) :: (:~:) k a b -> (:~:) k a b -> Bool (>) :: (:~:) k a b -> (:~:) k a b -> Bool (>=) :: (:~:) k a b -> (:~:) k a b -> Bool max :: (:~:) k a b -> (:~:) k a b -> (:~:) k a b min :: (:~:) k a b -> (:~:) k a b -> (:~:) k a b
Ord (Coercion k a b)
Methods compare :: Coercion k a b -> Coercion k a b -> Ordering (<) :: Coercion k a b -> Coercion k a b -> Bool (<=) :: Coercion k a b -> Coercion k a b -> Bool (>) :: Coercion k a b -> Coercion k a b -> Bool (>=) :: Coercion k a b -> Coercion k a b -> Bool max :: Coercion k a b -> Coercion k a b -> Coercion k a b min :: Coercion k a b -> Coercion k a b -> Coercion k a b
Ord (f a) => Ord (Alt k f a)
Methods compare :: Alt k f a -> Alt k f a -> Ordering (<) :: Alt k f a -> Alt k f a -> Bool (<=) :: Alt k f a -> Alt k f a -> Bool (>) :: Alt k f a -> Alt k f a -> Bool (>=) :: Alt k f a -> Alt k f a -> Bool max :: Alt k f a -> Alt k f a -> Alt k f a min :: Alt k f a -> Alt k f a -> Alt k f a
Ord (f p) => Ord (M1 i c f p)
Methods compare :: M1 i c f p -> M1 i c f p -> Ordering (<) :: M1 i c f p -> M1 i c f p -> Bool (<=) :: M1 i c f p -> M1 i c f p -> Bool (>) :: M1 i c f p -> M1 i c f p -> Bool (>=) :: M1 i c f p -> M1 i c f p -> Bool max :: M1 i c f p -> M1 i c f p -> M1 i c f p min :: M1 i c f p -> M1 i c f p -> M1 i c f p
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
Methods compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering (<) :: (a, b, c, d) -> (a, b, c, d) -> Bool (<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool (>) :: (a, b, c, d) -> (a, b, c, d) -> Bool (>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
Methods compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering (<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool (<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool (>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool (>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f)
Methods compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering (<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool (<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool (>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool (>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (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)
Methods compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering (<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool (<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool (>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool (>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering (<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool (<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool (>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool (>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering (<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool (<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool (>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool (>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering (<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool (<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool (>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool (>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering (<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool (<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool (>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool (>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering (<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool (>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (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)
Methods compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering (<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool (<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool (>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool (>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

data Ordering :: *

Constructors

LT
EQ
GT

Instances

Bounded Ordering Source
Methods minBound :: Ordering Source maxBound :: Ordering Source
Enum Ordering Source
Methods succ :: Ordering -> Ordering Source pred :: Ordering -> Ordering Source toEnum :: Int -> Ordering Source fromEnum :: Ordering -> Int Source enumFrom :: Ordering -> [Ordering] Source enumFromThen :: Ordering -> Ordering -> [Ordering] Source enumFromTo :: Ordering -> Ordering -> [Ordering] Source enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] Source
Eq Ordering
Methods (==) :: Ordering -> Ordering -> Bool (/=) :: Ordering -> Ordering -> Bool
Data Ordering Source
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering Source toConstr :: Ordering -> Constr Source dataTypeOf :: Ordering -> DataType Source dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) Source dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) Source gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r Source gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering Source
Ord Ordering
Methods compare :: Ordering -> Ordering -> Ordering (<) :: Ordering -> Ordering -> Bool (<=) :: Ordering -> Ordering -> Bool (>) :: Ordering -> Ordering -> Bool (>=) :: Ordering -> Ordering -> Bool max :: Ordering -> Ordering -> Ordering min :: Ordering -> Ordering -> Ordering
Read Ordering Source
Methods readsPrec :: Int -> ReadS Ordering Source readList :: ReadS [Ordering] Source readPrec :: ReadPrec Ordering Source readListPrec :: ReadPrec [Ordering] Source
Show Ordering Source
Methods showsPrec :: Int -> Ordering -> ShowS Source show :: Ordering -> String Source showList :: [Ordering] -> ShowS Source
Ix Ordering Source
Methods range :: (Ordering, Ordering) -> [Ordering] Source index :: (Ordering, Ordering) -> Ordering -> Int Source unsafeIndex :: (Ordering, Ordering) -> Ordering -> Int inRange :: (Ordering, Ordering) -> Ordering -> Bool Source rangeSize :: (Ordering, Ordering) -> Int Source unsafeRangeSize :: (Ordering, Ordering) -> Int
Generic Ordering Source
Associated Types type Rep Ordering :: * -> * Source Methods from :: Ordering -> Rep Ordering x Source to :: Rep Ordering x -> Ordering Source
Monoid Ordering Source
Methods mempty :: Ordering Source mappend :: Ordering -> Ordering -> Ordering Source mconcat :: [Ordering] -> Ordering Source
type Rep Ordering
type (==) Ordering a b Source

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

Provides Show and Read instances (since: 4.7.0.0).

Since: 4.6.0.0

Constructors

Down a

Instances

Eq a => Eq (Down a) Source
Methods (==) :: Down a -> Down a -> Bool (/=) :: Down a -> Down a -> Bool
Ord a => Ord (Down a) Source
Methods compare :: Down a -> Down a -> Ordering (<) :: Down a -> Down a -> Bool (<=) :: Down a -> Down a -> Bool (>) :: Down a -> Down a -> Bool (>=) :: Down a -> Down a -> Bool max :: Down a -> Down a -> Down a min :: Down a -> Down a -> Down a
Read a => Read (Down a) Source
Methods readsPrec :: Int -> ReadS (Down a) Source readList :: ReadS [Down a] Source readPrec :: ReadPrec (Down a) Source readListPrec :: ReadPrec [Down a] Source
Show a => Show (Down a) Source
Methods showsPrec :: Int -> Down a -> ShowS Source show :: Down a -> String Source showList :: [Down a] -> ShowS Source

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