Data.Prd

Documentation

type PartialOrd a = (Prd a, Eq a)

A partial order on a.

Preorders

class Prd a where

A preorder on a.

A preorder relation <~ must satisfy the following two axioms:

\( \forall x: x \leq x \) (reflexivity)

\( \forall a, b, c: ((a \leq b) \wedge (b \leq c)) \Rightarrow (a \leq c) \) (transitivity)

If additionally we have:

\( \forall a, b: (a \leq b) \Leftrightarrow \neg (b \leq a) \) (anti-symmetry)

then a is a partial order and we may define an Eq instance such that the following holds:

x ~~ y = x == y
x <~ y = x < y || x == y

Minimal complete definition

(<~) | pcompare

Methods

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

Non-strict partial order relation on a.

<~ is reflexive, anti-symmetric, and transitive.

x <~ y = x < y || x ~~ y
x <~ y = maybe False (<~ EQ) (pcompare x y)

for all x, y in a.

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

Converse non-strict partial order relation on a.

>~ is reflexive, anti-symmetric, and transitive.

x >~ y = x > y || x ~~ y
x >~ y = maybe False (>~ EQ) (pcompare x y)

for all x, y in a.

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

Strict partial order relation on a.

< is irreflexive, asymmetric, and transitive.

x < y = x <~ y && not (y <~ x)
x < y = maybe False (< EQ) (pcompare x y)

When <~ is antisymmetric then a is a partial order and we have:

x > y = x >~ y && x /~ y

for all x, y in a.

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

Converse strict partial order relation on a.

> is irreflexive, asymmetric, and transitive.

x > y = x >~ y && not (y >~ x)
x > y = maybe False (> EQ) (pcompare x y)

When <~ is antisymmetric then a is a partial order and we have:

x > y = x >~ y && x /~ y

for all x, y in a.

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

Comparability relation on a.

?~ is reflexive, symmetric, and transitive.

If a implements Ord then we should have x ?~ y = True.

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

Equivalence relation on a.

~~ is reflexive, symmetric, and transitive.

x ~~ y = x <~ y && y <~ x
x ~~ y = maybe False (~~ EQ) (pcompare x y)

Use this as a lawful substitute for == when comparing floats, doubles, or rationals.

If a implements Eq then we should have (~~) = (==).

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

Negation of ~~.

pmax :: a -> a -> Maybe a infix 4

A partial version of max.

Returns the left-hand argument in the case of equality.

pmin :: a -> a -> Maybe a infix 4

A partial version of min.

Returns the left-hand argument in the case of equality.

similar :: a -> a -> Bool

Similarity relation on a.

similar is reflexive and symmetric, but not necessarily transitive.

Note this is only equivalent to == in a total (i.e. linear) order:

similar (0/0 :: Float) 5 = True

If a implements Ord then we should have (~~) = similar = (==).

pcompare :: a -> a -> Maybe Ordering infix 4

A partial version of compare.

x <  y = maybe False (<  EQ) (pcompare x y)
x >  y = maybe False (>  EQ) (pcompare x y)
x <~ y = maybe False (<~ EQ) (pcompare x y)
x >~ y = maybe False (>~ EQ) (pcompare x y)
x ~~ y = maybe False (~~ EQ) (pcompare x y)
x ?~ y = maybe False (const True) (pcompare x y)

If a implements Ord then we should have pcompare x y = Just $ compare x y.

Instances

Prd Bool

Defined in Data.Prd

Methods

(<~) :: Bool -> Bool -> Bool

(>~) :: Bool -> Bool -> Bool

(<) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(?~) :: Bool -> Bool -> Bool

(~~) :: Bool -> Bool -> Bool

(/~) :: Bool -> Bool -> Bool

pmax :: Bool -> Bool -> Maybe Bool

pmin :: Bool -> Bool -> Maybe Bool

similar :: Bool -> Bool -> Bool

pcompare :: Bool -> Bool -> Maybe Ordering

Prd Char

Defined in Data.Prd

Methods

(<~) :: Char -> Char -> Bool

(>~) :: Char -> Char -> Bool

(<) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(?~) :: Char -> Char -> Bool

(~~) :: Char -> Char -> Bool

(/~) :: Char -> Char -> Bool

pmax :: Char -> Char -> Maybe Char

pmin :: Char -> Char -> Maybe Char

similar :: Char -> Char -> Bool

pcompare :: Char -> Char -> Maybe Ordering

Prd Double

Defined in Data.Prd

Methods

(<~) :: Double -> Double -> Bool

(>~) :: Double -> Double -> Bool

(<) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(?~) :: Double -> Double -> Bool

(~~) :: Double -> Double -> Bool

(/~) :: Double -> Double -> Bool

pmax :: Double -> Double -> Maybe Double

pmin :: Double -> Double -> Maybe Double

similar :: Double -> Double -> Bool

pcompare :: Double -> Double -> Maybe Ordering

Prd Float

Defined in Data.Prd

Methods

(<~) :: Float -> Float -> Bool

(>~) :: Float -> Float -> Bool

(<) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(?~) :: Float -> Float -> Bool

(~~) :: Float -> Float -> Bool

(/~) :: Float -> Float -> Bool

pmax :: Float -> Float -> Maybe Float

pmin :: Float -> Float -> Maybe Float

similar :: Float -> Float -> Bool

pcompare :: Float -> Float -> Maybe Ordering

Prd Int

Defined in Data.Prd

Methods

(<~) :: Int -> Int -> Bool

(>~) :: Int -> Int -> Bool

(<) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(?~) :: Int -> Int -> Bool

(~~) :: Int -> Int -> Bool

(/~) :: Int -> Int -> Bool

pmax :: Int -> Int -> Maybe Int

pmin :: Int -> Int -> Maybe Int

similar :: Int -> Int -> Bool

pcompare :: Int -> Int -> Maybe Ordering

Prd Int8

Defined in Data.Prd

Methods

(<~) :: Int8 -> Int8 -> Bool

(>~) :: Int8 -> Int8 -> Bool

(<) :: Int8 -> Int8 -> Bool

(>) :: Int8 -> Int8 -> Bool

(?~) :: Int8 -> Int8 -> Bool

(~~) :: Int8 -> Int8 -> Bool

(/~) :: Int8 -> Int8 -> Bool

pmax :: Int8 -> Int8 -> Maybe Int8

pmin :: Int8 -> Int8 -> Maybe Int8

similar :: Int8 -> Int8 -> Bool

pcompare :: Int8 -> Int8 -> Maybe Ordering

Prd Int16

Defined in Data.Prd

Methods

(<~) :: Int16 -> Int16 -> Bool

(>~) :: Int16 -> Int16 -> Bool

(<) :: Int16 -> Int16 -> Bool

(>) :: Int16 -> Int16 -> Bool

(?~) :: Int16 -> Int16 -> Bool

(~~) :: Int16 -> Int16 -> Bool

(/~) :: Int16 -> Int16 -> Bool

pmax :: Int16 -> Int16 -> Maybe Int16

pmin :: Int16 -> Int16 -> Maybe Int16

similar :: Int16 -> Int16 -> Bool

pcompare :: Int16 -> Int16 -> Maybe Ordering

Prd Int32

Defined in Data.Prd

Methods

(<~) :: Int32 -> Int32 -> Bool

(>~) :: Int32 -> Int32 -> Bool

(<) :: Int32 -> Int32 -> Bool

(>) :: Int32 -> Int32 -> Bool

(?~) :: Int32 -> Int32 -> Bool

(~~) :: Int32 -> Int32 -> Bool

(/~) :: Int32 -> Int32 -> Bool

pmax :: Int32 -> Int32 -> Maybe Int32

pmin :: Int32 -> Int32 -> Maybe Int32

similar :: Int32 -> Int32 -> Bool

pcompare :: Int32 -> Int32 -> Maybe Ordering

Prd Int64

Defined in Data.Prd

Methods

(<~) :: Int64 -> Int64 -> Bool

(>~) :: Int64 -> Int64 -> Bool

(<) :: Int64 -> Int64 -> Bool

(>) :: Int64 -> Int64 -> Bool

(?~) :: Int64 -> Int64 -> Bool

(~~) :: Int64 -> Int64 -> Bool

(/~) :: Int64 -> Int64 -> Bool

pmax :: Int64 -> Int64 -> Maybe Int64

pmin :: Int64 -> Int64 -> Maybe Int64

similar :: Int64 -> Int64 -> Bool

pcompare :: Int64 -> Int64 -> Maybe Ordering

Prd Integer

Defined in Data.Prd

Methods

(<~) :: Integer -> Integer -> Bool

(>~) :: Integer -> Integer -> Bool

(<) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

(?~) :: Integer -> Integer -> Bool

(~~) :: Integer -> Integer -> Bool

(/~) :: Integer -> Integer -> Bool

pmax :: Integer -> Integer -> Maybe Integer

pmin :: Integer -> Integer -> Maybe Integer

similar :: Integer -> Integer -> Bool

pcompare :: Integer -> Integer -> Maybe Ordering

Prd Natural

Defined in Data.Prd

Methods

(<~) :: Natural -> Natural -> Bool

(>~) :: Natural -> Natural -> Bool

(<) :: Natural -> Natural -> Bool

(>) :: Natural -> Natural -> Bool

(?~) :: Natural -> Natural -> Bool

(~~) :: Natural -> Natural -> Bool

(/~) :: Natural -> Natural -> Bool

pmax :: Natural -> Natural -> Maybe Natural

pmin :: Natural -> Natural -> Maybe Natural

similar :: Natural -> Natural -> Bool

pcompare :: Natural -> Natural -> Maybe Ordering

Prd Ordering

Defined in Data.Prd

Methods

(<~) :: Ordering -> Ordering -> Bool

(>~) :: Ordering -> Ordering -> Bool

(<) :: Ordering -> Ordering -> Bool

(>) :: Ordering -> Ordering -> Bool

(?~) :: Ordering -> Ordering -> Bool

(~~) :: Ordering -> Ordering -> Bool

(/~) :: Ordering -> Ordering -> Bool

pmax :: Ordering -> Ordering -> Maybe Ordering

pmin :: Ordering -> Ordering -> Maybe Ordering

similar :: Ordering -> Ordering -> Bool

pcompare :: Ordering -> Ordering -> Maybe Ordering

Prd Word

Defined in Data.Prd

Methods

(<~) :: Word -> Word -> Bool

