Copyright	(c) Conal Elliott 2009-2012
License	BSD3
Maintainer	conal@conal.net
Stability	experimental
Safe Haskell	Safe
Language	Haskell98

Data.Boolean

Description

Some classes for generalized boolean operations.

In this design, for if-then-else, equality and inequality tests, the boolean type depends on the value type.

I also tried using a unary type constructor class. The class doesn't work for regular booleans, so generality is lost. Also, we'd probably have to wire class constraints in like: (==*) :: Eq a => f Bool -> f a -> f a -> f a, which disallows situations needing additional constraints, e.g., Show.

Starting with 0.1.0, this package uses type families. Up to version 0.0.2, it used MPTCs with functional dependencies. My thanks to Andy Gill for suggesting & helping with the change.

Synopsis

Documentation

class Boolean b where #

Generalized boolean class

Minimal complete definition

true, false, notB, (&&*), (||*)

Methods

true, false :: b #

notB :: b -> b #

(&&*), (||*) :: b -> b -> b infixr 3 &&*infixr 2 ||* #

Instances

Boolean Bool #
Methods true :: Bool # false :: Bool # notB :: Bool -> Bool # (&&) :: Bool -> Bool -> Bool # (\|\|) :: Bool -> Bool -> Bool #
Boolean bool => Boolean (z -> bool) #
Methods true :: z -> bool # false :: z -> bool # notB :: (z -> bool) -> z -> bool # (&&) :: (z -> bool) -> (z -> bool) -> z -> bool # (\|\|) :: (z -> bool) -> (z -> bool) -> z -> bool #

type family BooleanOf a #

BooleanOf computed the boolean analog of a specific type.

Instances

type BooleanOf Bool #
type BooleanOf Bool = Bool
type BooleanOf Char #
type BooleanOf Char = Bool
type BooleanOf Double #
type BooleanOf Double = Bool
type BooleanOf Float #
type BooleanOf Float = Bool
type BooleanOf Int #
type BooleanOf Int = Bool
type BooleanOf Integer #
type BooleanOf Integer = Bool
type BooleanOf [a] #
type BooleanOf [a] = BooleanOf a
type BooleanOf (z -> a) #
type BooleanOf (z -> a) = z -> BooleanOf a
type BooleanOf (a, b) #
type BooleanOf (a, b) = BooleanOf a
type BooleanOf (a, b, c) #
type BooleanOf (a, b, c) = BooleanOf a
type BooleanOf (a, b, c, d) #
type BooleanOf (a, b, c, d) = BooleanOf a

class Boolean (BooleanOf a) => IfB a where #

Types with conditionals

Minimal complete definition

ifB

Methods

ifB :: bool ~ BooleanOf a => bool -> a -> a -> a #

Instances

IfB Bool #
Methods ifB :: (* ~ bool) (BooleanOf Bool) => bool -> Bool -> Bool -> Bool #
IfB Char #
Methods ifB :: (* ~ bool) (BooleanOf Char) => bool -> Char -> Char -> Char #
IfB Double #
Methods ifB :: (* ~ bool) (BooleanOf Double) => bool -> Double -> Double -> Double #
IfB Float #
Methods ifB :: (* ~ bool) (BooleanOf Float) => bool -> Float -> Float -> Float #
IfB Int #
Methods ifB :: (* ~ bool) (BooleanOf Int) => bool -> Int -> Int -> Int #
IfB Integer #
Methods ifB :: (* ~ bool) (BooleanOf Integer) => bool -> Integer -> Integer -> Integer #
(Boolean (BooleanOf a), (~) * (BooleanOf a) Bool) => IfB [a] #
Methods ifB :: (* ~ bool) (BooleanOf [a]) => bool -> [a] -> [a] -> [a] #
IfB a => IfB (z -> a) #
Methods ifB :: (* ~ bool) (BooleanOf (z -> a)) => bool -> (z -> a) -> (z -> a) -> z -> a #
((~) * bool (BooleanOf p), (~) * bool (BooleanOf q), IfB p, IfB q) => IfB (p, q) #
Methods ifB :: (* ~ bool) (BooleanOf (p, q)) => bool -> (p, q) -> (p, q) -> (p, q) #
((~) * bool (BooleanOf p), (~) * bool (BooleanOf q), (~) * bool (BooleanOf r), IfB p, IfB q, IfB r) => IfB (p, q, r) #
Methods ifB :: (* ~ bool) (BooleanOf (p, q, r)) => bool -> (p, q, r) -> (p, q, r) -> (p, q, r) #
((~) * bool (BooleanOf p), (~) * bool (BooleanOf q), (~) * bool (BooleanOf r), (~) * bool (BooleanOf s), IfB p, IfB q, IfB r, IfB s) => IfB (p, q, r, s) #
Methods ifB :: (* ~ bool) (BooleanOf (p, q, r, s)) => bool -> (p, q, r, s) -> (p, q, r, s) -> (p, q, r, s) #

boolean :: (IfB a, bool ~ BooleanOf a) => a -> a -> bool -> a #

Expression-lifted conditional with condition last

cond :: (Applicative f, IfB a, bool ~ BooleanOf a) => f bool -> f a -> f a -> f a #

Point-wise conditional

crop :: (Applicative f, Monoid (f a), IfB a, bool ~ BooleanOf a) => f bool -> f a -> f a #

Generalized cropping, filling in mempty where the test yields false.

class Boolean (BooleanOf a) => EqB a where #

Types with equality. Minimum definition: '(==*)'.

Minimal complete definition

(==*)

Methods

