Data.Easy

easy-data aims to make Either, List, Tuple, Monoid and Bool counterparts to the functions originally defined in Data.Maybe, whenever applicable.

This module also adds some extra useful functions, that can be found in otherwise disperse packages, pages, mailing lists, etc. A relevant link will be included whenever appropriate, or just a simple note regarding where to find the other implementations. The main goal is to have a consistent set of sensible convertions between types, providing either default values or custom error messages when faced with partial functions (in a mathematical sense).

This module is undoubtably neither original, nor providing the 'best' implementations. Its goal is instead to provide a regular and consistent set of functions, easy do memorize and use, for the Haskell beginner.

Most functions are one-liners, and you should read their actual code, to either use it as a more idiomatic haskell code, or to develop a better version yourself. Most of these functions are hand-picked from one of the following libraries, that also feature a lot of other goodies, so you should check them out.

safe : http://hackage.haskell.org/package/safe

either : http://hackage.haskell.org/package/either

errors : http://hackage.haskell.org/package/errors

basic-prelude:http://hackage.haskell.org/package/basic-prelude

missingh : http://hackage.haskell.org/package/MissingH

utility-ht : http://hackage.haskell.org/package/utility-ht

Note that the Safe module is re-exported by this module. Please notify me if you think I'm missing some other library.

For monad related functions, check my other related module, Control.Monad.Trans.Convert, or the modules that inspired it, either and errors.

Some choices have been made, and I am open to discussion whether they are adequate or not. Please contribute and help me make this a (even) more easy and consistent module.

Module exports

module Safe

Additional functions

Maybe

Since this module maps the Data.Maybe functions to other data types, we mainly just import (and re-export) this module. The extra functions are dedicated to conversions to other types.

maybeToMonoid :: Monoid a => Maybe a -> a

Maybe to monoid conversion

monoidToMaybe :: (Eq a, Monoid a) => a -> Maybe a

Convert a monoid value into a maybe value (Nothing if mempty).

monoidToMaybe = monoid Nothing Just

Either

Copied most of the functions from Data.Either.Combinators, from the "either" package. This package has a huge import list, unnecessary for such simple combinators.

fromLeft :: a -> Either a b -> a

Extract the left value or a default.

fromLeft ≡ either id

>>> fromLeft "hello" (Right 42)
"hello"

>>> fromLeft "hello" (Left "world")
"world"

fromRight :: b -> Either a b -> b

Extract the right value or a default.

fromRight b ≡ either b id

>>> fromRight "hello" (Right "world")
"world"

>>> fromRight "hello" (Left 42)
"hello"

fromLeft' :: Either a b -> a

Extracts the element out of a Left and throws an error if its argument take the form Right _.

Using Control.Lens:

fromLeft' x ≡ x^?!_Left

>>> fromLeft' (Left 12)
12

fromRight' :: Either a b -> b

Extracts the element out of a Right and throws an error if its argument take the form Left _.

Using Control.Lens:

fromRight' x ≡ x^?!_Right

>>> fromRight' (Right 12)
12

mapBoth :: (a -> c) -> (b -> d) -> Either a b -> Either c d

The mapBoth function takes two functions and applies the first if iff the value takes the form Left _ and the second if the value takes the form Right _.

Using Data.Bifunctor:

mapBoth = bimap

Using Control.Arrow:

mapBoth = (+++)

>>> mapBoth (*2) (*3) (Left 4)
Left 8

>>> mapBoth (*2) (*3) (Right 4)
Right 12

mapLeft :: (a -> c) -> Either a b -> Either c b

The mapLeft function takes a function and applies it to an Either value iff the value takes the form Left _.

Using Data.Bifunctor:

mapLeft = first

Using Control.Arrow:

mapLeft = (left)

Using Control.Lens:

mapLeft = over _Left

>>> mapLeft (*2) (Left 4)
Left 8

>>> mapLeft (*2) (Right "hello")
Right "hello"

mapRight :: (b -> c) -> Either a b -> Either a c

The mapRight function takes a function and applies it to an Either value iff the value takes the form Right _.

Using Data.Bifunctor:

mapRight = second

Using Control.Arrow:

mapRight = (right)

Using Control.Lens:

mapRight = over _Right

>>> mapRight (*2) (Left "hello")
Left "hello"

