Search
View source code
Display the source code in std/algorithm/iteration.d from which this page was generated on github.
Report a bug
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

# 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. The call `fold!(fun)(range, seed)` first assigns `seed` to an internal variable `result`, also called the accumulator. Then, for each element `x` in `range`, `result = fun(result, x)` gets evaluated. Finally, `result` is returned. 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).

``` template fold(fun...) ; ```

NameDescription
fold

## Parameters

NameDescription
fun the predicate function(s) to apply to the elements

`sum` is similar to `fold!((a, b) => a + b)` that offers precise summing of floating point numbers.

This 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, b) => a + b)); // 15

// Sum all elements with explicit seed
writeln(arr.fold!((a, b) => a + b)(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, b) => a + b)); // 20

// Return the last element of any range
writeln(arr.fold!((a, b) => b)); // 5
``````