(>~) :: Word -> Word -> Bool

(<) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(?~) :: Word -> Word -> Bool

(~~) :: Word -> Word -> Bool

(/~) :: Word -> Word -> Bool

pmax :: Word -> Word -> Maybe Word

pmin :: Word -> Word -> Maybe Word

similar :: Word -> Word -> Bool

pcompare :: Word -> Word -> Maybe Ordering

Prd Word8

Defined in Data.Prd

Methods

(<~) :: Word8 -> Word8 -> Bool

(>~) :: Word8 -> Word8 -> Bool

(<) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(?~) :: Word8 -> Word8 -> Bool

(~~) :: Word8 -> Word8 -> Bool

(/~) :: Word8 -> Word8 -> Bool

pmax :: Word8 -> Word8 -> Maybe Word8

pmin :: Word8 -> Word8 -> Maybe Word8

similar :: Word8 -> Word8 -> Bool

pcompare :: Word8 -> Word8 -> Maybe Ordering

Prd Word16

Defined in Data.Prd

Methods

(<~) :: Word16 -> Word16 -> Bool

(>~) :: Word16 -> Word16 -> Bool

(<) :: Word16 -> Word16 -> Bool

(>) :: Word16 -> Word16 -> Bool

(?~) :: Word16 -> Word16 -> Bool

(~~) :: Word16 -> Word16 -> Bool

(/~) :: Word16 -> Word16 -> Bool

pmax :: Word16 -> Word16 -> Maybe Word16

pmin :: Word16 -> Word16 -> Maybe Word16

similar :: Word16 -> Word16 -> Bool

pcompare :: Word16 -> Word16 -> Maybe Ordering

Prd Word32

Defined in Data.Prd

Methods

(<~) :: Word32 -> Word32 -> Bool

(>~) :: Word32 -> Word32 -> Bool

(<) :: Word32 -> Word32 -> Bool

(>) :: Word32 -> Word32 -> Bool

(?~) :: Word32 -> Word32 -> Bool

(~~) :: Word32 -> Word32 -> Bool

(/~) :: Word32 -> Word32 -> Bool

pmax :: Word32 -> Word32 -> Maybe Word32

pmin :: Word32 -> Word32 -> Maybe Word32

similar :: Word32 -> Word32 -> Bool

pcompare :: Word32 -> Word32 -> Maybe Ordering

Prd Word64

Defined in Data.Prd

Methods

(<~) :: Word64 -> Word64 -> Bool

(>~) :: Word64 -> Word64 -> Bool

(<) :: Word64 -> Word64 -> Bool

(>) :: Word64 -> Word64 -> Bool

(?~) :: Word64 -> Word64 -> Bool

(~~) :: Word64 -> Word64 -> Bool

(/~) :: Word64 -> Word64 -> Bool

pmax :: Word64 -> Word64 -> Maybe Word64

pmin :: Word64 -> Word64 -> Maybe Word64

similar :: Word64 -> Word64 -> Bool

pcompare :: Word64 -> Word64 -> Maybe Ordering

Prd ()

Defined in Data.Prd

Methods

(<~) :: () -> () -> Bool

(>~) :: () -> () -> Bool

(<) :: () -> () -> Bool

(>) :: () -> () -> Bool

(?~) :: () -> () -> Bool

(~~) :: () -> () -> Bool

(/~) :: () -> () -> Bool

pmax :: () -> () -> Maybe ()

pmin :: () -> () -> Maybe ()

similar :: () -> () -> Bool

pcompare :: () -> () -> Maybe Ordering

Prd All

Defined in Data.Prd

Methods

(<~) :: All -> All -> Bool

(>~) :: All -> All -> Bool

(<) :: All -> All -> Bool

(>) :: All -> All -> Bool

(?~) :: All -> All -> Bool

(~~) :: All -> All -> Bool

(/~) :: All -> All -> Bool

pmax :: All -> All -> Maybe All

pmin :: All -> All -> Maybe All

similar :: All -> All -> Bool

pcompare :: All -> All -> Maybe Ordering

Prd Any

Defined in Data.Prd

Methods

(<~) :: Any -> Any -> Bool

(>~) :: Any -> Any -> Bool

(<) :: Any -> Any -> Bool

(>) :: Any -> Any -> Bool

(?~) :: Any -> Any -> Bool

(~~) :: Any -> Any -> Bool

(/~) :: Any -> Any -> Bool

pmax :: Any -> Any -> Maybe Any

pmin :: Any -> Any -> Maybe Any

similar :: Any -> Any -> Bool

pcompare :: Any -> Any -> Maybe Ordering

Prd IntSet

Defined in Data.Prd

Methods

(<~) :: IntSet -> IntSet -> Bool

(>~) :: IntSet -> IntSet -> Bool

(<) :: IntSet -> IntSet -> Bool

(>) :: IntSet -> IntSet -> Bool

(?~) :: IntSet -> IntSet -> Bool

(~~) :: IntSet -> IntSet -> Bool

(/~) :: IntSet -> IntSet -> Bool

pmax :: IntSet -> IntSet -> Maybe IntSet

pmin :: IntSet -> IntSet -> Maybe IntSet

similar :: IntSet -> IntSet -> Bool

pcompare :: IntSet -> IntSet -> Maybe Ordering

Prd a => Prd [a]

Defined in Data.Prd

Methods

(<~) :: [a] -> [a] -> Bool

(>~) :: [a] -> [a] -> Bool

(<) :: [a] -> [a] -> Bool

(>) :: [a] -> [a] -> Bool

(?~) :: [a] -> [a] -> Bool

(~~) :: [a] -> [a] -> Bool

(/~) :: [a] -> [a] -> Bool

pmax :: [a] -> [a] -> Maybe [a]

pmin :: [a] -> [a] -> Maybe [a]

similar :: [a] -> [a] -> Bool

pcompare :: [a] -> [a] -> Maybe Ordering

Prd a => Prd (Maybe a)

Defined in Data.Prd

Methods

(<~) :: Maybe a -> Maybe a -> Bool

(>~) :: Maybe a -> Maybe a -> Bool

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

(>) :: Maybe a -> Maybe a -> Bool

(?~) :: Maybe a -> Maybe a -> Bool

(~~) :: Maybe a -> Maybe a -> Bool

(/~) :: Maybe a -> Maybe a -> Bool

pmax :: Maybe a -> Maybe a -> Maybe (Maybe a)

pmin :: Maybe a -> Maybe a -> Maybe (Maybe a)

similar :: Maybe a -> Maybe a -> Bool

pcompare :: Maybe a -> Maybe a -> Maybe Ordering

Prd (Ratio Integer)

Defined in Data.Prd

Methods

(<~) :: Ratio Integer -> Ratio Integer -> Bool

(>~) :: Ratio Integer -> Ratio Integer -> Bool

(<) :: Ratio Integer -> Ratio Integer -> Bool

(>) :: Ratio Integer -> Ratio Integer -> Bool

(?~) :: Ratio Integer -> Ratio Integer -> Bool

(~~) :: Ratio Integer -> Ratio Integer -> Bool

(/~) :: Ratio Integer -> Ratio Integer -> Bool

pmax :: Ratio Integer -> Ratio Integer -> Maybe (Ratio Integer)

pmin :: Ratio Integer -> Ratio Integer -> Maybe (Ratio Integer)

similar :: Ratio Integer -> Ratio Integer -> Bool

pcompare :: Ratio Integer -> Ratio Integer -> Maybe Ordering

Prd (Ratio Natural)

Defined in Data.Prd

Methods

(<~) :: Ratio Natural -> Ratio Natural -> Bool

(>~) :: Ratio Natural -> Ratio Natural -> Bool

(<) :: Ratio Natural -> Ratio Natural -> Bool

(>) :: Ratio Natural -> Ratio Natural -> Bool

(?~) :: Ratio Natural -> Ratio Natural -> Bool

(~~) :: Ratio Natural -> Ratio Natural -> Bool

(/~) :: Ratio Natural -> Ratio Natural -> Bool

pmax :: Ratio Natural -> Ratio Natural -> Maybe (Ratio Natural)

pmin :: Ratio Natural -> Ratio Natural -> Maybe (Ratio Natural)

similar :: Ratio Natural -> Ratio Natural -> Bool

pcompare :: Ratio Natural -> Ratio Natural -> Maybe Ordering

Prd a => Prd (Min a)

Defined in Data.Prd

Methods

(<~) :: Min a -> Min a -> Bool

(>~) :: Min a -> Min a -> Bool

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

(>) :: Min a -> Min a -> Bool

(?~) :: Min a -> Min a -> Bool

(~~) :: Min a -> Min a -> Bool

(/~) :: Min a -> Min a -> Bool

pmax :: Min a -> Min a -> Maybe (Min a)

pmin :: Min a -> Min a -> Maybe (Min a)

similar :: Min a -> Min a -> Bool

pcompare :: Min a -> Min a -> Maybe Ordering

Prd a => Prd (Max a)

Defined in Data.Prd

Methods

(<~) :: Max a -> Max a -> Bool

(>~) :: Max a -> Max a -> Bool

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

(>) :: Max a -> Max a -> Bool

(?~) :: Max a -> Max a -> Bool

(~~) :: Max a -> Max a -> Bool

(/~) :: Max a -> Max a -> Bool

pmax :: Max a -> Max a -> Maybe (Max a)

pmin :: Max a -> Max a -> Maybe (Max a)

similar :: Max a -> Max a -> Bool

pcompare :: Max a -> Max a -> Maybe Ordering

Prd a => Prd (Dual a)

Defined in Data.Prd

Methods

(<~) :: Dual a -> Dual a -> Bool

(>~) :: Dual a -> Dual a -> Bool

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

(>) :: Dual a -> Dual a -> Bool

(?~) :: Dual a -> Dual a -> Bool

(~~) :: Dual a -> Dual a -> Bool

(/~) :: Dual a -> Dual a -> Bool

pmax :: Dual a -> Dual a -> Maybe (Dual a)

pmin :: Dual a -> Dual a -> Maybe (Dual a)

similar :: Dual a -> Dual a -> Bool

pcompare :: Dual a -> Dual a -> Maybe Ordering

(Finite a, Prd a) => Prd (Endo a)

Defined in Data.Prd

Methods

(<~) :: Endo a -> Endo a -> Bool

(>~) :: Endo a -> Endo a -> Bool

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

(>) :: Endo a -> Endo a -> Bool