>>> mapRight (*2) (Right 4)
Right 8

whenLeft :: Applicative m => Either a b -> (a -> m ()) -> m ()

The whenLeft function takes an Either value and a function which returns a monad. The monad is only executed when the given argument takes the form Left _, otherwise it does nothing.

Using Control.Lens:

whenLeft ≡ forOf_ _Left

>>> whenLeft (Left 12) print
12

whenRight :: Applicative m => Either a b -> (b -> m ()) -> m ()

The whenRight function takes an Either value and a function which returns a monad. The monad is only executed when the given argument takes the form Right _, otherwise it does nothing.

Using Data.Foldable:

whenRight ≡ forM_

Using Control.Lens:

whenRight ≡ forOf_ _Right

>>> whenRight (Right 12) print
12

unlessLeft :: Applicative m => Either a b -> (b -> m ()) -> m ()

A synonym of whenRight.

unlessRight :: Applicative m => Either a b -> (a -> m ()) -> m ()

A synonym of whenLeft.

leftToMaybe :: Either a b -> Maybe a

Maybe get the Left side of an Either.

leftToMaybe ≡ either Just (const Nothing)

Using Control.Lens:

leftToMaybe ≡ preview _Left
leftToMaybe x ≡ x^?_Left

>>> leftToMaybe (Left 12)
Just 12

>>> leftToMaybe (Right 12)
Nothing

rightToMaybe :: Either a b -> Maybe b

Maybe get the Right side of an Either.

rightToMaybe ≡ either (const Nothing) Just

Using Control.Lens:

rightToMaybe ≡ preview _Right
rightToMaybe x ≡ x^?_Right

>>> rightToMaybe (Left 12)
Nothing

>>> rightToMaybe (Right 12)
Just 12

fromRightNote :: String -> Either a b -> b

Force a right value, or otherwise fail with provided error message

fromRightNote err = either (error err) id

fromLeftNote :: String -> Either a b -> a

Force a left value, or otherwise fail with provided error message

fromLeftNote err = either id (error err)

fromEither :: b -> Either a b -> b

Force a right value, providing a default value if the Either is Left

listToEither :: a -> [b] -> Either a b

Extract the first element of a list as a Right value, or else use the default value provided as a Left value

eitherToList :: Either a b -> [b]

Extracts the right value of an either to a singleton list, or an empty list if the Either value is a Left

Note: A Left value is lost in the convertion.

catEithers :: [Either a b] -> [b]

The catEithers function takes a list of Eithers and returns a list of all the Right values.

This is just an alias for rights, defined in Data.Either

catEithers = rights

mapEither :: (a -> Either b c) -> [a] -> [c]

The mapEither function is a version of map which can throw out elements. In particular, the functional argument returns something of type Either a b. If this is 'Left a', no element is added on to the result list. If it just Right b, then b is included in the result list.

mapEither f = rights . map f

maybeToEither :: a -> Maybe b -> Either a b

Convert a Maybe value to an Either value, with the provided default used as Left value if the Maybe value is Nothing

eitherToMaybe :: Either a b -> Maybe b

Convert an Either value to a Maybe value

This function is provided with a different name convention on Data.Either.Combinators:

eitherToMaybe = rightToMaybe

eitherToMonoid :: Monoid b => Either a b -> b

eitherToMonoid extract the right sided monoid into a single monoid value, or mempty in the case of a left value.

eitherToMonoid = either mempty id

monoidToEither :: (Eq b, Monoid b) => a -> b -> Either a b

monoidToEither extracts a non-empty value to the right side, or otherwise fills the Left side with the provided value.

joinEitherMonoid :: (Eq b, Monoid b) => a -> Either a b -> Either a b

Case analysis for a either monoid. If the right side of the monoid is mempty, then the value is transformed to a left value, using the provided function.

List

Data.Maybe counterparts for List, plus some extra functions. One special note for nubSort: this is the only 'optimized' function in this library, mainly because the original nub . sort performance is so bad. Nevertheless, never forget that you should probably not be using lists anyhow: http://www.haskell.org/haskellwiki/Performance

list :: b -> ([a] -> b) -> [a] -> b

Apply a function to a non-empty list, and retrieve its result or the default provided value if the list is empty.

isFilled :: [a] -> Bool

Alias for not.null

