# :: (a -> b) -> [a] -> b

Converts a constant function to one that takes a proxy argument. Since: 0.1
Version on concatMap generalised to a Monoid rather than just a list.
```mconcatMap Sum [1,2,3] == Sum 6
\f xs -> mconcatMap f xs == concatMap f xs
```
A strict version of sum, using a custom valuation function.
```sumOn' read ["1", "2", "3"] == 6
```
A strict version of product, using a custom valuation function.
```productOn' read ["1", "2", "4"] == 8
```
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:
```>>> 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 (<>) 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:
```>>> 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"
```
A left-associative variant of foldMap that is strict in the accumulator. Use this method for strict reduction when partial results are merged via (<>).

#### Examples

Define a Monoid over finite bit strings under xor. Use it to strictly compute the xor of a list of Int values.
```>>> :set -XGeneralizedNewtypeDeriving

>>> import Data.Bits (Bits, FiniteBits, xor, zeroBits)

>>> import Data.Foldable (foldMap')

>>> import Numeric (showHex)

>>>

>>> newtype X a = X a deriving (Eq, Bounded, Enum, Bits, FiniteBits)

>>> instance Bits a => Semigroup (X a) where X a <> X b = X (a `xor` b)

>>> instance Bits a => Monoid    (X a) where mempty     = X zeroBits

>>>

>>> let bits :: [Int]; bits = [0xcafe, 0xfeed, 0xdeaf, 0xbeef, 0x5411]

>>> (\ (X a) -> showString "0x" . showHex a \$ "") \$ foldMap' X bits
"0x42"
```
Map each element of the structure to a monoid, and combine the results.
A variant of foldMap that is strict in the accumulator.
This function may be used as a value for foldMap in a Foldable instance.
```foldMapDefault f ≡ getConst . traverse (Const . f)
```
This function may be used as a value for foldMap in a Foldable instance.
```foldMapDefault f ≡ getConst . traverse (Const . f)
```
A generalization of sumOn' to Foldable instances.
A generalization of productOn' to Foldable instances.
O(n) Map each element of the structure to a monoid and combine the results. It uses the same implementation as the corresponding method of the Foldable type cless. Note that it's implemented in terms of foldr and won't fuse with functions that traverse the vector from left to right (map, generate, etc.).
O(n) Like foldMap, but strict in the accumulator. It uses the same implementation as the corresponding method of the Foldable type class. Note that it's implemented in terms of foldl', so it fuses in most contexts.
Map each element of the structure to a monoid, and combine the results. Similar to foldMap
Defaults to mconcatMap m k = foldr (mappend . k) mempty m