map `f xs` is the list obtained by
applying `f` to each element of `xs`, i.e.,
`map id == id`
**Examples**

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]this means that

>>> map (+1) [1, 2, 3] [2,3,4]

>>> map id [1, 2, 3] [1,2,3]

>>> map (\n -> 3 * n + 1) [1, 2, 3] [4,7,10]

Map a function over a NonEmpty stream.

Map each element of a structure to a monadic action, evaluate these
actions from left to right, and collect the results. For a version
that ignores the results see mapM_.
**Examples**

mapM is literally a traverse with a type signature
restricted to Monad. Its implementation may be more efficient
due to additional power of Monad.

An associative operation
**NOTE**: This method is redundant and has the default
implementation `mappend = (<>)` since
*base-4.11.0.0*. Should it be implemented manually, since
mappend is a synonym for (<>), it is expected that
the two functions are defined the same way. In a future GHC release
mappend will be removed from Monoid.

The mapAccumL function behaves like a combination of
fmap and foldl; it applies a function to each element of
a structure, passing an accumulating parameter from left to right, and
returning a final value of this accumulator together with the new
structure.
**Examples**

Basic usage:

>>> mapAccumL (\a b -> (a + b, a)) 0 [1..10] (55,[0,1,3,6,10,15,21,28,36,45])

>>> mapAccumL (\a b -> (a <> show b, a)) "0" [1..5] ("012345",["0","01","012","0123","01234"])

The mapAccumR function behaves like a combination of
fmap and foldr; it applies a function to each element of
a structure, passing an accumulating parameter from right to left, and
returning a final value of this accumulator together with the new
structure.
**Examples**

Basic usage:

>>> mapAccumR (\a b -> (a + b, a)) 0 [1..10] (55,[54,52,49,45,40,34,27,19,10,0])

>>> mapAccumR (\a b -> (a <> show b, a)) "0" [1..5] ("054321",["05432","0543","054","05","0"])

The mapMaybe function is a version of map which can
throw out elements. In particular, the functional argument returns
something of type `Maybe b`. If this is Nothing,
no element is added on to the result list. If it is `Just
b`, then `b` is included in the result list.
**Examples**

Using `mapMaybe f x` is a shortcut for
`catMaybes $ map f x` in most cases:

>>> import GHC.Internal.Text.Read ( readMaybe ) >>> let readMaybeInt = readMaybe :: String -> Maybe Int >>> mapMaybe readMaybeInt ["1", "Foo", "3"] [1,3] >>> catMaybes $ map readMaybeInt ["1", "Foo", "3"] [1,3]If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3] [1,2,3]

The mapAndUnzipM function maps its first argument over a list,
returning the result as a pair of lists. This function is mainly used
with complicated data structures or a state monad.

This function maps one exception into another as proposed in the paper
"A semantics for imprecise exceptions".

The mapAccumM function behaves like a combination of
mapM and mapAccumL that traverses the structure while
evaluating the actions and passing an accumulating parameter from left
to right. It returns a final value of this accumulator together with
the new structure. The accumulator is often used for caching the
intermediate results of a computation.
**Examples**

Basic usage:

>>> let expensiveDouble a = putStrLn ("Doubling " <> show a) >> pure (2 * a) >>> :{ mapAccumM (\cache a -> case lookup a cache of Nothing -> expensiveDouble a >>= \double -> pure ((a, double):cache, double) Just double -> pure (cache, double) ) [] [1, 2, 3, 1, 2, 3] :} Doubling 1 Doubling 2 Doubling 3 ([(3,6),(2,4),(1,2)],[2,4,6,2,4,6])

Map a function over all the elements of a container and concatenate
the resulting lists.
**Examples**

Basic usage:

>>> concatMap (take 3) [[1..], [10..], [100..], [1000..]] [1,2,3,10,11,12,100,101,102,1000,1001,1002]

>>> concatMap (take 3) (Just [1..]) [1,2,3]

