Combinator.Booly

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.

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 `()`.