notNull :: [a] -> Bool

Alias for not . null . Yeah, it saves 3 characters.

notNull = not . null

isNull :: [a] -> Bool

Alias for null

fromHeadNote :: String -> [a] -> a

Similar to headNote from Safe package However, no text is added to the provided string error, for more deterministic error messages transparency.

fromList :: a -> [a] -> a

Returns the first value of a list if not empty, or the provided default value if the list is empty

catLists :: Eq a => [[a]] -> [[a]]

Alias for catMonoid.

mapList :: (a -> [b]) -> [a] -> [b]

Alias for concatMap

singleton :: a -> [a]

Insert a single value into a list

singleton = return

or

singleton = (:[])

mapV :: a -> [a -> b] -> [b]

map a value over a list of functions, and return a list of values

See: http://www.haskell.org/pipermail/haskell-cafe/2007-February/022694.html

Alternative 1: mapV value = map ($ value)

Alternative 2: mapV value lst = sequence lst value

nubSort :: (Eq a, Ord a) => [a] -> [a]

Sort and nub (remove duplicates) from a list. Specially for large lists, this is much more efficient than nub . sort.

Note: You shold probably be using Data.Set.

nubSort = Set.toAscList . Set.fromList

nubSort' :: (Eq a, Ord a, Monoid a) => [a] -> [a]

Sort, nub (remove duplicates) and remove initial empty value, if it exists. See nubSort.

atLeast :: Int -> [a] -> Bool

Lazy length: determine if a list has a given size without computing all of its elements.

See http://www.haskell.org/haskellwiki/Haskell_programming_tips

Tuple Pairs

Monoid class restriction will be used in tuple elements whenever necessary to create the concept of 'valid' value.

Here we adopt the convention of a direct mapping between Either and a tuple pair, meaning that the second value of the pair is considered the 'main' one, whenever applicable. However, if you prefer the first value to be considered instead, you can use the reciprocal "function'", like for example pairToMaybe'.

Note: if you need real heterogeneous lists, see the HList package. http://hackage.haskell.org/package/HList

pair :: Monoid c => (a -> c) -> (b -> c) -> (a, b) -> c

Case evaluation for a tuple pair, reducing it to a single value

pairS :: Monoid b => (a -> b) -> (a, a) -> b

Case evaluation for single type tuple pairs, simplification of pair.

isPairNotEmpty :: (Eq a, Monoid a, Eq b, Monoid b) => (a, b) -> Bool

Is the pair tuple 'valid', i.e., does it have at least one non-empty (monoid) value?

isPairEmpty :: (Eq a, Monoid a, Eq b, Monoid b) => (a, b) -> Bool

Is the pair tuple 'invalid', i.e., are both (monoid) elements mempty?

fromFst :: (a, b) -> a

Longer (??) alias for fst.

Note: included just for 'consistency' with the rest of the API. Use fst.

fromSnd :: (a, b) -> b

Longer (??) alias for snd.

fromPairNote :: (Eq a, Monoid a) => String -> (a, a) -> a

mappend the two monoid elements of a pair

fromPair :: (Eq a, Monoid a) => a -> (a, a) -> a

mappend the two monoid elements of a pair

listToPairNote :: String -> [a] -> (a, a)

listToPair grabs the two first elements of a list, and inserts them into a tuple. If not enough elements are available, raise the provided error.

listToPairs :: [a] -> ([(a, a)], [a])

Groups the elements of a list two by two, also returning the (possible) unpaired item not grouped.

group2 :: [a] -> [(a, a)]

Similar to listToPairs, but discards the (possible) unpaired item.

pairToList :: (a, a) -> [a]

Convert a single type pair into a two elements list

catPairs :: (Eq a, Monoid a) => [(a, a)] -> [a]

mappend each pair in a list into a single value, and filter out mempty values

mapPair :: (Eq b, Monoid b) => (a -> (b, b)) -> [a] -> [b]

Applies a pair returning function to each list element, and keeps only the non-empty mappend results (between the pair elements).

pairToEither :: (Eq b, Monoid b) => (a, b) -> Either a b

Transform a pair into an either. We adopt the convention that the second value is the one of interest. It is matched against mempty, and if equal the first value is returned as a Left value.

pairToEither' :: (Eq a, Monoid a) => (a, b) -> Either b a