(?~) :: Endo a -> Endo a -> Bool

(~~) :: Endo a -> Endo a -> Bool

(/~) :: Endo a -> Endo a -> Bool

pmax :: Endo a -> Endo a -> Maybe (Endo a)

pmin :: Endo a -> Endo a -> Maybe (Endo a)

similar :: Endo a -> Endo a -> Bool

pcompare :: Endo a -> Endo a -> Maybe Ordering

Prd a => Prd (Down a)

Defined in Data.Prd

Methods

(<~) :: Down a -> Down a -> Bool

(>~) :: Down a -> Down a -> Bool

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

(>) :: Down a -> Down a -> Bool

(?~) :: Down a -> Down a -> Bool

(~~) :: Down a -> Down a -> Bool

(/~) :: Down a -> Down a -> Bool

pmax :: Down a -> Down a -> Maybe (Down a)

pmin :: Down a -> Down a -> Maybe (Down a)

similar :: Down a -> Down a -> Bool

pcompare :: Down a -> Down a -> Maybe Ordering

Prd a => Prd (NonEmpty a)

Defined in Data.Prd

Methods

(<~) :: NonEmpty a -> NonEmpty a -> Bool

(>~) :: NonEmpty a -> NonEmpty a -> Bool

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

(>) :: NonEmpty a -> NonEmpty a -> Bool

(?~) :: NonEmpty a -> NonEmpty a -> Bool

(~~) :: NonEmpty a -> NonEmpty a -> Bool

(/~) :: NonEmpty a -> NonEmpty a -> Bool

pmax :: NonEmpty a -> NonEmpty a -> Maybe (NonEmpty a)

pmin :: NonEmpty a -> NonEmpty a -> Maybe (NonEmpty a)

similar :: NonEmpty a -> NonEmpty a -> Bool

pcompare :: NonEmpty a -> NonEmpty a -> Maybe Ordering

Prd a => Prd (IntMap a)

Defined in Data.Prd

Methods

(<~) :: IntMap a -> IntMap a -> Bool

(>~) :: IntMap a -> IntMap a -> Bool

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

(>) :: IntMap a -> IntMap a -> Bool

(?~) :: IntMap a -> IntMap a -> Bool

(~~) :: IntMap a -> IntMap a -> Bool

(/~) :: IntMap a -> IntMap a -> Bool

pmax :: IntMap a -> IntMap a -> Maybe (IntMap a)

pmin :: IntMap a -> IntMap a -> Maybe (IntMap a)

similar :: IntMap a -> IntMap a -> Bool

pcompare :: IntMap a -> IntMap a -> Maybe Ordering

Ord a => Prd (Set a)

Defined in Data.Prd

Methods

(<~) :: Set a -> Set a -> Bool

(>~) :: Set a -> Set a -> Bool

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

(>) :: Set a -> Set a -> Bool

(?~) :: Set a -> Set a -> Bool

(~~) :: Set a -> Set a -> Bool

(/~) :: Set a -> Set a -> Bool

pmax :: Set a -> Set a -> Maybe (Set a)

pmin :: Set a -> Set a -> Maybe (Set a)

similar :: Set a -> Set a -> Bool

pcompare :: Set a -> Set a -> Maybe Ordering

(Eq a, Semigroup (Meet a)) => Prd (Meet a)

Defined in Data.Semigroup.Join

Methods

(<~) :: Meet a -> Meet a -> Bool

(>~) :: Meet a -> Meet a -> Bool

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

(>) :: Meet a -> Meet a -> Bool

(?~) :: Meet a -> Meet a -> Bool

(~~) :: Meet a -> Meet a -> Bool

(/~) :: Meet a -> Meet a -> Bool

pmax :: Meet a -> Meet a -> Maybe (Meet a)

pmin :: Meet a -> Meet a -> Maybe (Meet a)

similar :: Meet a -> Meet a -> Bool

pcompare :: Meet a -> Meet a -> Maybe Ordering

(Eq a, Semigroup (Join a)) => Prd (Join a)

Defined in Data.Semigroup.Join

Methods

(<~) :: Join a -> Join a -> Bool

(>~) :: Join a -> Join a -> Bool

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

(>) :: Join a -> Join a -> Bool

(?~) :: Join a -> Join a -> Bool

(~~) :: Join a -> Join a -> Bool

(/~) :: Join a -> Join a -> Bool

pmax :: Join a -> Join a -> Maybe (Join a)

pmin :: Join a -> Join a -> Maybe (Join a)

similar :: Join a -> Join a -> Bool

pcompare :: Join a -> Join a -> Maybe Ordering

Prd a => Prd (Extended a)

Defined in Data.Lattice

Methods

(<~) :: Extended a -> Extended a -> Bool

(>~) :: Extended a -> Extended a -> Bool

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

(>) :: Extended a -> Extended a -> Bool

(?~) :: Extended a -> Extended a -> Bool

(~~) :: Extended a -> Extended a -> Bool

(/~) :: Extended a -> Extended a -> Bool

pmax :: Extended a -> Extended a -> Maybe (Extended a)

pmin :: Extended a -> Extended a -> Maybe (Extended a)

similar :: Extended a -> Extended a -> Bool

pcompare :: Extended a -> Extended a -> Maybe Ordering

(Finite a, Prd b) => Prd (a -> b)

Defined in Data.Prd

Methods

(<~) :: (a -> b) -> (a -> b) -> Bool

(>~) :: (a -> b) -> (a -> b) -> Bool

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

(>) :: (a -> b) -> (a -> b) -> Bool

(?~) :: (a -> b) -> (a -> b) -> Bool

(~~) :: (a -> b) -> (a -> b) -> Bool

(/~) :: (a -> b) -> (a -> b) -> Bool

pmax :: (a -> b) -> (a -> b) -> Maybe (a -> b)

pmin :: (a -> b) -> (a -> b) -> Maybe (a -> b)

similar :: (a -> b) -> (a -> b) -> Bool

pcompare :: (a -> b) -> (a -> b) -> Maybe Ordering

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

Defined in Data.Prd

Methods

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

(?~) :: Either a b -> Either a b -> Bool

(~~) :: Either a b -> Either a b -> Bool

(/~) :: Either a b -> Either a b -> Bool

pmax :: Either a b -> Either a b -> Maybe (Either a b)

pmin :: Either a b -> Either a b -> Maybe (Either a b)

similar :: Either a b -> Either a b -> Bool

pcompare :: Either a b -> Either a b -> Maybe Ordering

(Prd a, Prd b) => Prd (a, b)

Defined in Data.Prd

Methods

(<~) :: (a, b) -> (a, b) -> Bool

(>~) :: (a, b) -> (a, b) -> Bool

(<) :: (a, b) -> (a, b) -> Bool

(>) :: (a, b) -> (a, b) -> Bool

(?~) :: (a, b) -> (a, b) -> Bool

(~~) :: (a, b) -> (a, b) -> Bool

(/~) :: (a, b) -> (a, b) -> Bool

pmax :: (a, b) -> (a, b) -> Maybe (a, b)

pmin :: (a, b) -> (a, b) -> Maybe (a, b)

similar :: (a, b) -> (a, b) -> Bool

pcompare :: (a, b) -> (a, b) -> Maybe Ordering

(Ord k, Prd a) => Prd (Map k a)

Defined in Data.Prd

Methods

(<~) :: Map k a -> Map k a -> Bool

(>~) :: Map k a -> Map k a -> Bool

(<) :: Map k a -> Map k a -> Bool

(>) :: Map k a -> Map k a -> Bool

(?~) :: Map k a -> Map k a -> Bool

(~~) :: Map k a -> Map k a -> Bool

(/~) :: Map k a -> Map k a -> Bool

pmax :: Map k a -> Map k a -> Maybe (Map k a)

pmin :: Map k a -> Map k a -> Maybe (Map k a)

similar :: Map k a -> Map k a -> Bool

pcompare :: Map k a -> Map k a -> Maybe Ordering

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

Defined in Data.Prd

Methods

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

(?~) :: (a, b, c) -> (a, b, c) -> Bool

(~~) :: (a, b, c) -> (a, b, c) -> Bool

(/~) :: (a, b, c) -> (a, b, c) -> Bool

pmax :: (a, b, c) -> (a, b, c) -> Maybe (a, b, c)

pmin :: (a, b, c) -> (a, b, c) -> Maybe (a, b, c)

similar :: (a, b, c) -> (a, b, c) -> Bool

pcompare :: (a, b, c) -> (a, b, c) -> Maybe Ordering

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

Defined in Data.Prd

Methods

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

