Safe Haskell | None |
---|

- class Boolean b where
- true :: b
- false :: b
- not :: b -> b
- (&&) :: b -> b -> b
- (||) :: b -> b -> b
- xor :: b -> b -> b
- (-->) :: b -> b -> b
- (<-->) :: b -> b -> b
- and :: Foldable t => t b -> b
- or :: Foldable t => t b -> b
- nand :: Foldable t => t b -> b
- all :: Foldable t => (a -> b) -> t a -> b
- any :: Foldable t => (a -> b) -> t a -> b
- nor :: Foldable t => t b -> b

- fromBool :: Boolean b => Bool -> b
- newtype Bitwise a = Bitwise {
- getBits :: a

# Documentation

A class for boolean algebras. Instances of this class are expected to obey all the laws of boolean algebra.

Minimal complete definition: `true`

or `false`

, `not`

or `<-->`

, `||`

or `&&`

.

Truth value, defined as the top of the bounded lattice

False value, defined as the bottom of the bounded lattice.

Logical negation.

Logical conjunction. (infxr 3)

Logical inclusive disjunction. (infixr 2)

Logical exclusive disjunction. (infixr 1)

Logical implication. (infixr 1)

Logical biconditional. (infixr 1)

and :: Foldable t => t b -> bSource

The logical conjunction of several values.

or :: Foldable t => t b -> bSource

The logical disjunction of several values.

nand :: Foldable t => t b -> bSource

all :: Foldable t => (a -> b) -> t a -> bSource

The logical conjunction of the mapping of a function over several values.

any :: Foldable t => (a -> b) -> t a -> bSource

The logical disjunction of the mapping of a function over several values.

A newtype wrapper that derives a `Boolean`

instance from any type that is both
a `Bits`

instance and a `Num`

instance,
such that boolean logic operations on the `Bitwise`

wrapper correspond to
bitwise logic operations on the inner type. It should be noted that `false`

is
defined as `Bitwise`

0 and `true`

is defined as `not`

`false`

.

In addition, a number of other classes are automatically derived from the inner
type. These classes were chosen on the basis that many other `Bits`

instances defined in base are also instances of these classes.

Typeable1 Bitwise | |

Bounded a => Bounded (Bitwise a) | |

Enum a => Enum (Bitwise a) | |

Eq a => Eq (Bitwise a) | |

Integral a => Integral (Bitwise a) | |

Data a => Data (Bitwise a) | |

Num a => Num (Bitwise a) | |

Ord a => Ord (Bitwise a) | |

Read a => Read (Bitwise a) | |

Real a => Real (Bitwise a) | |

Show a => Show (Bitwise a) | |

Ix a => Ix (Bitwise a) | |

PrintfArg a => PrintfArg (Bitwise a) | |

Storable a => Storable (Bitwise a) | |

Bits a => Bits (Bitwise a) | |

(Num a, Bits a) => Boolean (Bitwise a) |