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
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
to continue iteration, or No
to stop
iteration).
Contained Functions
Name | Description |
---|---|
each |
Parameters
Name | Description |
---|---|
fun | function to apply to each element of the range |
r | range or iterable over which each iterates |
Returns
Yes
if the entire range was iterated, No
in case of early
stopping.
See Also
std
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