Ersatz.Orderable

Documentation

class Equatable t => Orderable t where

Instances for this class for arbitrary types can be automatically derived from Generic.

Minimal complete definition

Nothing

Methods

(<?) :: t -> t -> Bit infix 4

Compare for less-than within the SAT problem.

default (<?) :: (Generic t, GOrderable (Rep t)) => t -> t -> Bit

(<=?) :: t -> t -> Bit infix 4

Compare for less-than or equal-to within the SAT problem.

(>=?) :: t -> t -> Bit infix 4

Compare for greater-than or equal-to within the SAT problem.

(>?) :: t -> t -> Bit infix 4

Compare for greater-than within the SAT problem.

Instances

Orderable Void

Defined in Ersatz.Orderable

Methods

(<?) :: Void -> Void -> Bit

(<=?) :: Void -> Void -> Bit

(>=?) :: Void -> Void -> Bit

(>?) :: Void -> Void -> Bit

Orderable Int16

Defined in Ersatz.Orderable

Methods

(<?) :: Int16 -> Int16 -> Bit

(<=?) :: Int16 -> Int16 -> Bit

(>=?) :: Int16 -> Int16 -> Bit

(>?) :: Int16 -> Int16 -> Bit

Orderable Int32

Defined in Ersatz.Orderable

Methods

(<?) :: Int32 -> Int32 -> Bit

(<=?) :: Int32 -> Int32 -> Bit

(>=?) :: Int32 -> Int32 -> Bit

(>?) :: Int32 -> Int32 -> Bit

Orderable Int64

Defined in Ersatz.Orderable

Methods

(<?) :: Int64 -> Int64 -> Bit

(<=?) :: Int64 -> Int64 -> Bit

(>=?) :: Int64 -> Int64 -> Bit

(>?) :: Int64 -> Int64 -> Bit

Orderable Int8

Defined in Ersatz.Orderable

Methods

(<?) :: Int8 -> Int8 -> Bit

(<=?) :: Int8 -> Int8 -> Bit

(>=?) :: Int8 -> Int8 -> Bit

(>?) :: Int8 -> Int8 -> Bit

Orderable Word16

Defined in Ersatz.Orderable

Methods

(<?) :: Word16 -> Word16 -> Bit

(<=?) :: Word16 -> Word16 -> Bit

(>=?) :: Word16 -> Word16 -> Bit

(>?) :: Word16 -> Word16 -> Bit

Orderable Word32

Defined in Ersatz.Orderable

Methods

(<?) :: Word32 -> Word32 -> Bit

(<=?) :: Word32 -> Word32 -> Bit

(>=?) :: Word32 -> Word32 -> Bit

(>?) :: Word32 -> Word32 -> Bit

Orderable Word64

Defined in Ersatz.Orderable

Methods

(<?) :: Word64 -> Word64 -> Bit

(<=?) :: Word64 -> Word64 -> Bit

(>=?) :: Word64 -> Word64 -> Bit

(>?) :: Word64 -> Word64 -> Bit

Orderable Word8

Defined in Ersatz.Orderable

Methods

(<?) :: Word8 -> Word8 -> Bit

(<=?) :: Word8 -> Word8 -> Bit

(>=?) :: Word8 -> Word8 -> Bit

(>?) :: Word8 -> Word8 -> Bit

Orderable Bit

Defined in Ersatz.Orderable

Methods

(<?) :: Bit -> Bit -> Bit

(<=?) :: Bit -> Bit -> Bit

(>=?) :: Bit -> Bit -> Bit

(>?) :: Bit -> Bit -> Bit

Orderable BitChar

Defined in Ersatz.BitChar

Methods

(<?) :: BitChar -> BitChar -> Bit

(<=?) :: BitChar -> BitChar -> Bit

(>=?) :: BitChar -> BitChar -> Bit

(>?) :: BitChar -> BitChar -> Bit

Orderable Bit1

Defined in Ersatz.Bits

Methods

(<?) :: Bit1 -> Bit1 -> Bit

(<=?) :: Bit1 -> Bit1 -> Bit

(>=?) :: Bit1 -> Bit1 -> Bit

(>?) :: Bit1 -> Bit1 -> Bit

Orderable Bit2

Defined in Ersatz.Bits

Methods

(<?) :: Bit2 -> Bit2 -> Bit

(<=?) :: Bit2 -> Bit2 -> Bit

(>=?) :: Bit2 -> Bit2 -> Bit

(>?) :: Bit2 -> Bit2 -> Bit

Orderable Bit3

Defined in Ersatz.Bits

Methods

(<?) :: Bit3 -> Bit3 -> Bit

(<=?) :: Bit3 -> Bit3 -> Bit

(>=?) :: Bit3 -> Bit3 -> Bit

(>?) :: Bit3 -> Bit3 -> Bit

Orderable Bit4

Defined in Ersatz.Bits

Methods

(<?) :: Bit4 -> Bit4 -> Bit

