Ersatz.Orderable

Documentation

class Equatable t => Orderable t where

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

Methods

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

Compare for less-than within the SAT problem.

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

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

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

Compare for less-than 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 Bit

Defined in Ersatz.Orderable

Methods

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

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

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

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

Orderable Bits

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit8

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit7

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit6

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit5

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit4

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit3

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit2

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable Bit1

Defined in Ersatz.Bits

Methods

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

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

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

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

Orderable BitChar

Defined in Ersatz.BitChar

Methods

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

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

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

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

(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

Minimal complete definition

(<?#), (<=?#)

Methods

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

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

Instances

GOrderable (V1 :: * -> *)

Defined in Ersatz.Orderable

Methods

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

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

GOrderable (U1 :: * -> *)

Defined in Ersatz.Orderable

Methods

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

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

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

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

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