(?~) :: (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

pmax :: (a, b, c, d) -> (a, b, c, d) -> Maybe (a, b, c, d)

pmin :: (a, b, c, d) -> (a, b, c, d) -> Maybe (a, b, c, d)

similar :: (a, b, c, d) -> (a, b, c, d) -> Bool

pcompare :: (a, b, c, d) -> (a, b, c, d) -> Maybe Ordering

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

Defined in Data.Prd

Methods

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

(?~) :: (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

pmax :: (a, b, c, d, e) -> (a, b, c, d, e) -> Maybe (a, b, c, d, e)

pmin :: (a, b, c, d, e) -> (a, b, c, d, e) -> Maybe (a, b, c, d, e)

similar :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

pcompare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Maybe Ordering

pcompareEq :: Eq a => (a -> a -> Bool) -> a -> a -> Maybe Ordering

Version of pcompare that uses a semiorder relation and ==.

See https://en.wikipedia.org/wiki/Semiorder.

pcompareOrd :: Ord a => a -> a -> Maybe Ordering

Version of pcompare that uses compare.

pcompareRat :: Ratio Integer -> Ratio Integer -> Maybe Ordering

Re-exports

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.

The Haskell Report defines no laws for Ord. However, <= is customarily expected to implement a non-strict partial order and have the following properties:

Transitivity

if x <= y && y <= z = True, then x <= z = True

Reflexivity

x <= x = True

Antisymmetry

if x <= y && y <= x = True, then x == y = True

Note that the following operator interactions are expected to hold:

1. x >= y = y <= x
2. x < y = x <= y && x /= y
3. x > y = y < x
4. x < y = compare x y == LT
5. x > y = compare x y == GT
6. x == y = compare x y == EQ
7. min x y == if x <= y then x else y = True
8. max x y == if x >= y then x else y = True

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

max :: a -> a -> a

min :: a -> a -> a

Instances

Ord Bool

Defined in GHC.Classes

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

Defined in GHC.Classes

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

Note that due to the presence of NaN, Double's Ord instance does not satisfy reflexivity.

>>> 0/0 <= (0/0 :: Double)
False

Also note that, due to the same, Ord's operator interactions are not respected by Double's instance:

>>> (0/0 :: Double) > 1
False
>>> compare (0/0 :: Double) 1
GT

Defined in GHC.Classes

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

Note that due to the presence of NaN, Float's Ord instance does not satisfy reflexivity.

>>> 0/0 <= (0/0 :: Float)
False

Also note that, due to the same, Ord's operator interactions are not respected by Float's instance:

>>> (0/0 :: Float) > 1
False
>>> compare (0/0 :: Float) 1
GT

Defined in GHC.Classes

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

Defined in GHC.Classes

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

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

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

Since: base-2.1

Defined in GHC.Int

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

Defined in GHC.Integer.Type

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 Natural

Since: base-4.8.0.0

Defined in GHC.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 Ordering

Defined in GHC.Classes

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

Defined in GHC.Classes

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

Since: base-2.1

Defined in GHC.Word

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

Since: base-2.1

Defined in GHC.Word

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

Since: base-2.1

Defined in GHC.Word

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

Since: base-2.1

Defined in GHC.Word

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 Exp

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Exp -> Exp -> Ordering

(<) :: Exp -> Exp -> Bool

(<=) :: Exp -> Exp -> Bool

(>) :: Exp -> Exp -> Bool

(>=) :: Exp -> Exp -> Bool

max :: Exp -> Exp -> Exp

min :: Exp -> Exp -> Exp

Ord Match

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Match -> Match -> Ordering

(<) :: Match -> Match -> Bool

(<=) :: Match -> Match -> Bool

(>) :: Match -> Match -> Bool

(>=) :: Match -> Match -> Bool

max :: Match -> Match -> Match

min :: Match -> Match -> Match

Ord Clause

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Clause -> Clause -> Ordering

(<) :: Clause -> Clause -> Bool

(<=) :: Clause -> Clause -> Bool

(>) :: Clause -> Clause -> Bool

(>=) :: Clause -> Clause -> Bool

max :: Clause -> Clause -> Clause

min :: Clause -> Clause -> Clause

Ord Pat

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Pat -> Pat -> Ordering

(<) :: Pat -> Pat -> Bool

(<=) :: Pat -> Pat -> Bool

(>) :: Pat -> Pat -> Bool

(>=) :: Pat -> Pat -> Bool

max :: Pat -> Pat -> Pat

min :: Pat -> Pat -> Pat

Ord Type

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Type -> Type -> Ordering

(<) :: Type -> Type -> Bool

(<=) :: Type -> Type -> Bool

(>) :: Type -> Type -> Bool

(>=) :: Type -> Type -> Bool

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Ord Dec

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Dec -> Dec -> Ordering

(<) :: Dec -> Dec -> Bool

(<=) :: Dec -> Dec -> Bool

(>) :: Dec -> Dec -> Bool

(>=) :: Dec -> Dec -> Bool

max :: Dec -> Dec -> Dec

min :: Dec -> Dec -> Dec

Ord Name

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Ord FunDep

Defined in Language.Haskell.TH.Syntax

Methods

compare :: FunDep -> FunDep -> Ordering

(<) :: FunDep -> FunDep -> Bool

(<=) :: FunDep -> FunDep -> Bool

(>) :: FunDep -> FunDep -> Bool

(>=) :: FunDep -> FunDep -> Bool

max :: FunDep -> FunDep -> FunDep

min :: FunDep -> FunDep -> FunDep

Ord InjectivityAnn

Defined in Language.Haskell.TH.Syntax

Methods

compare :: InjectivityAnn -> InjectivityAnn -> Ordering

(<) :: InjectivityAnn -> InjectivityAnn -> Bool

(<=) :: InjectivityAnn -> InjectivityAnn -> Bool

(>) :: InjectivityAnn -> InjectivityAnn -> Bool

(>=) :: InjectivityAnn -> InjectivityAnn -> Bool

max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

Ord Overlap

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Overlap -> Overlap -> Ordering

(<) :: Overlap -> Overlap -> Bool

(<=) :: Overlap -> Overlap -> Bool

(>) :: Overlap -> Overlap -> Bool

(>=) :: Overlap -> Overlap -> Bool

max :: Overlap -> Overlap -> Overlap

min :: Overlap -> Overlap -> Overlap

Ord ()

Defined in GHC.Classes

Methods

compare :: () -> () -> Ordering

(<) :: () -> () -> Bool

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

(>) :: () -> () -> Bool

(>=) :: () -> () -> Bool

max :: () -> () -> ()

min :: () -> () -> ()

Ord TyCon

Defined in GHC.Classes

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 BigNat

Defined in GHC.Integer.Type

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 Void

Since: base-4.8.0.0

Defined in Data.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 Version

Since: base-2.1

Defined in Data.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 AsyncException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

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 ArrayException

Since: base-4.2.0.0

Defined in GHC.IO.Exception

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 ExitCode

Defined in GHC.IO.Exception

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 All

Since: base-2.1

Defined in Data.Semigroup.Internal

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 Any

Since: base-2.1

Defined in Data.Semigroup.Internal

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 Fixity

Since: base-4.6.0.0

Defined in GHC.Generics

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 Associativity

Since: base-4.6.0.0

Defined in GHC.Generics

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 SourceUnpackedness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering

(<) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

Ord SourceStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering

(<) :: SourceStrictness -> SourceStrictness -> Bool

(<=) :: SourceStrictness -> SourceStrictness -> Bool

(>) :: SourceStrictness -> SourceStrictness -> Bool

(>=) :: SourceStrictness -> SourceStrictness -> Bool

max :: SourceStrictness -> SourceStrictness -> SourceStrictness

min :: SourceStrictness -> SourceStrictness -> SourceStrictness

Ord DecidedStrictness

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: DecidedStrictness -> DecidedStrictness -> Ordering

(<) :: DecidedStrictness -> DecidedStrictness -> Bool

(<=) :: DecidedStrictness -> DecidedStrictness -> Bool

(>) :: DecidedStrictness -> DecidedStrictness -> Bool

(>=) :: DecidedStrictness -> DecidedStrictness -> Bool

max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

Ord CChar

Defined in Foreign.C.Types

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 CSChar

Defined in Foreign.C.Types

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 CUChar

Defined in Foreign.C.Types

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 CShort

Defined in Foreign.C.Types

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 CUShort

Defined in Foreign.C.Types

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 CInt

Defined in Foreign.C.Types

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 CUInt

Defined in Foreign.C.Types

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 CLong

Defined in Foreign.C.Types

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 CULong

Defined in Foreign.C.Types

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 CLLong

Defined in Foreign.C.Types

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 CULLong

Defined in Foreign.C.Types

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 CBool

Defined in Foreign.C.Types

Methods

compare :: CBool -> CBool -> Ordering

(<) :: CBool -> CBool -> Bool

(<=) :: CBool -> CBool -> Bool

(>) :: CBool -> CBool -> Bool

(>=) :: CBool -> CBool -> Bool

max :: CBool -> CBool -> CBool

min :: CBool -> CBool -> CBool

Ord CFloat

Defined in Foreign.C.Types

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 CDouble

Defined in Foreign.C.Types

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 CPtrdiff

Defined in Foreign.C.Types

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 CSize

Defined in Foreign.C.Types

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 CWchar

Defined in Foreign.C.Types

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 CSigAtomic

Defined in Foreign.C.Types

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 CClock

Defined in Foreign.C.Types

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 CTime

Defined in Foreign.C.Types

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 CUSeconds

Defined in Foreign.C.Types

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 CSUSeconds

Defined in Foreign.C.Types

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 CIntPtr

Defined in Foreign.C.Types

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 CUIntPtr

Defined in Foreign.C.Types

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 CIntMax

Defined in Foreign.C.Types

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 CUIntMax

Defined in Foreign.C.Types

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 IntSet

Defined in Data.IntSet.Internal

Methods

compare :: IntSet -> IntSet -> Ordering

(<) :: IntSet -> IntSet -> Bool

(<=) :: IntSet -> IntSet -> Bool

(>) :: IntSet -> IntSet -> Bool

(>=) :: IntSet -> IntSet -> Bool

max :: IntSet -> IntSet -> IntSet

min :: IntSet -> IntSet -> IntSet

Ord ModName

Defined in Language.Haskell.TH.Syntax

Methods

compare :: ModName -> ModName -> Ordering

(<) :: ModName -> ModName -> Bool

(<=) :: ModName -> ModName -> Bool

(>) :: ModName -> ModName -> Bool

(>=) :: ModName -> ModName -> Bool

max :: ModName -> ModName -> ModName

min :: ModName -> ModName -> ModName

Ord PkgName

Defined in Language.Haskell.TH.Syntax

Methods

compare :: PkgName -> PkgName -> Ordering

(<) :: PkgName -> PkgName -> Bool

(<=) :: PkgName -> PkgName -> Bool

(>) :: PkgName -> PkgName -> Bool

(>=) :: PkgName -> PkgName -> Bool

max :: PkgName -> PkgName -> PkgName

min :: PkgName -> PkgName -> PkgName

Ord Module

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Module -> Module -> Ordering

(<) :: Module -> Module -> Bool

(<=) :: Module -> Module -> Bool

(>) :: Module -> Module -> Bool

(>=) :: Module -> Module -> Bool

max :: Module -> Module -> Module

min :: Module -> Module -> Module

Ord OccName

Defined in Language.Haskell.TH.Syntax

Methods

compare :: OccName -> OccName -> Ordering

(<) :: OccName -> OccName -> Bool

(<=) :: OccName -> OccName -> Bool

(>) :: OccName -> OccName -> Bool

(>=) :: OccName -> OccName -> Bool

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

Ord NameFlavour

Defined in Language.Haskell.TH.Syntax

Methods

compare :: NameFlavour -> NameFlavour -> Ordering

(<) :: NameFlavour -> NameFlavour -> Bool

(<=) :: NameFlavour -> NameFlavour -> Bool

(>) :: NameFlavour -> NameFlavour -> Bool

(>=) :: NameFlavour -> NameFlavour -> Bool

max :: NameFlavour -> NameFlavour -> NameFlavour

min :: NameFlavour -> NameFlavour -> NameFlavour

Ord NameSpace

Defined in Language.Haskell.TH.Syntax

Methods

compare :: NameSpace -> NameSpace -> Ordering

(<) :: NameSpace -> NameSpace -> Bool

(<=) :: NameSpace -> NameSpace -> Bool

(>) :: NameSpace -> NameSpace -> Bool

(>=) :: NameSpace -> NameSpace -> Bool

max :: NameSpace -> NameSpace -> NameSpace

min :: NameSpace -> NameSpace -> NameSpace

Ord Loc

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Loc -> Loc -> Ordering

(<) :: Loc -> Loc -> Bool

(<=) :: Loc -> Loc -> Bool

(>) :: Loc -> Loc -> Bool

(>=) :: Loc -> Loc -> Bool

max :: Loc -> Loc -> Loc

min :: Loc -> Loc -> Loc

Ord Info

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Info -> Info -> Ordering

(<) :: Info -> Info -> Bool

(<=) :: Info -> Info -> Bool

(>) :: Info -> Info -> Bool

(>=) :: Info -> Info -> Bool

max :: Info -> Info -> Info

min :: Info -> Info -> Info

Ord ModuleInfo

Defined in Language.Haskell.TH.Syntax

Methods

compare :: ModuleInfo -> ModuleInfo -> Ordering

(<) :: ModuleInfo -> ModuleInfo -> Bool

(<=) :: ModuleInfo -> ModuleInfo -> Bool

(>) :: ModuleInfo -> ModuleInfo -> Bool

(>=) :: ModuleInfo -> ModuleInfo -> Bool

max :: ModuleInfo -> ModuleInfo -> ModuleInfo

min :: ModuleInfo -> ModuleInfo -> ModuleInfo

Ord Fixity

Defined in Language.Haskell.TH.Syntax

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 FixityDirection

Defined in Language.Haskell.TH.Syntax

Methods

compare :: FixityDirection -> FixityDirection -> Ordering

(<) :: FixityDirection -> FixityDirection -> Bool

(<=) :: FixityDirection -> FixityDirection -> Bool

(>) :: FixityDirection -> FixityDirection -> Bool

(>=) :: FixityDirection -> FixityDirection -> Bool

max :: FixityDirection -> FixityDirection -> FixityDirection

min :: FixityDirection -> FixityDirection -> FixityDirection

Ord Lit

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Lit -> Lit -> Ordering

(<) :: Lit -> Lit -> Bool

(<=) :: Lit -> Lit -> Bool

(>) :: Lit -> Lit -> Bool

(>=) :: Lit -> Lit -> Bool

max :: Lit -> Lit -> Lit

min :: Lit -> Lit -> Lit

Ord Body

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Body -> Body -> Ordering

(<) :: Body -> Body -> Bool

(<=) :: Body -> Body -> Bool

(>) :: Body -> Body -> Bool

(>=) :: Body -> Body -> Bool

max :: Body -> Body -> Body

min :: Body -> Body -> Body

Ord Guard

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Guard -> Guard -> Ordering

(<) :: Guard -> Guard -> Bool

(<=) :: Guard -> Guard -> Bool

(>) :: Guard -> Guard -> Bool

(>=) :: Guard -> Guard -> Bool

max :: Guard -> Guard -> Guard

min :: Guard -> Guard -> Guard

Ord Stmt

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Stmt -> Stmt -> Ordering

(<) :: Stmt -> Stmt -> Bool

(<=) :: Stmt -> Stmt -> Bool

(>) :: Stmt -> Stmt -> Bool

(>=) :: Stmt -> Stmt -> Bool

max :: Stmt -> Stmt -> Stmt

min :: Stmt -> Stmt -> Stmt

Ord Range

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Range -> Range -> Ordering

(<) :: Range -> Range -> Bool

(<=) :: Range -> Range -> Bool

(>) :: Range -> Range -> Bool

(>=) :: Range -> Range -> Bool

max :: Range -> Range -> Range

min :: Range -> Range -> Range

Ord DerivClause

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DerivClause -> DerivClause -> Ordering

(<) :: DerivClause -> DerivClause -> Bool

(<=) :: DerivClause -> DerivClause -> Bool

(>) :: DerivClause -> DerivClause -> Bool

(>=) :: DerivClause -> DerivClause -> Bool

max :: DerivClause -> DerivClause -> DerivClause

min :: DerivClause -> DerivClause -> DerivClause

Ord DerivStrategy

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DerivStrategy -> DerivStrategy -> Ordering

(<) :: DerivStrategy -> DerivStrategy -> Bool

(<=) :: DerivStrategy -> DerivStrategy -> Bool

(>) :: DerivStrategy -> DerivStrategy -> Bool

(>=) :: DerivStrategy -> DerivStrategy -> Bool

max :: DerivStrategy -> DerivStrategy -> DerivStrategy

min :: DerivStrategy -> DerivStrategy -> DerivStrategy

Ord TypeFamilyHead

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering

(<) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(<=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(>) :: TypeFamilyHead -> TypeFamilyHead -> Bool

(>=) :: TypeFamilyHead -> TypeFamilyHead -> Bool

max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

Ord TySynEqn

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TySynEqn -> TySynEqn -> Ordering

(<) :: TySynEqn -> TySynEqn -> Bool

(<=) :: TySynEqn -> TySynEqn -> Bool

(>) :: TySynEqn -> TySynEqn -> Bool

(>=) :: TySynEqn -> TySynEqn -> Bool

max :: TySynEqn -> TySynEqn -> TySynEqn

min :: TySynEqn -> TySynEqn -> TySynEqn

Ord Foreign

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Foreign -> Foreign -> Ordering

(<) :: Foreign -> Foreign -> Bool

(<=) :: Foreign -> Foreign -> Bool

(>) :: Foreign -> Foreign -> Bool

(>=) :: Foreign -> Foreign -> Bool

max :: Foreign -> Foreign -> Foreign

min :: Foreign -> Foreign -> Foreign

Ord Callconv

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Callconv -> Callconv -> Ordering

(<) :: Callconv -> Callconv -> Bool

(<=) :: Callconv -> Callconv -> Bool

(>) :: Callconv -> Callconv -> Bool

(>=) :: Callconv -> Callconv -> Bool

max :: Callconv -> Callconv -> Callconv

min :: Callconv -> Callconv -> Callconv

Ord Safety

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Safety -> Safety -> Ordering

(<) :: Safety -> Safety -> Bool

(<=) :: Safety -> Safety -> Bool

(>) :: Safety -> Safety -> Bool

(>=) :: Safety -> Safety -> Bool

max :: Safety -> Safety -> Safety

min :: Safety -> Safety -> Safety

Ord Pragma

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Pragma -> Pragma -> Ordering

(<) :: Pragma -> Pragma -> Bool

(<=) :: Pragma -> Pragma -> Bool

(>) :: Pragma -> Pragma -> Bool

(>=) :: Pragma -> Pragma -> Bool

max :: Pragma -> Pragma -> Pragma

min :: Pragma -> Pragma -> Pragma

Ord Inline

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Inline -> Inline -> Ordering

(<) :: Inline -> Inline -> Bool

(<=) :: Inline -> Inline -> Bool

(>) :: Inline -> Inline -> Bool

(>=) :: Inline -> Inline -> Bool

max :: Inline -> Inline -> Inline

min :: Inline -> Inline -> Inline

Ord RuleMatch

Defined in Language.Haskell.TH.Syntax

Methods

compare :: RuleMatch -> RuleMatch -> Ordering

(<) :: RuleMatch -> RuleMatch -> Bool

(<=) :: RuleMatch -> RuleMatch -> Bool

(>) :: RuleMatch -> RuleMatch -> Bool

(>=) :: RuleMatch -> RuleMatch -> Bool

max :: RuleMatch -> RuleMatch -> RuleMatch

min :: RuleMatch -> RuleMatch -> RuleMatch

Ord Phases

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Phases -> Phases -> Ordering

(<) :: Phases -> Phases -> Bool

(<=) :: Phases -> Phases -> Bool

(>) :: Phases -> Phases -> Bool

(>=) :: Phases -> Phases -> Bool

max :: Phases -> Phases -> Phases

min :: Phases -> Phases -> Phases

Ord RuleBndr

Defined in Language.Haskell.TH.Syntax

Methods

compare :: RuleBndr -> RuleBndr -> Ordering

(<) :: RuleBndr -> RuleBndr -> Bool

(<=) :: RuleBndr -> RuleBndr -> Bool

(>) :: RuleBndr -> RuleBndr -> Bool

(>=) :: RuleBndr -> RuleBndr -> Bool

max :: RuleBndr -> RuleBndr -> RuleBndr

min :: RuleBndr -> RuleBndr -> RuleBndr

Ord AnnTarget

Defined in Language.Haskell.TH.Syntax

Methods

compare :: AnnTarget -> AnnTarget -> Ordering

(<) :: AnnTarget -> AnnTarget -> Bool

(<=) :: AnnTarget -> AnnTarget -> Bool

(>) :: AnnTarget -> AnnTarget -> Bool

(>=) :: AnnTarget -> AnnTarget -> Bool

max :: AnnTarget -> AnnTarget -> AnnTarget

min :: AnnTarget -> AnnTarget -> AnnTarget

Ord SourceUnpackedness

Defined in Language.Haskell.TH.Syntax

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering

(<) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>) :: SourceUnpackedness -> SourceUnpackedness -> Bool

(>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

Ord SourceStrictness

Defined in Language.Haskell.TH.Syntax

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering

(<) :: SourceStrictness -> SourceStrictness -> Bool

(<=) :: SourceStrictness -> SourceStrictness -> Bool

(>) :: SourceStrictness -> SourceStrictness -> Bool

(>=) :: SourceStrictness -> SourceStrictness -> Bool

max :: SourceStrictness -> SourceStrictness -> SourceStrictness

min :: SourceStrictness -> SourceStrictness -> SourceStrictness

Ord DecidedStrictness

Defined in Language.Haskell.TH.Syntax

Methods

compare :: DecidedStrictness -> DecidedStrictness -> Ordering

(<) :: DecidedStrictness -> DecidedStrictness -> Bool

(<=) :: DecidedStrictness -> DecidedStrictness -> Bool

(>) :: DecidedStrictness -> DecidedStrictness -> Bool

(>=) :: DecidedStrictness -> DecidedStrictness -> Bool

max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

Ord Con

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Con -> Con -> Ordering

(<) :: Con -> Con -> Bool

(<=) :: Con -> Con -> Bool

(>) :: Con -> Con -> Bool

(>=) :: Con -> Con -> Bool

max :: Con -> Con -> Con

min :: Con -> Con -> Con

Ord Bang

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Bang -> Bang -> Ordering

(<) :: Bang -> Bang -> Bool

(<=) :: Bang -> Bang -> Bool

(>) :: Bang -> Bang -> Bool

(>=) :: Bang -> Bang -> Bool

max :: Bang -> Bang -> Bang

min :: Bang -> Bang -> Bang

Ord PatSynDir

Defined in Language.Haskell.TH.Syntax

Methods

compare :: PatSynDir -> PatSynDir -> Ordering

(<) :: PatSynDir -> PatSynDir -> Bool

(<=) :: PatSynDir -> PatSynDir -> Bool

(>) :: PatSynDir -> PatSynDir -> Bool

(>=) :: PatSynDir -> PatSynDir -> Bool

max :: PatSynDir -> PatSynDir -> PatSynDir

min :: PatSynDir -> PatSynDir -> PatSynDir

Ord PatSynArgs

Defined in Language.Haskell.TH.Syntax

Methods

compare :: PatSynArgs -> PatSynArgs -> Ordering

(<) :: PatSynArgs -> PatSynArgs -> Bool

(<=) :: PatSynArgs -> PatSynArgs -> Bool

(>) :: PatSynArgs -> PatSynArgs -> Bool

(>=) :: PatSynArgs -> PatSynArgs -> Bool

max :: PatSynArgs -> PatSynArgs -> PatSynArgs

min :: PatSynArgs -> PatSynArgs -> PatSynArgs

Ord TyVarBndr

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TyVarBndr -> TyVarBndr -> Ordering

(<) :: TyVarBndr -> TyVarBndr -> Bool

(<=) :: TyVarBndr -> TyVarBndr -> Bool

(>) :: TyVarBndr -> TyVarBndr -> Bool

(>=) :: TyVarBndr -> TyVarBndr -> Bool

max :: TyVarBndr -> TyVarBndr -> TyVarBndr

min :: TyVarBndr -> TyVarBndr -> TyVarBndr

Ord FamilyResultSig

Defined in Language.Haskell.TH.Syntax

Methods

compare :: FamilyResultSig -> FamilyResultSig -> Ordering

(<) :: FamilyResultSig -> FamilyResultSig -> Bool

(<=) :: FamilyResultSig -> FamilyResultSig -> Bool

(>) :: FamilyResultSig -> FamilyResultSig -> Bool

(>=) :: FamilyResultSig -> FamilyResultSig -> Bool

max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

Ord TyLit

Defined in Language.Haskell.TH.Syntax

Methods

compare :: TyLit -> TyLit -> Ordering

(<) :: TyLit -> TyLit -> Bool

(<=) :: TyLit -> TyLit -> Bool

(>) :: TyLit -> TyLit -> Bool

(>=) :: TyLit -> TyLit -> Bool

max :: TyLit -> TyLit -> TyLit

min :: TyLit -> TyLit -> TyLit

Ord Role

Defined in Language.Haskell.TH.Syntax

Methods

compare :: Role -> Role -> Ordering

(<) :: Role -> Role -> Bool

(<=) :: Role -> Role -> Bool

(>) :: Role -> Role -> Bool

(>=) :: Role -> Role -> Bool

max :: Role -> Role -> Role

min :: Role -> Role -> Role

Ord AnnLookup

Defined in Language.Haskell.TH.Syntax

Methods

compare :: AnnLookup -> AnnLookup -> Ordering

(<) :: AnnLookup -> AnnLookup -> Bool

(<=) :: AnnLookup -> AnnLookup -> Bool

(>) :: AnnLookup -> AnnLookup -> Bool

(>=) :: AnnLookup -> AnnLookup -> Bool

max :: AnnLookup -> AnnLookup -> AnnLookup

min :: AnnLookup -> AnnLookup -> AnnLookup

Ord a => Ord [a]

Defined in GHC.Classes

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]

Ord a => Ord (Maybe a)

Since: base-2.1

Defined in GHC.Maybe

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

Integral a => Ord (Ratio a)

Since: base-2.0.1

Defined in GHC.Real

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)

Since: base-2.1

Defined in GHC.Ptr

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)