(<=?) :: Bit4 -> Bit4 -> Bit

(>=?) :: Bit4 -> Bit4 -> Bit

(>?) :: Bit4 -> Bit4 -> Bit

Orderable Bit5

Defined in Ersatz.Bits

Methods

(<?) :: Bit5 -> Bit5 -> Bit

(<=?) :: Bit5 -> Bit5 -> Bit

(>=?) :: Bit5 -> Bit5 -> Bit

(>?) :: Bit5 -> Bit5 -> Bit

Orderable Bit6

Defined in Ersatz.Bits

Methods

(<?) :: Bit6 -> Bit6 -> Bit

(<=?) :: Bit6 -> Bit6 -> Bit

(>=?) :: Bit6 -> Bit6 -> Bit

(>?) :: Bit6 -> Bit6 -> Bit

Orderable Bit7

Defined in Ersatz.Bits

Methods

(<?) :: Bit7 -> Bit7 -> Bit

(<=?) :: Bit7 -> Bit7 -> Bit

(>=?) :: Bit7 -> Bit7 -> Bit

(>?) :: Bit7 -> Bit7 -> Bit

Orderable Bit8

Defined in Ersatz.Bits

Methods

(<?) :: Bit8 -> Bit8 -> Bit

(<=?) :: Bit8 -> Bit8 -> Bit

(>=?) :: Bit8 -> Bit8 -> Bit

(>?) :: Bit8 -> Bit8 -> Bit

Orderable Bits

Defined in Ersatz.Bits

Methods

(<?) :: Bits -> Bits -> Bit

(<=?) :: Bits -> Bits -> Bit

(>=?) :: Bits -> Bits -> Bit

(>?) :: Bits -> Bits -> Bit

Orderable Ordering

Defined in Ersatz.Orderable

Methods

(<?) :: Ordering -> Ordering -> Bit

(<=?) :: Ordering -> Ordering -> Bit

(>=?) :: Ordering -> Ordering -> Bit

(>?) :: Ordering -> Ordering -> Bit

Orderable Integer

Defined in Ersatz.Orderable

Methods

(<?) :: Integer -> Integer -> Bit

(<=?) :: Integer -> Integer -> Bit

(>=?) :: Integer -> Integer -> Bit

(>?) :: Integer -> Integer -> Bit

Orderable Natural

Defined in Ersatz.Orderable

Methods

(<?) :: Natural -> Natural -> Bit

(<=?) :: Natural -> Natural -> Bit

(>=?) :: Natural -> Natural -> Bit

(>?) :: Natural -> Natural -> Bit

Orderable ()

Defined in Ersatz.Orderable

Methods

(<?) :: () -> () -> Bit

(<=?) :: () -> () -> Bit

(>=?) :: () -> () -> Bit

(>?) :: () -> () -> Bit

Orderable Bool

Defined in Ersatz.Orderable

Methods

(<?) :: Bool -> Bool -> Bit

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

(>=?) :: Bool -> Bool -> Bit

(>?) :: Bool -> Bool -> Bit

Orderable Char

Defined in Ersatz.Orderable

Methods

(<?) :: Char -> Char -> Bit

(<=?) :: Char -> Char -> Bit

(>=?) :: Char -> Char -> Bit

(>?) :: Char -> Char -> Bit

Orderable Double

Defined in Ersatz.Orderable

Methods

(<?) :: Double -> Double -> Bit

(<=?) :: Double -> Double -> Bit

(>=?) :: Double -> Double -> Bit

(>?) :: Double -> Double -> Bit

Orderable Float

Defined in Ersatz.Orderable

Methods

(<?) :: Float -> Float -> Bit

(<=?) :: Float -> Float -> Bit

(>=?) :: Float -> Float -> Bit

(>?) :: Float -> Float -> Bit

Orderable Int

Defined in Ersatz.Orderable

Methods

(<?) :: Int -> Int -> Bit

(<=?) :: Int -> Int -> Bit

(>=?) :: Int -> Int -> Bit

(>?) :: Int -> Int -> Bit

Orderable Word

Defined in Ersatz.Orderable

Methods

(<?) :: Word -> Word -> Bit

(<=?) :: Word -> Word -> Bit

(>=?) :: Word -> Word -> Bit

(>?) :: Word -> Word -> Bit

Orderable v => Orderable (IntMap v)

Compare by lexicographic order on sorted key-value pairs

Defined in Ersatz.Orderable

Methods

(<?) :: IntMap v -> IntMap v -> Bit

(<=?) :: IntMap v -> IntMap v -> Bit

(>=?) :: IntMap v -> IntMap v -> Bit

(>?) :: IntMap v -> IntMap v -> Bit

Orderable v => Orderable (Seq v)

Compare by lexicographic order on elements

Defined in Ersatz.Orderable

Methods

(<?) :: Seq v -> Seq v -> Bit

(<=?) :: Seq v -> Seq v -> Bit

