Relation.Binary.Comparison

Documentation

class Preord a where

Minimal complete definition

(≥) | (≤)

Methods

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

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

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

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

Instances

Preord Bool

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Char

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Int

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Int8

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Int16

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Int32

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Int64

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Integer

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Natural

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Ordering

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Word

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Word8

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Word16

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Word32

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord Word64

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord ()

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord a => Preord (Maybe a)

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Preord (Sum Natural)

Defined in Relation.Binary.Comparison

Methods

(≤) :: Sum Natural -> Sum Natural -> Bool

(≥) :: Sum Natural -> Sum Natural -> Bool

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

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

Preord a => Preord (Down a)

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

Bits a => Preord (Min (BitSet a))

Defined in Data.BitSet

Methods

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

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

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

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

Bits a => Preord (Max (BitSet a))

Defined in Data.BitSet

Methods

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

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

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

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

Preord a => Preord (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

(Preord a, Preord b) => Preord (Lexical (Either a b))

Defined in Relation.Binary.Comparison

Methods

(≤) :: Lexical (Either a b) -> Lexical (Either a b) -> Bool

(≥) :: Lexical (Either a b) -> Lexical (Either a b) -> Bool

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

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

(PartialOrd a, PartialOrd b) => Preord (Lexical (a, b))

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

(PartialOrd a, PartialOrd b, PartialOrd c) => Preord (Lexical (a, b, c))

Defined in Relation.Binary.Comparison

Methods

(≤) :: Lexical (a, b, c) -> Lexical (a, b, c) -> Bool

(≥) :: Lexical (a, b, c) -> Lexical (a, b, c) -> Bool

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

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

Bits a => Preord (BitSet a)

Defined in Data.BitSet

Methods

(≤) :: BitSet a -> BitSet a -> Bool

(≥) :: BitSet a -> BitSet a -> Bool

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

(>) :: BitSet a -> BitSet a -> Bool

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

Defined in Relation.Binary.Comparison

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

(Preord a, Preord b) => Preord (a, b)

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

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

Defined in Relation.Binary.Comparison

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

class PartialEq a where

Minimal complete definition

(≡) | (≢)

Methods

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

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

Instances

PartialEq Bool

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Char

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Int

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Int8

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Int16

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Int32

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Int64

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Integer

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Natural

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Ordering

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Word

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Word8

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Word16

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Word32

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq Word64

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq ()

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq a => PartialEq [a]

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq a => PartialEq (Maybe a)

Defined in Relation.Binary.Comparison

Methods

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

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

PartialEq a => PartialEq (Ratio a)

Defined in Relation.Binary.Comparison

Methods

(≡) :: Ratio a -> Ratio a -> Bool

(≢) :: Ratio a -> Ratio a -> Bool

PartialEq (Sum Natural)

Defined in Relation.Binary.Comparison

Methods

(≡) :: Sum Natural -> Sum Natural -> Bool

(≢) :: Sum Natural -> Sum Natural -> Bool

PartialEq a => PartialEq (Down a)

Defined in Relation.Binary.Comparison

Methods

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

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

Bits a => PartialEq (Min (BitSet a))

Defined in Data.BitSet

Methods

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

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

Bits a => PartialEq (Max (BitSet a))

Defined in Data.BitSet

Methods

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

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

PartialEq a => PartialEq (Lexical a)

Defined in Relation.Binary.Comparison

Methods

(≡) :: Lexical a -> Lexical a -> Bool

(≢) :: Lexical a -> Lexical a -> Bool

Bits a => PartialEq (BitSet a)

Defined in Data.BitSet

Methods

(≡) :: BitSet a -> BitSet a -> Bool

(≢) :: BitSet a -> BitSet a -> Bool

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

Defined in Relation.Binary.Comparison

Methods

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

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

(PartialEq a, PartialEq b) => PartialEq (a, b)

Defined in Relation.Binary.Comparison

Methods

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

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

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

Defined in Relation.Binary.Comparison

Methods

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

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

class (Preord a, PartialEq a) => Eq a

Instances

Eq Bool

Defined in Relation.Binary.Comparison

Eq Char

Defined in Relation.Binary.Comparison

Eq Int

Defined in Relation.Binary.Comparison

Eq Int8

Defined in Relation.Binary.Comparison

Eq Int16

Defined in Relation.Binary.Comparison

Eq Int32

Defined in Relation.Binary.Comparison

Eq Int64

Defined in Relation.Binary.Comparison

Eq Integer

Defined in Relation.Binary.Comparison

Eq Natural

Defined in Relation.Binary.Comparison

Eq Ordering

Defined in Relation.Binary.Comparison

Eq Word

Defined in Relation.Binary.Comparison

Eq Word8

Defined in Relation.Binary.Comparison

Eq Word16

Defined in Relation.Binary.Comparison

Eq Word32

Defined in Relation.Binary.Comparison

Eq Word64

Defined in Relation.Binary.Comparison

Eq ()

Defined in Relation.Binary.Comparison

Eq a => Eq (Maybe a)

Defined in Relation.Binary.Comparison

Eq (Sum Natural)

Defined in Relation.Binary.Comparison

Eq a => Eq (Down a)

Defined in Relation.Binary.Comparison

Bits a => Eq (Min (BitSet a))

Defined in Data.BitSet

Bits a => Eq (Max (BitSet a))

Defined in Data.BitSet

Eq a => Eq (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

(Eq a, Eq b) => Eq (Lexical (Either a b))

Defined in Relation.Binary.Comparison

(PartialOrd a, PartialOrd b, Eq a, Eq b) => Eq (Lexical (a, b))

Defined in Relation.Binary.Comparison

(PartialOrd a, PartialOrd b, PartialOrd c, Eq a, Eq b, Eq c) => Eq (Lexical (a, b, c))

Defined in Relation.Binary.Comparison

Bits a => Eq (BitSet a)

Defined in Data.BitSet

class (Preord a, PartialEq a) => PartialOrd a where

Minimal complete definition

Nothing

Methods

tryCompare :: a -> a -> Maybe Ordering

Instances

PartialOrd Bool

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Bool -> Bool -> Maybe Ordering

PartialOrd Char

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Char -> Char -> Maybe Ordering

PartialOrd Int

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Int -> Int -> Maybe Ordering

PartialOrd Int8

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Int8 -> Int8 -> Maybe Ordering

PartialOrd Int16

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Int16 -> Int16 -> Maybe Ordering

PartialOrd Int32

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Int32 -> Int32 -> Maybe Ordering

PartialOrd Int64

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Int64 -> Int64 -> Maybe Ordering

PartialOrd Integer

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Integer -> Integer -> Maybe Ordering

PartialOrd Natural

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Natural -> Natural -> Maybe Ordering

PartialOrd Ordering

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Ordering -> Ordering -> Maybe Ordering

PartialOrd Word

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Word -> Word -> Maybe Ordering

PartialOrd Word8

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Word8 -> Word8 -> Maybe Ordering

PartialOrd Word16

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Word16 -> Word16 -> Maybe Ordering

PartialOrd Word32

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Word32 -> Word32 -> Maybe Ordering

PartialOrd Word64

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Word64 -> Word64 -> Maybe Ordering

PartialOrd ()

Defined in Relation.Binary.Comparison

Methods

tryCompare :: () -> () -> Maybe Ordering

PartialOrd a => PartialOrd (Maybe a)

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Maybe a -> Maybe a -> Maybe Ordering

PartialOrd (Sum Natural)

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Sum Natural -> Sum Natural -> Maybe Ordering

PartialOrd a => PartialOrd (Down a)

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Down a -> Down a -> Maybe Ordering

Bits a => PartialOrd (Min (BitSet a))

Defined in Data.BitSet

Methods

tryCompare :: Min (BitSet a) -> Min (BitSet a) -> Maybe Ordering

Bits a => PartialOrd (Max (BitSet a))

Defined in Data.BitSet

Methods

tryCompare :: Max (BitSet a) -> Max (BitSet a) -> Maybe Ordering

PartialOrd a => PartialOrd (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (Maybe a) -> Lexical (Maybe a) -> Maybe Ordering

(PartialOrd a, PartialOrd b) => PartialOrd (Lexical (Either a b))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (Either a b) -> Lexical (Either a b) -> Maybe Ordering

(PartialOrd a, PartialOrd b) => PartialOrd (Lexical (a, b))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (a, b) -> Lexical (a, b) -> Maybe Ordering

(PartialOrd a, PartialOrd b, PartialOrd c) => PartialOrd (Lexical (a, b, c))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (a, b, c) -> Lexical (a, b, c) -> Maybe Ordering

Bits a => PartialOrd (BitSet a)

Defined in Data.BitSet

Methods

tryCompare :: BitSet a -> BitSet a -> Maybe Ordering

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

Defined in Relation.Binary.Comparison

Methods

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

(PartialOrd a, PartialOrd b) => PartialOrd (a, b)

Defined in Relation.Binary.Comparison

Methods

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

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

Defined in Relation.Binary.Comparison

Methods

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

class (PartialOrd a, Eq a) => Ord a where

Minimal complete definition

Nothing

Methods

compare :: a -> a -> Ordering

Instances

Ord Bool

Defined in Relation.Binary.Comparison

Methods

compare :: Bool -> Bool -> Ordering

Ord Char

Defined in Relation.Binary.Comparison

Methods

compare :: Char -> Char -> Ordering

Ord Int

Defined in Relation.Binary.Comparison

Methods

compare :: Int -> Int -> Ordering

Ord Int8

Defined in Relation.Binary.Comparison

Methods

compare :: Int8 -> Int8 -> Ordering

Ord Int16

Defined in Relation.Binary.Comparison

Methods

compare :: Int16 -> Int16 -> Ordering

Ord Int32

Defined in Relation.Binary.Comparison

Methods

compare :: Int32 -> Int32 -> Ordering

Ord Int64

Defined in Relation.Binary.Comparison

Methods

compare :: Int64 -> Int64 -> Ordering

Ord Integer

Defined in Relation.Binary.Comparison

Methods

compare :: Integer -> Integer -> Ordering

Ord Natural

Defined in Relation.Binary.Comparison

Methods

compare :: Natural -> Natural -> Ordering

Ord Ordering

Defined in Relation.Binary.Comparison

Methods

compare :: Ordering -> Ordering -> Ordering

Ord Word

Defined in Relation.Binary.Comparison

Methods

compare :: Word -> Word -> Ordering

Ord Word8

Defined in Relation.Binary.Comparison

Methods

compare :: Word8 -> Word8 -> Ordering

Ord Word16

Defined in Relation.Binary.Comparison

Methods

compare :: Word16 -> Word16 -> Ordering

Ord Word32

Defined in Relation.Binary.Comparison

Methods

compare :: Word32 -> Word32 -> Ordering

Ord Word64

Defined in Relation.Binary.Comparison

Methods

compare :: Word64 -> Word64 -> Ordering

Ord ()

Defined in Relation.Binary.Comparison

Methods

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

Ord (Sum Natural)

Defined in Relation.Binary.Comparison

Methods

compare :: Sum Natural -> Sum Natural -> Ordering

Ord a => Ord (Down a)

Defined in Relation.Binary.Comparison

Methods

compare :: Down a -> Down a -> Ordering

Ord a => Ord (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (Maybe a) -> Lexical (Maybe a) -> Ordering

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

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (Either a b) -> Lexical (Either a b) -> Ordering

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

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (a, b) -> Lexical (a, b) -> Ordering

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

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (a, b, c) -> Lexical (a, b, c) -> Ordering

newtype Lexical a

Constructors

Lexical a

Instances

Semigroup a => Semigroup (Lexical a)

Defined in Relation.Binary.Comparison

Methods

(<>) :: Lexical a -> Lexical a -> Lexical a

sconcat :: NonEmpty (Lexical a) -> Lexical a

stimes :: Integral b => b -> Lexical a -> Lexical a

Monoid a => Monoid (Lexical a)

Defined in Relation.Binary.Comparison

Methods

mempty :: Lexical a

mappend :: Lexical a -> Lexical a -> Lexical a

mconcat :: [Lexical a] -> Lexical a

Group a => Group (Lexical a)

Defined in Relation.Binary.Comparison

Methods

invert :: Lexical a -> Lexical a

Ord a => Ord (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (Maybe a) -> Lexical (Maybe a) -> Ordering

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

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (Either a b) -> Lexical (Either a b) -> Ordering

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

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (a, b) -> Lexical (a, b) -> Ordering

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

Defined in Relation.Binary.Comparison

Methods

compare :: Lexical (a, b, c) -> Lexical (a, b, c) -> Ordering

PartialOrd a => PartialOrd (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (Maybe a) -> Lexical (Maybe a) -> Maybe Ordering

(PartialOrd a, PartialOrd b) => PartialOrd (Lexical (Either a b))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (Either a b) -> Lexical (Either a b) -> Maybe Ordering

(PartialOrd a, PartialOrd b) => PartialOrd (Lexical (a, b))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (a, b) -> Lexical (a, b) -> Maybe Ordering

(PartialOrd a, PartialOrd b, PartialOrd c) => PartialOrd (Lexical (a, b, c))

Defined in Relation.Binary.Comparison

Methods

tryCompare :: Lexical (a, b, c) -> Lexical (a, b, c) -> Maybe Ordering

Eq a => Eq (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

(Eq a, Eq b) => Eq (Lexical (Either a b))

Defined in Relation.Binary.Comparison

(PartialOrd a, PartialOrd b, Eq a, Eq b) => Eq (Lexical (a, b))

Defined in Relation.Binary.Comparison

(PartialOrd a, PartialOrd b, PartialOrd c, Eq a, Eq b, Eq c) => Eq (Lexical (a, b, c))

Defined in Relation.Binary.Comparison

PartialEq a => PartialEq (Lexical a)

Defined in Relation.Binary.Comparison

Methods

(≡) :: Lexical a -> Lexical a -> Bool

(≢) :: Lexical a -> Lexical a -> Bool

Preord a => Preord (Lexical (Maybe a))

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

(Preord a, Preord b) => Preord (Lexical (Either a b))

Defined in Relation.Binary.Comparison

Methods

(≤) :: Lexical (Either a b) -> Lexical (Either a b) -> Bool

(≥) :: Lexical (Either a b) -> Lexical (Either a b) -> Bool

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

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

(PartialOrd a, PartialOrd b) => Preord (Lexical (a, b))

Defined in Relation.Binary.Comparison

Methods

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

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

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

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

(PartialOrd a, PartialOrd b, PartialOrd c) => Preord (Lexical (a, b, c))

Defined in Relation.Binary.Comparison

Methods

(≤) :: Lexical (a, b, c) -> Lexical (a, b, c) -> Bool

(≥) :: Lexical (a, b, c) -> Lexical (a, b, c) -> Bool

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

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

class (Monoid a, Abelian a, PartialOrd a) => Monus a where

Methods

monus :: a -> a -> a

Instances

Monus (Sum Natural)

Defined in Relation.Binary.Comparison

Methods

monus :: Sum Natural -> Sum Natural -> Sum Natural

Bits a => Monus (Min (BitSet a))

Defined in Data.BitSet

Methods

monus :: Min (BitSet a) -> Min (BitSet a) -> Min (BitSet a)

Bits a => Monus (Max (BitSet a))

Defined in Data.BitSet

Methods

monus :: Max (BitSet a) -> Max (BitSet a) -> Max (BitSet a)

(∸) :: Monus (Sum a) => a -> a -> a

max :: Ord a => a -> a -> a

min :: Ord a => a -> a -> a

newtype Max a

Constructors

Max

Fields

• unMax :: a

Instances

Eq a => Eq (Max a)

Defined in Relation.Binary.Comparison

Methods

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

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

Read a => Read (Max a)

Defined in Relation.Binary.Comparison

Methods

readsPrec :: Int -> ReadS (Max a)

readList :: ReadS [Max a]

readPrec :: ReadPrec (Max a)

readListPrec :: ReadPrec [Max a]

Show a => Show (Max a)

Defined in Relation.Binary.Comparison

Methods

showsPrec :: Int -> Max a -> ShowS

show :: Max a -> String

showList :: [Max a] -> ShowS

Ord a => Semigroup (Max a)

Defined in Relation.Binary.Comparison

Methods

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

sconcat :: NonEmpty (Max a) -> Max a

stimes :: Integral b => b -> Max a -> Max a

Bits a => Semigroup (Max (BitSet a))

Defined in Data.BitSet

Methods

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

sconcat :: NonEmpty (Max (BitSet a)) -> Max (BitSet a)

stimes :: Integral b => b -> Max (BitSet a) -> Max (BitSet a)

Bits a => Monoid (Max (BitSet a))

Defined in Data.BitSet

Methods

mempty :: Max (BitSet a)

mappend :: Max (BitSet a) -> Max (BitSet a) -> Max (BitSet a)

mconcat :: [Max (BitSet a)] -> Max (BitSet a)

Bits a => Bits (Max a)

Defined in Relation.Binary.Comparison

Methods

(.&.) :: Max a -> Max a -> Max a

(.|.) :: Max a -> Max a -> Max a

xor :: Max a -> Max a -> Max a

complement :: Max a -> Max a

shift :: Max a -> Int -> Max a

rotate :: Max a -> Int -> Max a

zeroBits :: Max a

bit :: Int -> Max a

setBit :: Max a -> Int -> Max a

clearBit :: Max a -> Int -> Max a

complementBit :: Max a -> Int -> Max a

testBit :: Max a -> Int -> Bool

bitSizeMaybe :: Max a -> Maybe Int

bitSize :: Max a -> Int

isSigned :: Max a -> Bool

shiftL :: Max a -> Int -> Max a

unsafeShiftL :: Max a -> Int -> Max a

shiftR :: Max a -> Int -> Max a

unsafeShiftR :: Max a -> Int -> Max a

rotateL :: Max a -> Int -> Max a

rotateR :: Max a -> Int -> Max a

popCount :: Max a -> Int

FiniteBits a => FiniteBits (Max a)

Defined in Relation.Binary.Comparison

Methods

finiteBitSize :: Max a -> Int

countLeadingZeros :: Max a -> Int

countTrailingZeros :: Max a -> Int

Bits a => Idempotent (Max (BitSet a))

Defined in Data.BitSet

Bits a => Abelian (Max (BitSet a))

Defined in Data.BitSet

Bits a => Monus (Max (BitSet a))

Defined in Data.BitSet

Methods

monus :: Max (BitSet a) -> Max (BitSet a) -> Max (BitSet a)

Bits a => PartialOrd (Max (BitSet a))

Defined in Data.BitSet

Methods

tryCompare :: Max (BitSet a) -> Max (BitSet a) -> Maybe Ordering

Bits a => Eq (Max (BitSet a))

Defined in Data.BitSet

Bits a => PartialEq (Max (BitSet a))

Defined in Data.BitSet

Methods

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

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

Bits a => Preord (Max (BitSet a))

Defined in Data.BitSet

Methods

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

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

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

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

newtype Min a

Constructors

Min

Fields

• unMin :: a

Instances

Eq a => Eq (Min a)

Defined in Relation.Binary.Comparison

Methods

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

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

Read a => Read (Min a)

Defined in Relation.Binary.Comparison

Methods

readsPrec :: Int -> ReadS (Min a)

readList :: ReadS [Min a]

readPrec :: ReadPrec (Min a)

readListPrec :: ReadPrec [Min a]

Show a => Show (Min a)

Defined in Relation.Binary.Comparison

Methods

showsPrec :: Int -> Min a -> ShowS

show :: Min a -> String

showList :: [Min a] -> ShowS

Ord a => Semigroup (Min a)

Defined in Relation.Binary.Comparison

Methods

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

sconcat :: NonEmpty (Min a) -> Min a

stimes :: Integral b => b -> Min a -> Min a

Bits a => Semigroup (Min (BitSet a))

Defined in Data.BitSet

Methods

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

sconcat :: NonEmpty (Min (BitSet a)) -> Min (BitSet a)

stimes :: Integral b => b -> Min (BitSet a) -> Min (BitSet a)

Bits a => Monoid (Min (BitSet a))

Defined in Data.BitSet

Methods

mempty :: Min (BitSet a)

mappend :: Min (BitSet a) -> Min (BitSet a) -> Min (BitSet a)

mconcat :: [Min (BitSet a)] -> Min (BitSet a)

Bits a => Bits (Min a)

Defined in Relation.Binary.Comparison

Methods

(.&.) :: Min a -> Min a -> Min a

(.|.) :: Min a -> Min a -> Min a

xor :: Min a -> Min a -> Min a

complement :: Min a -> Min a

shift :: Min a -> Int -> Min a

rotate :: Min a -> Int -> Min a

zeroBits :: Min a

bit :: Int -> Min a

setBit :: Min a -> Int -> Min a

clearBit :: Min a -> Int -> Min a

complementBit :: Min a -> Int -> Min a

testBit :: Min a -> Int -> Bool

bitSizeMaybe :: Min a -> Maybe Int

bitSize :: Min a -> Int

isSigned :: Min a -> Bool

shiftL :: Min a -> Int -> Min a

unsafeShiftL :: Min a -> Int -> Min a

shiftR :: Min a -> Int -> Min a

unsafeShiftR :: Min a -> Int -> Min a

rotateL :: Min a -> Int -> Min a

rotateR :: Min a -> Int -> Min a

popCount :: Min a -> Int

FiniteBits a => FiniteBits (Min a)

Defined in Relation.Binary.Comparison

Methods

finiteBitSize :: Min a -> Int

countLeadingZeros :: Min a -> Int

countTrailingZeros :: Min a -> Int

Bits a => Idempotent (Min (BitSet a))

Defined in Data.BitSet

Bits a => Abelian (Min (BitSet a))

Defined in Data.BitSet

Bits a => Monus (Min (BitSet a))

Defined in Data.BitSet

Methods

monus :: Min (BitSet a) -> Min (BitSet a) -> Min (BitSet a)

Bits a => PartialOrd (Min (BitSet a))

Defined in Data.BitSet

Methods

tryCompare :: Min (BitSet a) -> Min (BitSet a) -> Maybe Ordering

Bits a => Eq (Min (BitSet a))

Defined in Data.BitSet

Bits a => PartialEq (Min (BitSet a))

Defined in Data.BitSet

Methods

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

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

Bits a => Preord (Min (BitSet a))

Defined in Data.BitSet

Methods

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

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

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

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