(==*), (/=*) :: bool ~ BooleanOf a => a -> a -> bool infix 4 ==*, /=* #

Instances

EqB Bool #
Methods (==) :: ( ~ bool) (BooleanOf Bool) => Bool -> Bool -> bool # (/=) :: ( ~ bool) (BooleanOf Bool) => Bool -> Bool -> bool #
EqB Char #
Methods (==) :: ( ~ bool) (BooleanOf Char) => Char -> Char -> bool # (/=) :: ( ~ bool) (BooleanOf Char) => Char -> Char -> bool #
EqB Double #
Methods (==) :: ( ~ bool) (BooleanOf Double) => Double -> Double -> bool # (/=) :: ( ~ bool) (BooleanOf Double) => Double -> Double -> bool #
EqB Float #
Methods (==) :: ( ~ bool) (BooleanOf Float) => Float -> Float -> bool # (/=) :: ( ~ bool) (BooleanOf Float) => Float -> Float -> bool #
EqB Int #
Methods (==) :: ( ~ bool) (BooleanOf Int) => Int -> Int -> bool # (/=) :: ( ~ bool) (BooleanOf Int) => Int -> Int -> bool #
EqB Integer #
Methods (==) :: ( ~ bool) (BooleanOf Integer) => Integer -> Integer -> bool # (/=) :: ( ~ bool) (BooleanOf Integer) => Integer -> Integer -> bool #
EqB a => EqB (z -> a) #
Methods (==) :: ( ~ bool) (BooleanOf (z -> a)) => (z -> a) -> (z -> a) -> bool # (/=) :: ( ~ bool) (BooleanOf (z -> a)) => (z -> a) -> (z -> a) -> bool #

class Boolean (BooleanOf a) => OrdB a where #

Types with inequality. Minimum definition: '(<*)'.

Minimal complete definition

(<*)

Methods

(<*), (<=*), (>*), (>=*) :: bool ~ BooleanOf a => a -> a -> bool infix 4 <*, <=*, >*, >=* #

Instances

OrdB Bool #
Methods (<) :: ( ~ bool) (BooleanOf Bool) => Bool -> Bool -> bool # (<=) :: ( ~ bool) (BooleanOf Bool) => Bool -> Bool -> bool # (>) :: ( ~ bool) (BooleanOf Bool) => Bool -> Bool -> bool # (>=) :: ( ~ bool) (BooleanOf Bool) => Bool -> Bool -> bool #
OrdB Char #
Methods (<) :: ( ~ bool) (BooleanOf Char) => Char -> Char -> bool # (<=) :: ( ~ bool) (BooleanOf Char) => Char -> Char -> bool # (>) :: ( ~ bool) (BooleanOf Char) => Char -> Char -> bool # (>=) :: ( ~ bool) (BooleanOf Char) => Char -> Char -> bool #
OrdB Double #
Methods (<) :: ( ~ bool) (BooleanOf Double) => Double -> Double -> bool # (<=) :: ( ~ bool) (BooleanOf Double) => Double -> Double -> bool # (>) :: ( ~ bool) (BooleanOf Double) => Double -> Double -> bool # (>=) :: ( ~ bool) (BooleanOf Double) => Double -> Double -> bool #
OrdB Float #
Methods (<) :: ( ~ bool) (BooleanOf Float) => Float -> Float -> bool # (<=) :: ( ~ bool) (BooleanOf Float) => Float -> Float -> bool # (>) :: ( ~ bool) (BooleanOf Float) => Float -> Float -> bool # (>=) :: ( ~ bool) (BooleanOf Float) => Float -> Float -> bool #
OrdB Int #
Methods (<) :: ( ~ bool) (BooleanOf Int) => Int -> Int -> bool # (<=) :: ( ~ bool) (BooleanOf Int) => Int -> Int -> bool # (>) :: ( ~ bool) (BooleanOf Int) => Int -> Int -> bool # (>=) :: ( ~ bool) (BooleanOf Int) => Int -> Int -> bool #
OrdB Integer #
Methods (<) :: ( ~ bool) (BooleanOf Integer) => Integer -> Integer -> bool # (<=) :: ( ~ bool) (BooleanOf Integer) => Integer -> Integer -> bool # (>) :: ( ~ bool) (BooleanOf Integer) => Integer -> Integer -> bool # (>=) :: ( ~ bool) (BooleanOf Integer) => Integer -> Integer -> bool #
OrdB a => OrdB (z -> a) #
Methods (<) :: ( ~ bool) (BooleanOf (z -> a)) => (z -> a) -> (z -> a) -> bool # (<=) :: ( ~ bool) (BooleanOf (z -> a)) => (z -> a) -> (z -> a) -> bool # (>) :: ( ~ bool) (BooleanOf (z -> a)) => (z -> a) -> (z -> a) -> bool # (>=) :: ( ~ bool) (BooleanOf (z -> a)) => (z -> a) -> (z -> a) -> bool #

minB :: (IfB a, OrdB a) => a -> a -> a #

Variant of min using ifB and '(<=*)'

maxB :: (IfB a, OrdB a) => a -> a -> a #

Variant of max using ifB and '(>=*)'

sort2B :: (IfB a, OrdB a) => (a, a) -> (a, a) #

Variant of min and max using ifB and '(<=*)'

guardedB :: (IfB b, bool ~ BooleanOf b) => bool -> [(bool, b)] -> b -> b #

A generalized replacement for guards and chained ifs.

caseB :: (IfB b, bool ~ BooleanOf b) => a -> [(a -> bool, b)] -> b -> b #

A generalized version of a case like control structure.