Defined in GHC.Ptr

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 p => Ord (Par1 p)

Since: base-4.7.0.0

Defined in GHC.Generics

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

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

compare :: Min a -> Min a -> Ordering

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

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

(>) :: Min a -> Min a -> Bool

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

max :: Min a -> Min a -> Min a

min :: Min a -> Min a -> Min a

Ord a => Ord (Max a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

compare :: Max a -> Max a -> Ordering

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

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

(>) :: Max a -> Max a -> Bool

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

max :: Max a -> Max a -> Max a

min :: Max a -> Max a -> Max a

Ord a => Ord (First a)

Since: base-4.9.0.0

Defined in Data.Semigroup

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

Since: base-4.9.0.0

Defined in Data.Semigroup

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 m => Ord (WrappedMonoid m)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering

(<) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(>) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool

max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

Ord a => Ord (Option a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

compare :: Option a -> Option a -> Ordering

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

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

(>) :: Option a -> Option a -> Bool

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

max :: Option a -> Option a -> Option a

min :: Option a -> Option a -> Option a

Ord a => Ord (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

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 a => Ord (Identity a)

Since: base-4.8.0.0

Defined in Data.Functor.Identity

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

Since: base-2.1

Defined in Data.Monoid

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

Since: base-2.1

Defined in Data.Monoid

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

Since: base-2.1

Defined in Data.Semigroup.Internal

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 a => Ord (Sum a)

Since: base-2.1

Defined in Data.Semigroup.Internal

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

Since: base-2.1

Defined in Data.Semigroup.Internal

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

Since: base-4.6.0.0

Defined in Data.Ord

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

Since: base-4.9.0.0

Defined in GHC.Base

Methods

compare :: NonEmpty a -> NonEmpty a -> Ordering

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

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

(>) :: NonEmpty a -> NonEmpty a -> Bool

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

max :: NonEmpty a -> NonEmpty a -> NonEmpty a

min :: NonEmpty a -> NonEmpty a -> NonEmpty a

Ord a => Ord (IntMap a)

Defined in Data.IntMap.Internal

Methods

compare :: IntMap a -> IntMap a -> Ordering

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

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

(>) :: IntMap a -> IntMap a -> Bool

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

max :: IntMap a -> IntMap a -> IntMap a

min :: IntMap a -> IntMap a -> IntMap a

Ord a => Ord (Seq a)

Defined in Data.Sequence.Internal

Methods

compare :: Seq a -> Seq a -> Ordering

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

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

(>) :: Seq a -> Seq a -> Bool

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

max :: Seq a -> Seq a -> Seq a

min :: Seq a -> Seq a -> Seq a

Ord a => Ord (ViewL a)

Defined in Data.Sequence.Internal

Methods

compare :: ViewL a -> ViewL a -> Ordering

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

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

(>) :: ViewL a -> ViewL a -> Bool

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

max :: ViewL a -> ViewL a -> ViewL a

min :: ViewL a -> ViewL a -> ViewL a

Ord a => Ord (ViewR a)

Defined in Data.Sequence.Internal

Methods

compare :: ViewR a -> ViewR a -> Ordering

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

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

(>) :: ViewR a -> ViewR a -> Bool

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

max :: ViewR a -> ViewR a -> ViewR a

min :: ViewR a -> ViewR a -> ViewR a

Ord a => Ord (Set a)

Defined in Data.Set.Internal

Methods

compare :: Set a -> Set a -> Ordering

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

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

(>) :: Set a -> Set a -> Bool

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

max :: Set a -> Set a -> Set a

min :: Set a -> Set a -> Set a

Ord a => Ord (Hashed a)

Defined in Data.Hashable.Class

Methods

compare :: Hashed a -> Hashed a -> Ordering

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

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

(>) :: Hashed a -> Hashed a -> Bool

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

max :: Hashed a -> Hashed a -> Hashed a

min :: Hashed a -> Hashed a -> Hashed a

Ord a => Ord (HashSet a)

Defined in Data.HashSet.Base

Methods

compare :: HashSet a -> HashSet a -> Ordering

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

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

(>) :: HashSet a -> HashSet a -> Bool

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

max :: HashSet a -> HashSet a -> HashSet a

min :: HashSet a -> HashSet a -> HashSet a

Ord a => Ord (Meet a)

Defined in Data.Semigroup.Join

Methods

compare :: Meet a -> Meet a -> Ordering

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

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

(>) :: Meet a -> Meet a -> Bool

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

max :: Meet a -> Meet a -> Meet a

min :: Meet a -> Meet a -> Meet a

Ord a => Ord (Join a)

Defined in Data.Semigroup.Join

Methods

compare :: Join a -> Join a -> Ordering

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

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

(>) :: Join a -> Join a -> Bool

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

max :: Join a -> Join a -> Join a

min :: Join a -> Join a -> Join a

Ord a => Ord (Extended a)

Defined in Data.Lattice

Methods

compare :: Extended a -> Extended a -> Ordering

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

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

(>) :: Extended a -> Extended a -> Bool

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

max :: Extended a -> Extended a -> Extended a

min :: Extended a -> Extended a -> Extended a

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

Since: base-2.1

Defined in Data.Either

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: V1 p -> V1 p -> Ordering

(<) :: V1 p -> V1 p -> Bool

(<=) :: V1 p -> V1 p -> Bool

(>) :: V1 p -> V1 p -> Bool

(>=) :: V1 p -> V1 p -> Bool

max :: V1 p -> V1 p -> V1 p

min :: V1 p -> V1 p -> V1 p

Ord (U1 p)

Since: base-4.7.0.0

Defined in GHC.Generics

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 a, Ord b) => Ord (a, b)

Defined in GHC.Classes

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 a => Ord (Arg a b)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

compare :: Arg a b -> Arg a b -> Ordering

(<) :: Arg a b -> Arg a b -> Bool

(<=) :: Arg a b -> Arg a b -> Bool

(>) :: Arg a b -> Arg a b -> Bool

(>=) :: Arg a b -> Arg a b -> Bool

max :: Arg a b -> Arg a b -> Arg a b

min :: Arg a b -> Arg a b -> Arg a b

Ord (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

compare :: Proxy s -> Proxy s -> Ordering

(<) :: Proxy s -> Proxy s -> Bool

(<=) :: Proxy s -> Proxy s -> Bool

(>) :: Proxy s -> Proxy s -> Bool

(>=) :: Proxy s -> Proxy s -> Bool

max :: Proxy s -> Proxy s -> Proxy s

min :: Proxy s -> Proxy s -> Proxy s

(Ord k, Ord v) => Ord (Map k v)

Defined in Data.Map.Internal

Methods

compare :: Map k v -> Map k v -> Ordering

(<) :: Map k v -> Map k v -> Bool

(<=) :: Map k v -> Map k v -> Bool

(>) :: Map k v -> Map k v -> Bool

(>=) :: Map k v -> Map k v -> Bool

max :: Map k v -> Map k v -> Map k v

min :: Map k v -> Map k v -> Map k v

(Ord k, Ord v) => Ord (HashMap k v)

The order is total.

Note: Because the hash is not guaranteed to be stable across library versions, OSes, or architectures, neither is an actual order of elements in HashMap or an result of compare.is stable.

Defined in Data.HashMap.Base

Methods

compare :: HashMap k v -> HashMap k v -> Ordering

(<) :: HashMap k v -> HashMap k v -> Bool

(<=) :: HashMap k v -> HashMap k v -> Bool

(>) :: HashMap k v -> HashMap k v -> Bool

(>=) :: HashMap k v -> HashMap k v -> Bool

max :: HashMap k v -> HashMap k v -> HashMap k v

min :: HashMap k v -> HashMap k v -> HashMap k v

Ord (f a) => Ord (F1 f a)

Defined in Data.Semigroup.Join

Methods

compare :: F1 f a -> F1 f a -> Ordering

(<) :: F1 f a -> F1 f a -> Bool

(<=) :: F1 f a -> F1 f a -> Bool

(>) :: F1 f a -> F1 f a -> Bool

(>=) :: F1 f a -> F1 f a -> Bool

max :: F1 f a -> F1 f a -> F1 f a

min :: F1 f a -> F1 f a -> F1 f a

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

Since: base-4.7.0.0

Defined in GHC.Generics

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 (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

Ord (URec Char p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

Ord (URec Double p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

Ord (URec Float p)

Defined in GHC.Generics

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

Ord (URec Int p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Int p -> URec Int p -> Ordering

(<) :: URec Int p -> URec Int p -> Bool

(<=) :: URec Int p -> URec Int p -> Bool

(>) :: URec Int p -> URec Int p -> Bool

(>=) :: URec Int p -> URec Int p -> Bool

max :: URec Int p -> URec Int p -> URec Int p

min :: URec Int p -> URec Int p -> URec Int p

Ord (URec Word p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec Word p -> URec Word p -> Ordering

(<) :: URec Word p -> URec Word p -> Bool

(<=) :: URec Word p -> URec Word p -> Bool

(>) :: URec Word p -> URec Word p -> Bool

(>=) :: URec Word p -> URec Word p -> Bool

max :: URec Word p -> URec Word p -> URec Word p

min :: URec Word p -> URec Word p -> URec Word p

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

Defined in GHC.Classes

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 a => Ord (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

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 (f a) => Ord (Ap f a)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

compare :: Ap f a -> Ap f a -> Ordering

(<) :: Ap f a -> Ap f a -> Bool

(<=) :: Ap f a -> Ap f a -> Bool

(>) :: Ap f a -> Ap f a -> Bool

(>=) :: Ap f a -> Ap f a -> Bool

max :: Ap f a -> Ap f a -> Ap f a

min :: Ap f a -> Ap f a -> Ap f a

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

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

compare :: Alt f a -> Alt f a -> Ordering

(<) :: Alt f a -> Alt f a -> Bool

(<=) :: Alt f a -> Alt f a -> Bool

(>) :: Alt f a -> Alt f a -> Bool

(>=) :: Alt f a -> Alt f a -> Bool

max :: Alt f a -> Alt f a -> Alt f a

min :: Alt f a -> Alt f a -> Alt f a

Ord (p a a) => Ord (Join p a)

Defined in Data.Bifunctor.Join

Methods

compare :: Join p a -> Join p a -> Ordering

(<) :: Join p a -> Join p a -> Bool

(<=) :: Join p a -> Join p a -> Bool

(>) :: Join p a -> Join p a -> Bool

(>=) :: Join p a -> Join p a -> Bool

max :: Join p a -> Join p a -> Join p a

min :: Join p a -> Join p a -> Join p a

(Ord1 f, Ord a) => Ord (IdentityT f a)

Defined in Control.Monad.Trans.Identity

Methods

compare :: IdentityT f a -> IdentityT f a -> Ordering

(<) :: IdentityT f a -> IdentityT f a -> Bool

(<=) :: IdentityT f a -> IdentityT f a -> Bool

(>) :: IdentityT f a -> IdentityT f a -> Bool

(>=) :: IdentityT f a -> IdentityT f a -> Bool

max :: IdentityT f a -> IdentityT f a -> IdentityT f a

min :: IdentityT f a -> IdentityT f a -> IdentityT f a

(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a)

Defined in Control.Monad.Trans.Error

Methods

compare :: ErrorT e m a -> ErrorT e m a -> Ordering

(<) :: ErrorT e m a -> ErrorT e m a -> Bool

(<=) :: ErrorT e m a -> ErrorT e m a -> Bool

(>) :: ErrorT e m a -> ErrorT e m a -> Bool

(>=) :: ErrorT e m a -> ErrorT e m a -> Bool

max :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

min :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

Ord b => Ord (Tagged s b)

Defined in Data.Tagged

Methods

compare :: Tagged s b -> Tagged s b -> Ordering

(<) :: Tagged s b -> Tagged s b -> Bool

(<=) :: Tagged s b -> Tagged s b -> Bool

(>) :: Tagged s b -> Tagged s b -> Bool

(>=) :: Tagged s b -> Tagged s b -> Bool

max :: Tagged s b -> Tagged s b -> Tagged s b

min :: Tagged s b -> Tagged s b -> Tagged s b

Ord (f (g a)) => Ord (F2 f g a)

Defined in Data.Semigroup.Join

Methods

compare :: F2 f g a -> F2 f g a -> Ordering

(<) :: F2 f g a -> F2 f g a -> Bool

(<=) :: F2 f g a -> F2 f g a -> Bool

(>) :: F2 f g a -> F2 f g a -> Bool

(>=) :: F2 f g a -> F2 f g a -> Bool

max :: F2 f g a -> F2 f g a -> F2 f g a

min :: F2 f g a -> F2 f g a -> F2 f g a

Ord c => Ord (K1 i c p)

Since: base-4.7.0.0

Defined in GHC.Generics

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)

Since: base-4.7.0.0

Defined in GHC.Generics

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)

Since: base-4.7.0.0

Defined in GHC.Generics

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 d) => Ord (a, b, c, d)

Defined in GHC.Classes

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)

(Ord1 f, Ord1 g, Ord a) => Ord (Product f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

compare :: Product f g a -> Product f g a -> Ordering

(<) :: Product f g a -> Product f g a -> Bool

(<=) :: Product f g a -> Product f g a -> Bool

(>) :: Product f g a -> Product f g a -> Bool

(>=) :: Product f g a -> Product f g a -> Bool

max :: Product f g a -> Product f g a -> Product f g a

min :: Product f g a -> Product f g a -> Product f g a

(Ord1 f, Ord1 g, Ord a) => Ord (Sum f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

compare :: Sum f g a -> Sum f g a -> Ordering

(<) :: Sum f g a -> Sum f g a -> Bool

(<=) :: Sum f g a -> Sum f g a -> Bool

(>) :: Sum f g a -> Sum f g a -> Bool

(>=) :: Sum f g a -> Sum f g a -> Bool

max :: Sum f g a -> Sum f g a -> Sum f g a

min :: Sum f g a -> Sum f g a -> Sum f g a

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

Since: base-4.7.0.0

Defined in GHC.Generics

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 (f (g p)) => Ord ((f :.: g) p)

Since: base-4.7.0.0

Defined in GHC.Generics

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 d, Ord e) => Ord (a, b, c, d, e)

Defined in GHC.Classes

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)

(Ord1 f, Ord1 g, Ord a) => Ord (Compose f g a)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

compare :: Compose f g a -> Compose f g a -> Ordering

(<) :: Compose f g a -> Compose f g a -> Bool

(<=) :: Compose f g a -> Compose f g a -> Bool

(>) :: Compose f g a -> Compose f g a -> Bool

(>=) :: Compose f g a -> Compose f g a -> Bool

max :: Compose f g a -> Compose f g a -> Compose f g a

min :: Compose f g a -> Compose f g a -> Compose f g a

Ord (p a b) => Ord (WrappedBifunctor p a b)

Defined in Data.Bifunctor.Wrapped

Methods

compare :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Ordering

(<) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(<=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(>) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

(>=) :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> Bool

max :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b

min :: WrappedBifunctor p a b -> WrappedBifunctor p a b -> WrappedBifunctor p a b

Ord (g b) => Ord (Joker g a b)

Defined in Data.Bifunctor.Joker

Methods

compare :: Joker g a b -> Joker g a b -> Ordering

(<) :: Joker g a b -> Joker g a b -> Bool

(<=) :: Joker g a b -> Joker g a b -> Bool

(>) :: Joker g a b -> Joker g a b -> Bool

(>=) :: Joker g a b -> Joker g a b -> Bool

max :: Joker g a b -> Joker g a b -> Joker g a b

min :: Joker g a b -> Joker g a b -> Joker g a b

Ord (p b a) => Ord (Flip p a b)

Defined in Data.Bifunctor.Flip

Methods

compare :: Flip p a b -> Flip p a b -> Ordering

(<) :: Flip p a b -> Flip p a b -> Bool

(<=) :: Flip p a b -> Flip p a b -> Bool

(>) :: Flip p a b -> Flip p a b -> Bool

(>=) :: Flip p a b -> Flip p a b -> Bool

max :: Flip p a b -> Flip p a b -> Flip p a b

min :: Flip p a b -> Flip p a b -> Flip p a b

Ord (f a) => Ord (Clown f a b)

Defined in Data.Bifunctor.Clown

Methods

compare :: Clown f a b -> Clown f a b -> Ordering

(<) :: Clown f a b -> Clown f a b -> Bool

(<=) :: Clown f a b -> Clown f a b -> Bool

(>) :: Clown f a b -> Clown f a b -> Bool

(>=) :: Clown f a b -> Clown f a b -> Bool

max :: Clown f a b -> Clown f a b -> Clown f a b

min :: Clown f a b -> Clown f a b -> Clown f a b

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

Defined in GHC.Classes

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 (f a b), Ord (g a b)) => Ord (Product f g a b)

Defined in Data.Bifunctor.Product

Methods

compare :: Product f g a b -> Product f g a b -> Ordering

(<) :: Product f g a b -> Product f g a b -> Bool

(<=) :: Product f g a b -> Product f g a b -> Bool

(>) :: Product f g a b -> Product f g a b -> Bool

(>=) :: Product f g a b -> Product f g a b -> Bool

max :: Product f g a b -> Product f g a b -> Product f g a b

min :: Product f g a b -> Product f g a b -> Product f g a b

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

Defined in GHC.Classes

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 (f (p a b)) => Ord (Tannen f p a b)

Defined in Data.Bifunctor.Tannen

Methods

compare :: Tannen f p a b -> Tannen f p a b -> Ordering

(<) :: Tannen f p a b -> Tannen f p a b -> Bool

(<=) :: Tannen f p a b -> Tannen f p a b -> Bool

(>) :: Tannen f p a b -> Tannen f p a b -> Bool

(>=) :: Tannen f p a b -> Tannen f p a b -> Bool

max :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b

min :: Tannen f p a b -> Tannen f p a b -> Tannen f p a b

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

Defined in GHC.Classes

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)

Defined in GHC.Classes

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 (p (f a) (g b)) => Ord (Biff p f g a b)

Defined in Data.Bifunctor.Biff

Methods

compare :: Biff p f g a b -> Biff p f g a b -> Ordering

(<) :: Biff p f g a b -> Biff p f g a b -> Bool

(<=) :: Biff p f g a b -> Biff p f g a b -> Bool

(>) :: Biff p f g a b -> Biff p f g a b -> Bool

(>=) :: Biff p f g a b -> Biff p f g a b -> Bool

max :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b

min :: Biff p f g a b -> Biff p f g a b -> Biff p f g a b

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

Defined in GHC.Classes

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)

Defined in GHC.Classes

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)

Defined in GHC.Classes

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)

Defined in GHC.Classes

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)

