Template std.algorithm.iteration.fold
Implements the homonym function (also known as accumulate, compress, inject, or foldl) present in various programming
languages of functional flavor, iteratively calling one or more predicates.
template fold(fun...)
;
Each predicate in fun must take two arguments:
r
Each predicate must return a value which implicitly converts to the type of the accumulator.
For a single predicate,
the call fold!(fun)(range, seed) will:
* Use seed to initialize an internal variable result (also called
the accumulator).
* For each element e in range, evaluate result = fun(result, e).
* Return result.
The one-argument version fold!(fun)(range)
works similarly, but it uses the first element of the range as the
seed (the range must be non-empty) and iterates over the remaining
elements.
Multiple results are produced when using multiple predicates.
Contained Functions
| Name | Description |
|---|---|
| fold |
Parameters
| Name | Description |
|---|---|
| fun | the predicate function(s) to apply to the elements |
See Also
* Fold (higher-order function)
* sum is similar to fold!((a, b) => a + b) that offers
precise summing of floating point numbers.
* fold is functionally equivalent to reduce with the argument order
reversed, and without the need to use tuple
for multiple seeds.
Example
immutable arr = [1, 2, 3, 4, 5];
// Sum all elements
writeln(arr