Generates a map using a Range to determine the length.
*This may fail to generate anything if the keys produced by the*
*generator do not account for a large enough number of unique*
*items to satify the required map size.*

Map over a generator's shrink tree.

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.

Map a config modification function over a property.

Map between TreeT computations.

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"

**Packages**- is:exact