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 function must return a value which implicitly converts to the type of the accumulator.
For a single function,
the call fold!(fun)(range, seed) will:
* Use seed to initialize an internal accumulator.
* For each element e in range, evaluate accumulator = fun(result, e).
* Return accumulator.
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 functions.
If range has only one element, the functions are never invoked and
result and the seed is returned unchanged.
Contained Functions
| Name | Description |
|---|---|
| fold |
Parameters
| Name | Description |
|---|---|
| fun | one or more functions of the form Acc function(Acc, ElemT) |
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