Defined in GHC.Classes

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)

Defined in GHC.Classes

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)

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

Since: base-4.6.0.0

Constructors

Down a

Instances

Monad Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(>>=) :: Down a -> (a -> Down b) -> Down b

(>>) :: Down a -> Down b -> Down b

return :: a -> Down a

fail :: String -> Down a

Functor Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

fmap :: (a -> b) -> Down a -> Down b

(<$) :: a -> Down b -> Down a

Applicative Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

pure :: a -> Down a

(<*>) :: Down (a -> b) -> Down a -> Down b

liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c

(*>) :: Down a -> Down b -> Down b

(<*) :: Down a -> Down b -> Down a

Foldable Down

Since: base-4.12.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Down m -> m

foldMap :: Monoid m => (a -> m) -> Down a -> m

foldr :: (a -> b -> b) -> b -> Down a -> b

foldr' :: (a -> b -> b) -> b -> Down a -> b

foldl :: (b -> a -> b) -> b -> Down a -> b

foldl' :: (b -> a -> b) -> b -> Down a -> b

foldr1 :: (a -> a -> a) -> Down a -> a

foldl1 :: (a -> a -> a) -> Down a -> a

toList :: Down a -> [a]

null :: Down a -> Bool

length :: Down a -> Int

elem :: Eq a => a -> Down a -> Bool

