Ersatz.Equatable

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