Transform a pair into an either. The same as pairToEither, but the first tuple element is considered.

pairBothToEither :: (Eq a, Monoid a) => b -> (a, a) -> Either b a

Transform a pair into an either. Both values are checked for a valid monoid (non-empty). The first to be found is returned as a Right value. If none is found, a default value is returned.

eitherToPair :: Monoid b => a -> Either a b -> (a, b)

Transform an Either value into a pair. This follows the same convention as pairToEither, and thus transforms a Left value into a (Left value,mempty), and a Right value into a (def, value).

eitherToPair' :: Monoid a => b -> Either b a -> (a, b)

Transform an Either value into a pair. This follows the same convention as pairToEither', and thus transforms a Left value into a (mempty, Left value), and a Right value into a (value, def).

pairToMaybe :: (Eq a, Monoid a) => (a, a) -> Maybe a

Transform a pair onto a Maybe This function follows the same convention as pairToEither, and thus the second value is considered the most important one, and as such will take precedence over the first if both are not empty. If you prefer the first value to take precedence, see pairToMaybe'. If both elements of the pair are mempty, this function returns Nothing.

Note: the reciprocal of this function is pairToMaybe.

pairToMaybe = monoid (monoid Nothing Just a) Just b

pairToMaybe' :: (Eq a, Monoid a) => (a, a) -> Maybe a

Transform a pair onto a Maybe If both the values are non-empty, the first one is returned wrapped in a Just. If just one value is not-empty, that value is returned, irrespectively if it is the first or second. Otherwise, this function returns Nothing.

Note: the reciprocal of this function is pairToMaybe.

pairToMaybe' = monoid (monoid Nothing Just b) Just a

pairFstToMaybe :: (Eq a, Monoid a) => (a, b) -> Maybe a

Transform the first element of a pair (if it is a monoid) into an Maybe. Reciprocal to pairSndToMaybe.

pairToMaybe' = monoitToMaybe . fst

pairSndToMaybe :: (Eq b, Monoid b) => (a, b) -> Maybe b

Transform the second element of a pair (if it is a monoid) into a Maybe. Reciprocal to pairFstToMaybe.

pairToMaybe = monoitToMaybe . snd

maybeToPair :: Monoid b => a -> Maybe b -> (a, b)

Transform a Maybe value into a pair. This follows the same convention as pairToMaybe, and thus transforms a Nothing into a (def, mempty), and a Just value into a (def, value).

maybeToPair' :: Monoid a => b -> Maybe a -> (a, b)

Transform a Maybe value into a pair. This follows the same convention as pairToMaybe', and thus transforms a Nothing into a (mempty, def), and a Just value into a (value,def).

pairToMonoid :: (Eq a, Monoid a) => (a, a) -> a

Finds the first non-empty monoid in a pair, and returns it. If none found, returns mempty.

Note: reciprocal to pairToMonoid'

pairToMonoid' :: (Eq a, Monoid a) => (a, a) -> a

Finds the last non-empty monoid in a pair, and returns it. If none found, returns mempty.

Tuple Triples

Monoid class restriction will be used in tuple elements whenever necessary to create the concept of 'valid' value.

Since it does not make sense to map a triple to an Either, here we follow a different convention than from pairs, meaning that the first value is always considered the 'valid' value, if the function needs to choose (the first 'valid' value).

Note: if you need real heterogeneous lists, see the HList package. http://hackage.haskell.org/package/HList

Note: we use the postfix ' to distinguish from tuple pairs, for example in the snd' function. This clearly doesn't scale to bigger tuples. If you need those, you probably should be using a better library than this, no? See http://hackage.haskell.org/package/lens.

triple :: Monoid d => (a -> d) -> (b -> d) -> (c -> d) -> (a, b, c) -> d

Case evaluation for a tuple triple, reducing it to a single value

tripleS :: Monoid b => (a -> b) -> (a, a, a) -> b

Case evaluation for single type tuple triples, simplification of triple.

isTripleNotEmpty :: (Eq a, Monoid a, Eq b, Monoid b, Eq c, Monoid c) => (a, b, c) -> Bool

Is the triple tuple 'valid', i.e., does it have at least one non-empty (monoid) value?

isTripleEmpty :: (Eq a, Monoid a, Eq b, Monoid b, Eq c, Monoid c) => (a, b, c) -> Bool

