**Packages**- is:exact

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

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]

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

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 traverse for Monad, and the following
example shows how mapM can apply an `IO` action to a
`List` to produce a structured result.
Basic usage:

>>> import System.IO >>> mapM (openTempFile ".") ["t1", "t2"] [("./t169980-3",{handle: ./t169980-3}),("./t269980-4",{handle: ./t269980-4})]

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

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]

Using `ApplicativeDo`: '`fmap f as`' can be
understood as the `do` expression
`Functor` constraint.

do a <- as pure (f a)with an inferred

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)