Safe Haskell	None
Language	Haskell2010

Combinator.Booly

Description

A set of typeclasses Falsifier, Andlike, Orlike, and Xorlike, that define operations dealing with boolean-representable structures such as Maybe which has true-like Just and false-like Nothing, or '[]' by true-like non-empty list and false-like empty list.

Synopsis

Documentation

class Andlike a where #

Boolean-like logic operation >&> that acts like AND for any boolean-representable datatypes, e.g. '[]' or Maybe.

Associativity

(a >&> b) >&> c == a >&> (b >&> c)

Absorbing element / truth table

false >&> false == false

false >&> b == false

a >&> false == false

a >&> b == b

Methods

(<&<) :: a -> a -> a infixl 7 #

Andlike operator, returns the rightmost argument on success, i.e. if no false are present.

(<&<) :: (Applicative f, f b ~ a) => a -> a -> a infixl 7 #

Andlike operator, returns the rightmost argument on success, i.e. if no false are present.

Instances

Andlike Bool #
Methods (<&<) :: Bool -> Bool -> Bool #
Andlike () #
Methods (<&<) :: () -> () -> () #
Andlike ByteString #
Methods (<&<) :: ByteString -> ByteString -> ByteString #
Andlike ByteString #
Methods (<&<) :: ByteString -> ByteString -> ByteString #
Andlike Text #
Methods (<&<) :: Text -> Text -> Text #
Andlike [a] #
Methods (<&<) :: [a] -> [a] -> [a] #
Andlike (Maybe a) #
Methods (<&<) :: Maybe a -> Maybe a -> Maybe a #
Andlike (Option a) #
Methods (<&<) :: Option a -> Option a -> Option a #
Andlike (Vector a) #
Methods (<&<) :: Vector a -> Vector a -> Vector a #
Andlike (Either a b) #
Methods (<&<) :: Either a b -> Either a b -> Either a b #
(Andlike a, Andlike b) => Andlike (a, b) #
Methods (<&<) :: (a, b) -> (a, b) -> (a, b) #
Andlike (Parser i a) #
Methods (<&<) :: Parser i a -> Parser i a -> Parser i a #
Ord k => Andlike (Map k v) #
Methods (<&<) :: Map k v -> Map k v -> Map k v #
(Andlike a, Andlike b, Andlike c) => Andlike (a, b, c) #
Methods (<&<) :: (a, b, c) -> (a, b, c) -> (a, b, c) #
(Andlike a, Andlike b, Andlike c, Andlike d) => Andlike (a, b, c, d) #
Methods (<&<) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #

class Orlike a where #

Boolean-like logic operation <|< that acts like OR for any boolean-representable datatypes, e.g. '[]' or Maybe. It is basically 'Control.Applicative.(|)' with a list instance that doesn't append.

Associativity

(a <|< b) <|< c == a <|< (b <|< c)

Absorbing element / truth table

false <|< false == false

false <|< b == b

a <|< false == a

a <|< b == a

Methods

(<|<) :: a -> a -> a infixl 5 #

Orlike operator, returns the leftmost true-like argument, otherwise the rightmost true-like argument, or finally false.

(<|<) :: (Alternative f, f b ~ a) => a -> a -> a infixl 5 #

Orlike operator, returns the leftmost true-like argument, otherwise the rightmost true-like argument, or finally false.

Instances

Orlike Bool #
Methods (<\|<) :: Bool -> Bool -> Bool #
Orlike () #
Methods (<\|<) :: () -> () -> () #
Orlike ByteString #
Methods (<\|<) :: ByteString -> ByteString -> ByteString #
Orlike ByteString #
Methods (<\|<) :: ByteString -> ByteString -> ByteString #
Orlike Text #
Methods (<\|<) :: Text -> Text -> Text #
Orlike [a] #
Methods (<\|<) :: [a] -> [a] -> [a] #
Orlike (Maybe a) #
Methods (<\|<) :: Maybe a -> Maybe a -> Maybe a #
Orlike (Option a) #
Methods (<\|<) :: Option a -> Option a -> Option a #
Orlike (Vector a) #
Methods (<\|<) :: Vector a -> Vector a -> Vector a #
Orlike (Either a b) #
Methods (<\|<) :: Either a b -> Either a b -> Either a b #
(Orlike a, Orlike b) => Orlike (a, b) #
Methods (<\|<) :: (a, b) -> (a, b) -> (a, b) #
Orlike (Parser i a) #
Methods (<\|<) :: Parser i a -> Parser i a -> Parser i a #
Ord k => Orlike (Map k v) #
Methods (<\|<) :: Map k v -> Map k v -> Map k v #
(Orlike a, Orlike b, Orlike c) => Orlike (a, b, c) #
Methods (<\|<) :: (a, b, c) -> (a, b, c) -> (a, b, c) #
(Orlike a, Orlike b, Orlike c, Orlike d) => Orlike (a, b, c, d) #
Methods (<\|<) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #

class Xorlike a where #

Boolean-like logic operation <^> that acts like XOR for any boolean-representable datatypes, e.g. '[]' or Maybe.

Absorbing element / truth table

false <^> false == false

false <^> b == b

a <^> false == a

a <^> b == false

Minimal complete definition

(<^>)

Methods

(<^>) :: a -> a -> a infixl 6 #

Xorlike operator, returns whichever argument is true-like as both cannot simultaneously be true-like values, or false.

Instances

Xorlike Bool #
Methods (<^>) :: Bool -> Bool -> Bool #
Xorlike () #
Methods (<^>) :: () -> () -> () #
Xorlike ByteString #
Methods (<^>) :: ByteString -> ByteString -> ByteString #
Xorlike ByteString #
Methods (<^>) :: ByteString -> ByteString -> ByteString #
Xorlike Text #
Methods (<^>) :: Text -> Text -> Text #
Xorlike [a] #
Methods (<^>) :: [a] -> [a] -> [a] #
Xorlike (Maybe a) #
Methods (<^>) :: Maybe a -> Maybe a -> Maybe a #
Xorlike (Option a) #
Methods (<^>) :: Option a -> Option a -> Option a #
Xorlike (Vector a) #
Methods (<^>) :: Vector a -> Vector a -> Vector a #
Ord k => Xorlike (Map k v) #
Methods (<^>) :: Map k v -> Map k v -> Map k v #

class Falsifier a where #

Methods

false :: a #

false :: Monoid a => a #

Instances

Falsifier Bool #
Methods false :: Bool #
Falsifier () #
Methods false :: () #
Falsifier ByteString #
Methods false :: ByteString #
Falsifier ByteString #
Methods false :: ByteString #
Falsifier Text #
Methods false :: Text #
Falsifier [a] #
Methods false :: [a] #
Falsifier (Maybe a) #
Methods false :: Maybe a #
Falsifier (Option a) #
Methods false :: Option a #
Falsifier (Vector a) #
Methods false :: Vector a #
Falsifier (Parser i a) #
Methods false :: Parser i a #
Ord k => Falsifier (Map k v) #
Methods false :: Map k v #

(>&>) :: Andlike a => a -> a -> a infixr 7 #

Flipped version of <&<. Returns the leftmost argument on both success or failure.

(>|>) :: Orlike a => a -> a -> a infixr 5 #

Flipped version of <|<. Returns the leftmost argument on both success or failure.

andLast :: (Andlike a, Falsifier a, Foldable t) => t a -> a #

Returns the last element on success of all values.

andHead :: (Andlike a, Falsifier a, Foldable t) => t a -> a #

Returns the first element on success of all values.

andMappend :: (Andlike a, Monoid a) => a -> a -> a #

Monadic append with the annihilating operator guarding each argument. Returns the mappended result on success.

andMconcat :: (Andlike a, Falsifier a, Monoid a, Foldable t) => t a -> a #

Monadic concatenation with the annihilating operator guarding each argument.

isFalse :: (Eq a, Falsifier a) => a -> Bool #

isTrue :: (Eq a, Falsifier a) => a -> Bool #

boolF :: (Eq b, Falsifier b) => a -> a -> b -> a #

Similar to bool.

voidF :: Falsifier a => a -> a #

Discard the argument and return false.

whenF :: (Eq a, Eq b, Falsifier a, Falsifier b) => a -> b -> b #

Similar to when but takes a boolean-like and returns false instead of `()`.

unlessF :: (Eq a, Eq b, Falsifier a, Falsifier b) => a -> b -> b #

Similar to unless but takes a boolean-like and returns false instead of `()`.