(>=?) :: Seq v -> Seq v -> Bit

(>?) :: Seq v -> Seq v -> Bit

Orderable a => Orderable (Tree a)

Compare by lexicographic order on: root node, list of children

Defined in Ersatz.Orderable

Methods

(<?) :: Tree a -> Tree a -> Bit

(<=?) :: Tree a -> Tree a -> Bit

(>=?) :: Tree a -> Tree a -> Bit

(>?) :: Tree a -> Tree a -> Bit

Orderable a => Orderable (Maybe a)

Defined in Ersatz.Orderable

Methods

(<?) :: Maybe a -> Maybe a -> Bit

(<=?) :: Maybe a -> Maybe a -> Bit

(>=?) :: Maybe a -> Maybe a -> Bit

(>?) :: Maybe a -> Maybe a -> Bit

Orderable a => Orderable [a]

Lexicographic order

Defined in Ersatz.Orderable

Methods

(<?) :: [a] -> [a] -> Bit

(<=?) :: [a] -> [a] -> Bit

(>=?) :: [a] -> [a] -> Bit

(>?) :: [a] -> [a] -> Bit

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

Defined in Ersatz.Orderable

Methods

(<?) :: Either a b -> Either a b -> Bit

(<=?) :: Either a b -> Either a b -> Bit

(>=?) :: Either a b -> Either a b -> Bit

(>?) :: Either a b -> Either a b -> Bit

(Ord k, Orderable v) => Orderable (Map k v)

Compare by lexicographic order on sorted key-value pairs

Defined in Ersatz.Orderable

Methods

(<?) :: Map k v -> Map k v -> Bit

(<=?) :: Map k v -> Map k v -> Bit

(>=?) :: Map k v -> Map k v -> Bit

(>?) :: Map k v -> Map k v -> Bit

(Orderable a, Orderable b) => Orderable (a, b)

Defined in Ersatz.Orderable

Methods

(<?) :: (a, b) -> (a, b) -> Bit

(<=?) :: (a, b) -> (a, b) -> Bit

(>=?) :: (a, b) -> (a, b) -> Bit

(>?) :: (a, b) -> (a, b) -> Bit

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

Defined in Ersatz.Orderable

Methods

(<?) :: (a, b, c) -> (a, b, c) -> Bit

(<=?) :: (a, b, c) -> (a, b, c) -> Bit

(>=?) :: (a, b, c) -> (a, b, c) -> Bit

(>?) :: (a, b, c) -> (a, b, c) -> Bit

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

Defined in Ersatz.Orderable

Methods

(<?) :: (a, b, c, d) -> (a, b, c, d) -> Bit

(<=?) :: (a, b, c, d) -> (a, b, c, d) -> Bit

(>=?) :: (a, b, c, d) -> (a, b, c, d) -> Bit

(>?) :: (a, b, c, d) -> (a, b, c, d) -> Bit

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

Defined in Ersatz.Orderable

Methods

(<?) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bit

(<=?) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bit

(>=?) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bit

(>?) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bit

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

Defined in Ersatz.Orderable

Methods

(<?) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bit

(<=?) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bit

(>=?) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bit

(>?) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bit

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

Defined in Ersatz.Orderable

Methods

(<?) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bit

(<=?) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bit

(>=?) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bit

(>?) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bit

class GEquatable f => GOrderable f where

Methods

(<?#) :: f a -> f a -> Bit

(<=?#) :: f a -> f a -> Bit

Instances

GOrderable (U1 :: Type -> Type)

Defined in Ersatz.Orderable

Methods

(<?#) :: U1 a -> U1 a -> Bit

(<=?#) :: U1 a -> U1 a -> Bit

GOrderable (V1 :: Type -> Type)

Defined in Ersatz.Orderable

Methods

(<?#) :: V1 a -> V1 a -> Bit

(<=?#) :: V1 a -> V1 a -> Bit

(GOrderable f, GOrderable g) => GOrderable (f :*: g)

Defined in Ersatz.Orderable

Methods

(<?#) :: (f :*: g) a -> (f :*: g) a -> Bit

(<=?#) :: (f :*: g) a -> (f :*: g) a -> Bit

(GOrderable f, GOrderable g) => GOrderable (f :+: g)

Defined in Ersatz.Orderable

Methods

(<?#) :: (f :+: g) a -> (f :+: g) a -> Bit

(<=?#) :: (f :+: g) a -> (f :+: g) a -> Bit

Orderable a => GOrderable (K1 i a :: Type -> Type)

Defined in Ersatz.Orderable

Methods

(<?#) :: K1 i a a0 -> K1 i a a0 -> Bit

(<=?#) :: K1 i a a0 -> K1 i a a0 -> Bit

GOrderable f => GOrderable (M1 i c f)

Defined in Ersatz.Orderable

Methods

(<?#) :: M1 i c f a -> M1 i c f a -> Bit

(<=?#) :: M1 i c f a -> M1 i c f a -> Bit