fmap is used to apply a function of type `(a -> b)`
to a value of type `f a`, where f is a functor, to produce a
value of type `f b`. Note that for any type constructor with
more than one parameter (e.g., `Either`), only the last type
parameter can be modified with fmap (e.g., `b` in
`Either a b`).
Some type constructors with two parameters or more have a
`Bifunctor` instance that allows both the last and the
penultimate parameters to be mapped over.
**Examples**

Convert from a `Maybe Int` to a `Maybe String`
using show:
`Either Int Int` to an `Either Int
String` using show:
`(a,b,c)` can also be written `(,,) a b c` and
its `Functor` instance is defined for `Functor ((,,) a
b)` (i.e., only the third parameter is free to be mapped over with
`fmap`).
It explains why `fmap` can be used with tuples containing
values of different types as in the following example:

>>> fmap show Nothing Nothing >>> fmap show (Just 3) Just "3"Convert from an

>>> fmap show (Left 17) Left 17 >>> fmap show (Right 17) Right "17"Double each element of a list:

>>> fmap (*2) [1,2,3] [2,4,6]Apply even to the second element of a pair:

>>> fmap even (2,2) (2,True)It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements

>>> fmap even ("hello", 1.0, 4) ("hello",1.0,True)

Map each element of the structure into a monoid, and combine the
results with `(<>)`. This fold is
right-associative and lazy in the accumulator. For strict
left-associative folds consider foldMap' instead.
**Examples**

Basic usage:
`(<>)` is lazy in its second
argument, foldMap can return a result even from an unbounded
structure. For example, lazy accumulation enables
Data.ByteString.Builder to efficiently serialise large data
structures and produce the output incrementally:

>>> foldMap Sum [1, 3, 5] Sum {getSum = 9}

>>> foldMap Product [1, 3, 5] Product {getProduct = 15}

>>> foldMap (replicate 3) [1, 2, 3] [1,1,1,2,2,2,3,3,3]When a Monoid's

>>> import qualified Data.ByteString.Lazy as L >>> import qualified Data.ByteString.Builder as B >>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20 >>> let lbs = B.toLazyByteString $ foldMap bld [0..] >>> L.take 64 lbs "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"

Given a means of mapping the elements of a structure to lists,
computes the concatenation of all such lists in order.
**Examples**

Basic usage:

>>> biconcatMap (take 3) (fmap digitToInt) ([1..], "89") [1,2,3,8,9]

>>> biconcatMap (take 3) (fmap digitToInt) (Left [1..]) [1,2,3]

>>> biconcatMap (take 3) (fmap digitToInt) (Right "89") [8,9]

Combines the elements of a structure, given ways of mapping them to a
common monoid.
**Examples**

Basic usage:

bifoldMap f g ≡ bifoldr (mappend . f) (mappend . g) mempty

>>> bifoldMap (take 3) (fmap digitToInt) ([1..], "89") [1,2,3,8,9]

>>> bifoldMap (take 3) (fmap digitToInt) (Left [1..]) [1,2,3]

>>> bifoldMap (take 3) (fmap digitToInt) (Right "89") [8,9]

Alias for bitraverse_.

A default definition of bifoldMap in terms of the
Bitraversable operations.

bifoldMapDefault f g ≡ getConst . bitraverse (Const . f) (Const . g)

The bimapAccumL function behaves like a combination of
bimap and bifoldl; it traverses a structure from left to
right, threading a state of type `a` and using the given
actions to compute new elements for the structure.
**Examples**

Basic usage:

>>> bimapAccumL (\acc bool -> (acc + 1, show bool)) (\acc string -> (acc * 2, reverse string)) 3 (True, "foo") (8,("True","oof"))

The bimapAccumR function behaves like a combination of
bimap and bifoldr; it traverses a structure from right
to left, threading a state of type `a` and using the given
actions to compute new elements for the structure.
**Examples**

Basic usage:

>>> bimapAccumR (\acc bool -> (acc + 1, show bool)) (\acc string -> (acc * 2, reverse string)) 3 (True, "foo") (7,("True","oof"))

A default definition of bimap in terms of the
Bitraversable operations.

bimapDefault f g ≡ runIdentity . bitraverse (Identity . f) (Identity . g)

**Packages**- is:exact