maximum :: Ord a => Down a -> a

minimum :: Ord a => Down a -> a

sum :: Num a => Down a -> a

product :: Num a => Down a -> a

Traversable Down

Since: base-4.12.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Down a -> f (Down b)

sequenceA :: Applicative f => Down (f a) -> f (Down a)

mapM :: Monad m => (a -> m b) -> Down a -> m (Down b)

sequence :: Monad m => Down (m a) -> m (Down a)

Eq1 Down

Since: base-4.12.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Down a -> Down b -> Bool

Ord1 Down

Since: base-4.12.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> Down a -> Down b -> Ordering

Read1 Down

Since: base-4.12.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Down a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Down a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Down a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Down a]

Show1 Down

Since: base-4.12.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Down a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Down a] -> ShowS

Apply Down

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Down (a -> b) -> Down a -> Down b

(.>) :: Down a -> Down b -> Down b

(<.) :: Down a -> Down b -> Down a

liftF2 :: (a -> b -> c) -> Down a -> Down b -> Down c

Bind Down

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: Down a -> (a -> Down b) -> Down b

join :: Down (Down a) -> Down a

Eq a => Eq (Down a)

Since: base-4.6.0.0

Defined in Data.Ord

Methods

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

(/=) :: Down a -> Down a -> Bool

