Menu
Search

API Documentation

version 2.109.1

overview

View source code
Display the source code in std/algorithm/iteration.d from which this page was generated on github.
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
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.each

Eagerly iterates over r and calls fun with each element.

template each(alias fun) ;

If no function to call is specified, each defaults to doing nothing but consuming the entire range. r.front will be evaluated, but that can be avoided by specifying a lambda with a lazy parameter.

each also supports opApply-based types, so it works with e.g. parallel.

Normally the entire range is iterated. If partial iteration (early stopping) is desired, fun needs to return a value of type Flag!"each" (Yes.each to continue iteration, or No.each to stop iteration).

Contained Functions

NameDescription
each

Parameters

NameDescription
fun function to apply to each element of the range
r range or iterable over which each iterates

Returns

Yes.each if the entire range was iterated, No.each in case of early stopping.

See Also

std.range.tee

Example

import std.range : iota;
import std.typecons : No;

int[] arr;
iota(5).each!(n => arr ~= n);
writeln(arr); // [0, 1, 2, 3, 4]

// stop iterating early
iota(5).each!((n) { arr ~= n; return No.each; });
writeln(arr); // [0, 1, 2, 3, 4, 0]

// If the range supports it, the value can be mutated in place
arr.each!((ref n) => n++);
writeln(arr); // [1, 2, 3, 4, 5, 1]

arr.each!"a++";
writeln(arr); // [2, 3, 4, 5, 6, 2]

auto m = arr.map!(n => n);
// by-ref lambdas are not allowed for non-ref ranges
static assert(!__traits(compiles, m.each!((ref n) => n++)));

// The default predicate consumes the range
(&m).each();
assert(m.empty);

Example

each can pass an index variable for iterable objects which support this 

auto arr = new size_t[4];

arr.each!"a=i"();
writeln(arr); // [0, 1, 2, 3]

arr.each!((i, ref e) => e = i * 2);
writeln(arr); // [0, 2, 4, 6]

Example

opApply iterators work as well 

static class S
{
    int x;
    int opApply(scope int delegate(ref int _x) dg) { return dg(x); }
}

auto s = new S;
s.each!"a++";
writeln(s.x); // 1

Authors

Andrei Alexandrescu

License

Boost License 1.0.