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"