Num a => Num (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(+) :: Down a -> Down a -> Down a

(-) :: Down a -> Down a -> Down a

(*) :: Down a -> Down a -> Down a

negate :: Down a -> Down a

abs :: Down a -> Down a

signum :: Down a -> Down a

fromInteger :: Integer -> Down a

Ord a => Ord (Down a)

Since: base-4.6.0.0

Defined in Data.Ord

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)

Since: base-4.7.0.0

Defined in Data.Ord

Methods

readsPrec :: Int -> ReadS (Down a)

readList :: ReadS [Down a]

readPrec :: ReadPrec (Down a)

readListPrec :: ReadPrec [Down a]

Show a => Show (Down a)

Since: base-4.7.0.0

Defined in Data.Ord

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String

showList :: [Down a] -> ShowS

Generic (Down a)

Defined in GHC.Generics

Associated Types

type Rep (Down a) :: Type -> Type

Methods

from :: Down a -> Rep (Down a) x

to :: Rep (Down a) x -> Down a

Semigroup a => Semigroup (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

(<>) :: Down a -> Down a -> Down a

sconcat :: NonEmpty (Down a) -> Down a

stimes :: Integral b => b -> Down a -> Down a

Semigroup (Join a) => Semigroup (Meet (Down a))

Defined in Data.Semigroup.Join

Methods

(<>) :: Meet (Down a) -> Meet (Down a) -> Meet (Down a)

sconcat :: NonEmpty (Meet (Down a)) -> Meet (Down a)

stimes :: Integral b => b -> Meet (Down a) -> Meet (Down a)

Semigroup (Meet a) => Semigroup (Join (Down a))

Defined in Data.Semigroup.Join

Methods

(<>) :: Join (Down a) -> Join (Down a) -> Join (Down a)

sconcat :: NonEmpty (Join (Down a)) -> Join (Down a)

stimes :: Integral b => b -> Join (Down a) -> Join (Down a)

Monoid a => Monoid (Down a)

Since: base-4.11.0.0

Defined in Data.Ord

Methods

mempty :: Down a

mappend :: Down a -> Down a -> Down a

mconcat :: [Down a] -> Down a

Monoid (Join a) => Monoid (Meet (Down a))

Defined in Data.Semigroup.Join

Methods

mempty :: Meet (Down a)

mappend :: Meet (Down a) -> Meet (Down a) -> Meet (Down a)

mconcat :: [Meet (Down a)] -> Meet (Down a)

Monoid (Meet a) => Monoid (Join (Down a))

Defined in Data.Semigroup.Join

Methods

mempty :: Join (Down a)

mappend :: Join (Down a) -> Join (Down a) -> Join (Down a)

mconcat :: [Join (Down a)] -> Join (Down a)

Prd a => Prd (Down a)

Defined in Data.Prd

Methods

(<~) :: Down a -> Down a -> Bool

(>~) :: Down a -> Down a -> Bool

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

(>) :: Down a -> Down a -> Bool

(?~) :: Down a -> Down a -> Bool

(~~) :: Down a -> Down a -> Bool

(/~) :: Down a -> Down a -> Bool

pmax :: Down a -> Down a -> Maybe (Down a)

pmin :: Down a -> Down a -> Maybe (Down a)

similar :: Down a -> Down a -> Bool

pcompare :: Down a -> Down a -> Maybe Ordering

Distributive a => Distributive (Down a)

Defined in Data.Lattice

Methods

glb :: Down a -> Down a -> Down a -> Down a

lub :: Down a -> Down a -> Down a -> Down a

Bounded a => Bounded (Down a)

Defined in Data.Lattice

Methods

reduce :: (Foldable f, Functor f) => f (f (Down a)) -> Down a

Lattice a => Lattice (Down a)

Defined in Data.Lattice

Methods

reduce1 :: (Foldable1 f, Functor f) => f (f (Down a)) -> Down a

Quantale (Join a) => Quantale (Meet (Down a))

Defined in Data.Connection.Quantale

Methods

residl :: Meet (Down a) -> Conn (Meet (Down a)) (Meet (Down a))

residr :: Meet (Down a) -> Conn (Meet (Down a)) (Meet (Down a))

(//) :: Meet (Down a) -> Meet (Down a) -> Meet (Down a)

(\\) :: Meet (Down a) -> Meet (Down a) -> Meet (Down a)

Quantale (Meet a) => Quantale (Join (Down a))

Defined in Data.Connection.Quantale

Methods

residl :: Join (Down a) -> Conn (Join (Down a)) (Join (Down a))

residr :: Join (Down a) -> Conn (Join (Down a)) (Join (Down a))

(//) :: Join (Down a) -> Join (Down a) -> Join (Down a)

(\\) :: Join (Down a) -> Join (Down a) -> Join (Down a)

Generic1 Down

Defined in GHC.Generics

Associated Types

type Rep1 Down :: k -> Type

Methods

from1 :: Down a -> Rep1 Down a

to1 :: Rep1 Down a -> Down a

Connection a b => Connection (Down b) (Down a)

Defined in Data.Connection

Methods

connection :: Conn (Down b) (Down a)

type Rep (Down a)

Since: base-4.12.0.0

Defined in GHC.Generics

type Rep (Down a) = D1 (MetaData "Down" "Data.Ord" "base" True) (C1 (MetaCons "Down" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 Down

Since: base-4.12.0.0

Defined in GHC.Generics

type Rep1 Down = D1 (MetaData "Down" "Data.Ord" "base" True) (C1 (MetaCons "Down" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))