Data.Algebra.Boolean.Negable

Documentation

data Neg a

Free Negable.

Constructors

Pos a

Positive value

Neg a

Negative value

Instances

Functor Neg

Methods

fmap :: (a -> b) -> Neg a -> Neg b

(<$) :: a -> Neg b -> Neg a

CoBoolean1 Neg

Methods

toBooleanWith :: Boolean c => (a -> c) -> Neg a -> c

Eq a => Eq (Neg a)

Methods

(==) :: Neg a -> Neg a -> Bool

(/=) :: Neg a -> Neg a -> Bool

Ord a => Ord (Neg a)

Methods

compare :: Neg a -> Neg a -> Ordering

(<) :: Neg a -> Neg a -> Bool

(<=) :: Neg a -> Neg a -> Bool

(>) :: Neg a -> Neg a -> Bool

(>=) :: Neg a -> Neg a -> Bool

max :: Neg a -> Neg a -> Neg a

min :: Neg a -> Neg a -> Neg a

Read a => Read (Neg a)

Methods

readsPrec :: Int -> ReadS (Neg a)

readList :: ReadS [Neg a]

readPrec :: ReadPrec (Neg a)

readListPrec :: ReadPrec [Neg a]

Show a => Show (Neg a)

Methods

showsPrec :: Int -> Neg a -> ShowS

show :: Neg a -> String

showList :: [Neg a] -> ShowS

NFData a => NFData (Neg a)

Methods

rnf :: Neg a -> ()

CoBoolean (Neg a)

Methods

toBoolean :: Boolean b => Neg a -> b

Negable (Neg a)

Methods

not :: Neg a -> Neg a

class Negable x where

Class to represent invertible values.

Must obey the double negation law: not (not x) = x

The negation appears only in leafs of normal forms, and the underlying proposition class might have built-in negation, thus we use Negable.

Minimal complete definition

not

Methods

not :: x -> x

Invert the value.

Instances

Negable Bool

Methods

not :: Bool -> Bool

Monoid m => Negable (Maybe m)

Methods

not :: Maybe m -> Maybe m

Negable (Neg a)

Methods

not :: Neg a -> Neg a

Negable (FreeBoolean a)

Methods

not :: FreeBoolean a -> FreeBoolean a

(Ord a, Negable a) => Negable (NNF a)

Methods

not :: NNF a -> NNF a

Negable a => Negable (NNF a)

Methods

not :: NNF a -> NNF a

Negable a => Negable (DNF a)

Methods

not :: DNF a -> DNF a

(Ord a, Negable a) => Negable (DNF a)

Methods

not :: DNF a -> DNF a

(Ord a, Negable a) => Negable (CNF a)

Methods

not :: CNF a -> CNF a

Negable a => Negable (CNF a)

Methods

not :: CNF a -> CNF a

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

Methods

not :: Either a b -> Either a b

(Negable a, Negable b) => Negable (a, b)

Methods

not :: (a, b) -> (a, b)