foldMap

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"

Map the elements in the set to a monoid and combine with (<>).

Apply the provided mapping function and monoidal combine all values. Subject to fusion

A monoidal strict left fold. Subject to fusion Since 0.5.3

foldMap equivalent for metadatas.

Convert a "foldMap" to a Fold

Map each element of the stream to a monoid, and take the monoidal sum of the results.

>>> S.foldMap Sum $ S.take 2 (S.stdinLn)
1<Enter>
2<Enter>
3<Enter>
Sum {getSum = 6} :> ()

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

Synonym for ofoldMap

Map each element to a monoid, then combine the results

Generalizes foldMap from Data.Foldable, except the function arguments are prime factors rather than the structure elements.

This is like mconcat . map f, but in many cases the result of f will not be storable.

Monoidal fold over the element of an array.

Definition:

>>> foldMap f = Fold.lmap f Fold.mconcat

Make a fold from a pure function that folds the output of the function using mappend and mempty.

>>> sum = Fold.foldMap Data.Monoid.Sum

>>> Stream.fold sum $ Stream.enumerateFromTo 1 10
Sum {getSum = 55}

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