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

Description

 

Synopsis

Documentation

class Equatable t where #

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

Methods

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

Compare for equality within the SAT problem.

(===) :: (Generic t, GEquatable (Rep t)) => t -> t -> Bit infix 4 #

Compare for equality within the SAT problem.

(/==) :: t -> t -> Bit infix 4 #

Compare for inequality within the SAT problem.

Instances

Equatable Bit # 

Methods

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

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

Equatable Bits # 

Methods

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

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

Equatable Bit8 # 

Methods

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

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

Equatable Bit7 # 

Methods

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

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

Equatable Bit6 # 

Methods

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

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

Equatable Bit5 # 

Methods

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

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

Equatable Bit4 # 

Methods

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

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

Equatable Bit3 # 

Methods

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

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

Equatable Bit2 # 

Methods

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

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

Equatable Bit1 # 

Methods

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

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

Equatable BitChar # 

Methods

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

(/==) :: BitChar -> BitChar -> Bit #

Equatable a => Equatable [a] # 

Methods

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

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

Equatable a => Equatable (Maybe a) # 

Methods

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

(/==) :: Maybe a -> Maybe a -> Bit #

Equatable v => Equatable (IntMap v) # 

Methods

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

(/==) :: IntMap v -> IntMap v -> Bit #

(Equatable a, Equatable b) => Equatable (Either a b) # 

Methods

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

(/==) :: Either a b -> Either a b -> Bit #

(Equatable a, Equatable b) => Equatable (a, b) # 

Methods

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

(/==) :: (a, b) -> (a, b) -> Bit #

(Eq k, Equatable v) => Equatable (Map k v) # 

Methods

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

(/==) :: Map k v -> Map k v -> Bit #

(Equatable a, Equatable b, Equatable c) => Equatable (a, b, c) # 

Methods

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

(/==) :: (a, b, c) -> (a, b, c) -> Bit #

(Equatable a, Equatable b, Equatable c, Equatable d) => Equatable (a, b, c, d) # 

Methods

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

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

(Equatable a, Equatable b, Equatable c, Equatable d, Equatable e) => Equatable (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 #

(Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f) => Equatable (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 #

(Equatable a, Equatable b, Equatable c, Equatable d, Equatable e, Equatable f, Equatable g) => Equatable (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 #

class GEquatable f where #

Minimal complete definition

(===#)

Methods

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

Instances

GEquatable V1 # 

Methods

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

GEquatable U1 # 

Methods

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

Equatable a => GEquatable (K1 i a) # 

Methods

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

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

Methods

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

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

Methods

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

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

Methods

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