Maybe to monoid conversion

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

 monoidToMaybe = monoid Nothing Just

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

 fromRightNote err = either (error err) id

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

 fromLeftNote err = either id (error err)

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

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

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.

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

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

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

Convert an Either value to a Maybe value

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

 eitherToMaybe = rightToMaybe

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 extracts a non-empty value to the right side, or otherwise fills the Left side with the provided value.

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.

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

Alias for 'not'@.@'null'

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

 notNull = not . null

Alias for null

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

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

Alias for catMonoid.

Alias for concatMap

Insert a single value into a list

 singleton = return

or

 singleton = (:[])

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

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

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

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

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

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

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

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

Longer (??) alias for fst.

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

Longer (??) alias for snd.

mappend the two monoid elements of a pair

mappend the two monoid elements of a pair

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.

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

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

Convert a single type pair into a two elements list

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

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

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.

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

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.

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

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

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

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

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

 pairToMaybe' = monoitToMaybe . fst

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

 pairToMaybe = monoitToMaybe . snd

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

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

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

Note: reciprocal to pairToMonoid'

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

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

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

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

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

Extract the first element from a triple

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

Extract the second element from a triple

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

Extract the third element from a triple

Alias for fromTrd'

mappend the two monoid elements of a pair

mappend the three monoid elements of a triple

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.

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

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

Convert a single type triple tuple into a three elements list

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

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

Pair to Triple, inserting the missing element in first place

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

Pair to Triple, inserting the missing element in second place

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

Pair to Triple, inserting the missing element in third place

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

Alias for toTrdPairToTriple

Triple to pair, removing the first element.

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

Triple to pair, removing the second element.

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

Triple to pair, removing the third element.

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

Alias for dropTrdTripleToPair.

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

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

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

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

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

Check that a monoid is not mempty

Alias for isNotEmpty.

Check it is mempty

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 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.

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

Example usage:

 let x = valueThatCanBeEmpty ?+ defaultValue

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 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 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

Filter out all empty monoids from a list.

 catMonoids = filter isNotEmpty

Alias for catMonoids.

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.

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.

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.

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

Returns mempty if the structure is empty.

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...

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

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

Infix version of atF.

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

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

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

 catBools = filter id

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.

Higher order ternary operator. Use like this:

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

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

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.

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

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

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

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

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

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

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

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

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]

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

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

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

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.

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

Flipped allCond

 flip allCond

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

Flipped anyCond

 flip anyCond