Numeric.MixedTypes.Bool

Documentation

type IsBool t = (HasBools t, CanNegSameType t, CanAndOrSameType t)

A type constraint synonym that stipulates that the type behaves very much like Bool, except it does not necessarily satisfy the law of excluded middle, which means that the type can contain a "do-not-know" value.

Examples: Bool, Maybe Bool, Maybe (Maybe Bool)

specIsBool :: (IsBool t, CanTestCertainly t, Show t, Serial IO t) => T t -> Spec

HSpec properties that each implementation of IsBool should satisfy.

Conversion to/from Bool

type HasBools t = ConvertibleExactly Bool t

class HasBools t => CanTestCertainly t where

Tests for truth or falsity. Beware, when isCertainlyTrue returns False, it does not mean that the proposition is false. It usually means that we failed to prove the proposition.

Minimal complete definition

isCertainlyTrue, isCertainlyFalse

Methods

isCertainlyTrue :: t -> Bool

isCertainlyFalse :: t -> Bool

Instances

CanTestCertainly Bool

Methods

isCertainlyTrue :: Bool -> Bool

isCertainlyFalse :: Bool -> Bool

CanTestCertainly t => CanTestCertainly (Maybe t)

Methods

isCertainlyTrue :: Maybe t -> Bool

isCertainlyFalse :: Maybe t -> Bool

specCanTestCertainly :: CanTestCertainly t => T t -> Spec

HSpec properties that each implementation of CanTestCertainly should satisfy.

type CanTestCertainlyX t = (CanTestCertainly t, Show t, Serial IO t)

Compound type constraint useful for test definition.

isNotTrue :: CanTestCertainly t => t -> Bool

isNotFalse :: CanTestCertainly t => t -> Bool

stronglyImplies :: (CanTestCertainly t1, CanTestCertainly t2) => t1 -> t2 -> Bool

If l is certainly True, then r is also certainly True.

stronglyEquivalentTo :: (CanTestCertainly t1, CanTestCertainly t2) => t1 -> t2 -> Bool

weaklyImplies :: (CanTestCertainly t1, CanTestCertainly t2) => t1 -> t2 -> Bool

If l is certainly True, then r is not certainly False.

weaklyEquivalentTo :: (CanTestCertainly t1, CanTestCertainly t2) => t1 -> t2 -> Bool

Negation

class CanNeg t where

This is negation is both the numeric negation as well as the Boolean negation. Example of non-standard Boolean negation:

 negate (Just True) = Just False
 

Minimal complete definition

negate

Associated Types

type NegType t

Methods

negate :: t -> NegType t

Instances

CanNeg Bool

Associated Types

type NegType Bool :: *

Methods

negate :: Bool -> NegType Bool

CanNeg t => CanNeg (Maybe t)

Associated Types

type NegType (Maybe t) :: *

Methods

negate :: Maybe t -> NegType (Maybe t)

not :: CanNeg t => t -> NegType t

A synonym of negate.

type CanNegSameType t = (CanNeg t, NegType t ~ t)

Tests

specCanNegBool :: (CanNegBoolX t, CanNegBoolX (NegType t)) => T t -> Spec

HSpec properties that each Boolean implementation of CanNeg should satisfy.

type CanNegBoolX t = (CanNeg t, CanTestCertainlyX t, CanTestCertainlyX (NegType t))

Compound type constraint useful for test definition.

And and or

type CanAndOr t1 t2 = (CanAndOrAsymmetric t1 t2, CanAndOrAsymmetric t2 t1, AndOrType t1 t2 ~ AndOrType t2 t1)

class CanAndOrAsymmetric t1 t2 where

Binary logical and and or for generalised Booleans. For example:

 (Just True) && False = Just False
 (Just (Just True)) || False = (Just (Just True))
 

Minimal complete definition

and2, or2

Associated Types

type AndOrType t1 t2

Methods

and2 :: t1 -> t2 -> AndOrType t1 t2

or2 :: t1 -> t2 -> AndOrType t1 t2

Instances

CanAndOrAsymmetric Bool Bool

