foldMap -package:rio

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 (<>).

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 class. 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) 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) 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) 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 class. 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) 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.).

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} :> ()

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.

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

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