Is the pair tuple 'invalid', i.e., are both (monoid) elements mempty?

fromFst' :: (a, b, c) -> a

Extract the first element from a triple

fst' :: (a, b, c) -> a

Alias for fromFst' (extract the first element of a triple).

fromSnd' :: (a, b, c) -> b

Extract the second element from a triple

snd' :: (a, b, c) -> b

Alias for fromSnd' (extract the second element of a triple).

fromTrd' :: (a, b, c) -> c

Extract the third element from a triple

trd' :: (a, b, c) -> c

Alias for fromTrd'

fromTripleNote :: (Eq a, Monoid a) => String -> (a, a, a) -> a

mappend the two monoid elements of a pair

fromTriple :: (Eq a, Monoid a) => a -> (a, a, a) -> a

mappend the three monoid elements of a triple

listToTripleNote :: String -> [a] -> (a, a, a)

listToTriple grabs the two three elements of a list, and inserts them into a triple tuple. If not enough elements are available, raise the provided error.

listToTriples :: [a] -> ([(a, a, a)], [a])

Groups the elements of a list three by three, also returning the (possible) remaining item(s) (not grouped).

group3 :: [a] -> [(a, a, a)]

Similar to listToTriples, but discards the (possible) remaining item(s).

tripleToList :: (a, a, a) -> [a]

Convert a single type triple tuple into a three elements list

catTriples :: (Eq a, Monoid a) => [(a, a, a)] -> [a]

mappend each triple in a list into a single value, and filter out mempty values

mapTriple :: (Eq b, Monoid b) => (a -> (b, b, b)) -> [a] -> [b]

Apply the provided function to each list element resulting in a triple, and keep only the non-empty monoids concat results.

toFstPairToTriple :: a -> (b, c) -> (a, b, c)

Pair to Triple, inserting the missing element in first place

toFstPairToTriple x (y,z) = (x,y,z)

toSndPairToTriple :: b -> (a, c) -> (a, b, c)

Pair to Triple, inserting the missing element in second place

toSndPairToTriple y (x, z) = (x, y, z)

toTrdPairToTriple :: c -> (a, b) -> (a, b, c)

Pair to Triple, inserting the missing element in third place

toTrdPairToTriple z (x, y) = (x, y, z)

pairToTriple :: c -> (a, b) -> (a, b, c)

Alias for toTrdPairToTriple

dropFstTripleToPair :: (a, b, c) -> (b, c)

Triple to pair, removing the first element.

\(_,y,z) -> (y,z)

dropSndTripleToPair :: (a, b, c) -> (a, c)

Triple to pair, removing the second element.

\(x,_,z) -> (x,z)

dropTrdTripleToPair :: (a, b, c) -> (a, b)

Triple to pair, removing the third element.

\(x,y,_) -> (x,y)

tripleToPair :: (a, b, c) -> (a, b)

Alias for dropTrdTripleToPair.

tripleToMaybe :: (Eq a, Monoid a) => (a, a, a) -> Maybe a

Triple to Maybe. Analogous to pairToMaybe, it keeps the first non-empty monoid value.

tripleToMaybe' :: (Eq a, Monoid a) => (a, a, a) -> Maybe a

Triple to Maybe. Analogous to pairToMaybe', it keeps the last non-empty monoid value.

tripleToMonoid :: (Eq a, Monoid a) => (a, a, a) -> a

Triple to Monoid. Analogous to pairToMonoid, it keeps the first non-empty monoid value.

tripleToMonoid' :: (Eq a, Monoid a) => (a, a, a) -> a

Triple to Maybe. Analogous to pairToMonoid', it keeps the last non-empty monoid value.

curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d

uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d

Monoid

The monoid version of the functions deviate slightly from the others, in the sense no value is extracted from or promoted to a monoid. Instead, the value is just checked against mempty, and kept|discarded|operated on accordingly. See http://hackage.haskell.org/package/monoid-subclasses module on hackage for a perhaps saner approach.

monoid :: (Monoid a, Eq a) => b -> (a -> b) -> a -> b

Apply a function to a non-empty monoid, and retrieve its result or the default provided value if the monoid is mempty.

isNotEmpty :: (Monoid a, Eq a) => a -> Bool