Associated Types

type AndOrType Bool Bool :: *

Methods

and2 :: Bool -> Bool -> AndOrType Bool Bool

or2 :: Bool -> Bool -> AndOrType Bool Bool

(CanAndOrAsymmetric Bool t2, CanTestCertainly t2, CanTestCertainly (AndOrType Bool t2)) => CanAndOrAsymmetric Bool (Maybe t2)

Associated Types

type AndOrType Bool (Maybe t2) :: *

Methods

and2 :: Bool -> Maybe t2 -> AndOrType Bool (Maybe t2)

or2 :: Bool -> Maybe t2 -> AndOrType Bool (Maybe t2)

(CanAndOrAsymmetric t1 Bool, CanTestCertainly t1, CanTestCertainly (AndOrType t1 Bool)) => CanAndOrAsymmetric (Maybe t1) Bool

Associated Types

type AndOrType (Maybe t1) Bool :: *

Methods

and2 :: Maybe t1 -> Bool -> AndOrType (Maybe t1) Bool

or2 :: Maybe t1 -> Bool -> AndOrType (Maybe t1) Bool

(CanAndOrAsymmetric t1 t2, CanTestCertainly t1, CanTestCertainly t2, CanTestCertainly (AndOrType t1 t2)) => CanAndOrAsymmetric (Maybe t1) (Maybe t2)

Associated Types

type AndOrType (Maybe t1) (Maybe t2) :: *

Methods

and2 :: Maybe t1 -> Maybe t2 -> AndOrType (Maybe t1) (Maybe t2)

or2 :: Maybe t1 -> Maybe t2 -> AndOrType (Maybe t1) (Maybe t2)

(&&) :: CanAndOrAsymmetric a b => a -> b -> AndOrType a b infixr 3

A synonym of and2.

(||) :: CanAndOrAsymmetric a b => a -> b -> AndOrType a b infixr 2

A synonym of or2.

type CanAndOrWith t1 t2 = (CanAndOr t1 t2, AndOrType t1 t2 ~ t1)

type CanAndOrSameType t = CanAndOrWith t t

and :: (CanAndOrSameType t, CanTestCertainly t) => [t] -> t

or :: (CanAndOrSameType t, CanTestCertainly t) => [t] -> t

Tests

specCanAndOr :: (CanAndOrX t1 t1, CanAndOrX t1 t2, CanAndOrX t2 t1, CanAndOrX t1 t3, CanAndOrX t2 t3, CanAndOrX (AndOrType t1 t2) t3, CanAndOrX t1 (AndOrType t2 t3), CanAndOrX (AndOrType t1 t2) (AndOrType t1 t3)) => T t1 -> T t2 -> T t3 -> Spec

HSpec properties that each implementation of CanAndOr should satisfy.

specCanAndOrNotMixed :: (CanAndOrX t t, CanAndOrX (AndOrType t t) t, CanAndOrX t (AndOrType t t), CanAndOrX (AndOrType t t) (AndOrType t t)) => T t -> Spec

HSpec properties that each implementation of CanAndOr should satisfy.

type CanAndOrX t1 t2 = (CanAndOr t1 t2, CanNeg t1, CanNeg t2, CanAndOr (NegType t1) t2, CanAndOr t1 (NegType t2), CanAndOr (NegType t1) (NegType t2), CanTestCertainlyX t1, CanTestCertainlyX t2, CanTestCertainlyX (AndOrType t1 t2), CanTestCertainlyX (NegType (AndOrType t1 t2)), CanTestCertainlyX (AndOrType (NegType t1) t2), CanTestCertainlyX (AndOrType t1 (NegType t2)), CanTestCertainlyX (AndOrType (NegType t1) (NegType t2)))

Compound type constraint useful for test definition.

Orphan instances

ConvertibleExactly Bool Bool

Methods

safeConvertExactly :: Bool -> ConvertResult Bool

ConvertibleExactly Bool t => ConvertibleExactly Bool (Maybe t)

Methods

safeConvertExactly :: Bool -> ConvertResult (Maybe t)