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

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

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]

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.

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

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

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

This function may be used as a value for fmap in a
Functor instance, provided that traverse is defined.
(Using fmapDefault with a Traversable instance defined
only by sequenceA will result in infinite recursion.)

fmapDefault f ≡ runIdentity . traverse (Identity . f)

Map each element of the structure to a monoid, and combine the
results.

A variant of foldMap that is strict in the accumulator.

Transformation of one immediate subterm with success

Transformation of at least one immediate subterm does not fail

A generic query that processes the immediate subterms and returns a
list of results. The list is given in the same order as originally
specified in the declaration of the data constructors.

A generic query that processes one child by index (zero-based)

A generic query with a left-associative binary operator

A generic query with a right-associative binary operator

A generic transformation that maps over the immediate subterms
The default definition instantiates the type constructor `c` in
the type of gfoldl to an identity datatype constructor, using
the isomorphism pair as injection and projection.