Check that a monoid is not mempty

notEmpty :: (Monoid a, Eq a) => a -> Bool

Alias for isNotEmpty.

isEmpty :: (Monoid a, Eq a) => a -> Bool

Check it is mempty

fromNotEmptyNote :: (Eq a, Monoid a) => String -> a -> a

fromNotEmptyNote keeps the monoid value if it is not empty, otherwise it raises an error with the provided message.

Note: This differs from fromJust in the sense it is not possible to extract values from monoid

fromMonoid :: (Eq a, Monoid a) => a -> a -> a

fromMonoid keeps the monoid value if it is not empty, otherwise it replaces it with the provided default value

Note: No check is made to see if default value is itself mempty

Note: This differs from fromMaybe in the sense it is not possible to extract values from monoid

Note: similar to flip | for the appropriate types.

(?+) :: (Eq a, Monoid a) => a -> a -> a infixr 1

Infix fromMonoid. Equivalent to higher order ternary operator, similar to python if in expressions

Example usage:

let x = valueThatCanBeEmpty ?+ defaultValue

(<!>) :: (Eq a, Monoid a) => a -> a -> a infixl 3

Monoid choice operator. See (obligatory reading, even if you don't understand it at first): http://stackoverflow.com/questions/13080606/confused-by-the-meaning-of-the-alternative-type-class-and-its-relationship-to

This operator implements Alternative like choice operator to Monoids.

listToMonoid :: (Eq a, Monoid a) => [a] -> a

listToMonoid extracts the first element from a monoid list into a single monoid, or returns mempty if the list is empty

Note: This differs from listToMaybe in the sense it is not possible to promote values into a monoid

listToMonoid = headDef mempty

monoidToList :: (Eq a, Monoid a) => a -> [a]

monoidToList convert an empty monoid into an empty list, otherwise it creates a singleton list with the monoid inside

Note: This differs from maybeToList in the sense it is not possible to extract the value from a monoid

monoidToList = monoid [] singleton

catMonoids :: (Eq a, Monoid a) => [a] -> [a]

Filter out all empty monoids from a list.

catMonoids = filter isNotEmpty

nonEmpty :: (Eq a, Monoid a) => [a] -> [a]

Alias for catMonoids.

mapMonoid :: (Eq b, Monoid b) => (a -> b) -> [a] -> [b]

Apply a function that returns a monoid to all elements of a list and return a new list with only not mempty results.

Note: This differs from mapMaybe in the sense it is not possible to extract the value from a monoid.

getFirst' :: (Eq a, Monoid a) => [a] -> a

Get the first non-empty element from a list. If all elements are mempty, or the list is empty, it returns mempty. Note: A newtype based solution as done by maybe in Data.Monoid will always be more efficient than this, so this is not really recommend. However, it might come handy in some non-critical code.

getLast' :: (Eq a, Monoid a) => [a] -> a

Get the last non-empty element from a list. If all elements are mempty, or the list is empty, it returns mempty. Note: A newtype based solution as done by maybe in Data.Monoid will always be more efficient than this, so this is not really recommend. However, it might come handy in some non-critical code.

headF :: (Foldable t, Monoid a) => t a -> a

A head that fails returning mempty. Gets the first element of a foldable stucture of monoids.

Returns mempty if the structure is empty.

lastF :: (Foldable t, Monoid a) => t a -> a

A last that fails returning mempty. Gets the last element of a foldable stucture of monoids. Returns mempty if the structure is empty.

Note: this function starts by mapping the foldable structure to a list...

atF :: (Foldable t, Monoid a) => t a -> Int -> a

A '(!!)' that fails returning mempty.

Note: this function starts by mapping the foldable structure to a list...

(@@) :: (Foldable t, Monoid a) => t a -> Int -> a infixl 9

Infix version of atF.

Bool

Some extra functions included, namely the simplified ternary operator modified from what is seen in https://gist.github.com/Burgestrand/218987

Note: This is probably not considered good practice. Use the standard if-then-else instead, its almost always clearer. You have been warned.

fromBool :: a -> Bool -> a -> a

fromBool is a 'if' rewrite following the call convention of fromMaybe.

fromBoolC :: a -> (a -> Bool) -> a -> a

fromBoolC is similar to fromBool, but it takes a condition rather than a simple boolean value

catBools :: [Bool] -> [Bool]

Cat bools. Filter out False values from a list. Probably useless.

catBools = filter id

(?) :: Bool -> a -> a -> a infixr 1

Ternary operator. Use like this:

(i > 0) ? i $ 1

Note: this is non-idiomatic haskell. Use at your own risk.

Note: this may require additional parenthesis, so it may not be worth it.

(?$) :: (a -> Bool) -> a -> a -> a infixr 1

Higher order ternary operator. Use like this:

(not . null) ?$ "" $ "default value"

Note: this is non-idiomatic haskell. Use at your own risk.

(?|) :: a -> (a -> Bool) -> a -> a infixr 1

Higher order ternary operator, similar to python if in expressions. Use like this:

"" ?| (not . null) $ "default value"

Note: this is non-idiomatic haskell. Use at your own risk.

boolToMaybe :: a -> Bool -> Maybe a

Provided a default value, apply it to a maybe if the predicate holds

ifToMaybe :: Bool -> a -> Maybe a

Same as boolToMaybe, but with a more familiar 'if-like' syntax

boolCToMaybe :: a -> (a -> Bool) -> Maybe a

Test a value with a function returning a Bool, and apply it to a Maybe accordingly.

ifCToMaybe :: (a -> Bool) -> a -> Maybe a

Same as boolCToMaybe, but with a more familiar 'if-like' syntax

boolToEither :: a -> b -> Bool -> Either a b

Provided two values, choose amongst them based on a Bool value.

\l r b = if b then Right r else Left l

boolCToEither :: a -> b -> (b -> Bool) -> Either a b

Provided two values, choose amongst them based on a the provided test on the second value.

\l r f = if f r then Left l else Right r

boolToList :: a -> Bool -> [a]

Insert the provided value into a list if the Bool value is True, otherwise return an empty list.

boolCToList :: a -> (a -> Bool) -> [a]

Insert the provided value into a list if the provided condition is True, otherwise return an empty list.

Use a list comprehension instead:

[value | f value]

boolToMonoid :: Monoid a => a -> Bool -> a

Keep the provided value if the Bool value is True, mempty otherwise.

boolCToMonoid :: Monoid a => a -> (a -> Bool) -> a

Keep the provided value if the Bool value is True, mempty otherwise.

(?&&) :: Monoid a => a -> Bool -> a infixl 1

Emulates and,&& and or,|| from scripting languages like python, in the sense you can mix booleans with a value to get the value when the boolean is true (or mempty otherwise).

However, in order to allow several ?&& in a row, the order is not the one normally used in languages like bash, where the test comes first.

Usage:

value ?&& bool1 ?&& bool2 ?&& ...

Note: this is non-idiomatic haskell. Use at your own risk. You should instead use the following code :

if bool1 && bool2 && ...  then value else mempty

Or better yet:

if and [bool1,bool2,...] then value else mempty

(?&&\) :: Monoid a => a -> (a -> Bool) -> a infixl 1

Emulates and,&& and or,|| from scripting languages like python, in the sense you can mix boolean tests with a value to get the original value when all the tests return true (or mempty otherwise).

However, in order to allow several ??&& in a row, the order is not the one normally used in languages like bash, where the test comes first.

Note: an easy mnemonic to remember is that operators ending in \ (lambda) imply that their parameters are functions instead of values (in this particular case, boolean tests)

Usage:

value ?&&\ condition1 ?&&\ condition2 ?&&\ ...

Note: this is non-idiomatic haskell. Use at your own risk.

allCond :: a -> [a -> Bool] -> Bool

Apply a list of boolean checks/tests to a variable, and return (True) if all of them passed.

Note: See All in Data.Monoid and all in Prelude for reference.

See: http://www.haskell.org/pipermail/haskell-cafe/2007-February/022694.html

allCond' :: [a -> Bool] -> a -> Bool

Flipped allCond

flip allCond

anyCond :: a -> [a -> Bool] -> Bool

Apply a list of boolean checks/tests to a variable, and return (True) if any of them passed.

Note: See Any in Data.Monoid and any in Prelude for reference.

See: http://www.haskell.org/pipermail/haskell-cafe/2007-February/022694.html

anyCond' :: [a -> Bool] -> a -> Bool

Flipped anyCond

flip anyCond