Apply a function over each element in the non-empty list.

Map - A `Map` is an associative array data type composed of a
collection of key/value pairs such that each possible key appears
at most once in the collection.

A `Map k v` is an associative array data type composed of a
collection of key/value pairs of key type `k` and value type `v`
such that each possible key appears at most once in the collection.

Apply an applicative function to each element of a list.

The `mapAccumL` function combines the behaviours of `map` and
`foldl`; it applies a function to each element of a list, passing
an accumulating parameter from left to right, and returning a final
value of this accumulator together with the new list.

The `mapOptional` function is a version of `map` which can throw out
elements. In particular, the functional argument returns something
of type `Optional b`. If this is `None`, no element is added on to
the result list. If it is `Some b`, then `b` is included in the
result list.

Map each element of a structure to an action, evaluate these actions
from left to right, and collect the results.

A class for types that can be used as keys for the `Map` type.
All keys `k` must satisfy `keyFromText (keyToText k) == k`.

The `TextMap a` type represents an associative array from keys of type
`Text` to values of type `a`.

Map a function over each element of a list, and concatenate all the results.

`fmap` takes a function of type `a -> b`, and turns it into a
function of type `f a -> f a`, where `f` is the type which is an
instance of `Functor`.
For example, `map` is an `fmap` that only works on lists.
It takes a function `a -> b` and a `[a]`, and returns a `[b]`.

Map over both arguments at the same time.
@'bimap' f g ≡ 'first' f '.' 'second' g@
==== __Examples__
>>> bimap not (+1) (True, 3)
(False,4)
>>> bimap not (+1) (Left True)
Left False
>>> bimap not (+1) (Right 3)
Right 4

Combine the elements of a structure using a monoid.

TextMap - A map is an associative array data type composed of a
collection of key/value pairs such that, each possible key appears
at most once in the collection.