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 .fold!((a, e) => a + e)); // 15
// Sum all elements with explicit seed
writeln(arr .fold!((a, e) => a + e)(6)); // 21
import std .algorithm .comparison : min, max;
import std .typecons : tuple;
// Compute minimum and maximum at the same time
writeln(arr .fold!(min, max)); // tuple(1, 5)
// Compute minimum and maximum at the same time with seeds
writeln(arr .fold!(min, max)(0, 7)); // tuple(0, 7)
// Can be used in a UFCS chain
writeln(arr .map!(a => a + 1) .fold!((a, e) => a + e)); // 20
// Return the last element of any range
writeln(arr .fold!((a, e) => e)); // 5