ersatz-0.4: A monad for expressing SAT or QSAT problems using observable sharing.

Copyright© Edward Kmett 2010-2014 Johan Kiviniemi 2013
LicenseBSD3
MaintainerEdward Kmett <ekmett@gmail.com>
Stabilityexperimental
Portabilitynon-portable
Safe HaskellSafe
LanguageHaskell2010

Ersatz.Orderable

Description

 

Synopsis

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 # 

Methods

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

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

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

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

Orderable Bits # 

Methods

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

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

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

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

Orderable Bit8 # 

Methods

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

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

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

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

Orderable Bit7 # 

Methods

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

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

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

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

Orderable Bit6 # 

Methods

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

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

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

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

Orderable Bit5 # 

Methods

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

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

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

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

Orderable Bit4 # 

Methods

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

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

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

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

Orderable Bit3 # 

Methods

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

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

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

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

Orderable Bit2 # 

Methods

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

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

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

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

Orderable Bit1 # 

Methods

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

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

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

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

Orderable BitChar # 
Orderable a => Orderable [a] #

Lexicographic order

Methods

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

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

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

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

Orderable a => Orderable (Maybe a) # 

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

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

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

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

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

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

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

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 # 

Methods

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

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

GOrderable U1 # 

Methods

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

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

Orderable a => GOrderable (K1 i a) # 

Methods

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

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

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

Methods

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

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

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

Methods

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

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

GOrderable f => GOrderable (M1 i c f) # 

Methods

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

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