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 signedin GitHub account. This works well for small changes.
If you'd like to make larger changes you may want to consider using
local clone.
Module std.algorithm.iteration
This is a submodule of std
.
It contains generic iteration algorithms.
Function Name  Description 

cache  Eagerly evaluates and caches another range's front . 
cacheBidirectional  As above, but also provides back and popBack . 
chunkBy  chunkBy!((a,b) => a[1] == b[1])([[1, 1], [1, 2], [2, 2], [2, 1]])
returns a range containing 3 subranges: the first with just
[1, 1] ; the second with the elements [1, 2] and [2, 2] ;
and the third with just [2, 1] . 
cumulativeFold  cumulativeFold!((a, b) => a + b)([1, 2, 3, 4]) returns a
lazilyevaluated range containing the successive reduced values 1 ,
3 , 6 , 10 . 
each  each!writeln([1, 2, 3]) eagerly prints the numbers 1 , 2
and 3 on their own lines. 
filter  filter!(a => a > 0)([1, 1, 2, 0, 3]) iterates over elements 1
and 2 . 
filterBidirectional  Similar to filter , but also provides back and popBack at
a small increase in cost. 
fold  fold!((a, b) => a + b)([1, 2, 3, 4]) returns 10 . 
group  group([5, 2, 2, 3, 3]) returns a range containing the tuples
tuple(5, 1) , tuple(2, 2) , and tuple(3, 2) . 
joiner  joiner(["hello", "world!"], "; ") returns a range that iterates
over the characters "hello; world!" . No new string is created 
the existing inputs are iterated. 
map  map!(a => a * 2)([1, 2, 3]) lazily returns a range with the numbers
2 , 4 , 6 . 
permutations  Lazily computes all permutations using Heap's algorithm. 
reduce  reduce!((a, b) => a + b)([1, 2, 3, 4]) returns 10 .
This is the old implementation of fold . 
splitter  Lazily splits a range by a separator. 
sum  Same as fold , but specialized for accurate summation. 
uniq  Iterates over the unique elements in a range, which is assumed sorted. 
Functions
Name  Description 

cache

cache eagerly evaluates front of range
on each construction or call to popFront ,
to store the result in a cache.
The result is then directly returned when front is called,
rather than reevaluated.

cacheBidirectional

cache eagerly evaluates front of range
on each construction or call to popFront ,
to store the result in a cache.
The result is then directly returned when front is called,
rather than reevaluated.

chunkBy

Chunks an input range into subranges of equivalent adjacent elements.
In other languages this is often called partitionBy , groupBy
or sliceWhen .

group

Groups consecutively equivalent elements into a single tuple of the element and the number of its repetitions. 
joiner

Lazily joins a range of ranges with a separator. The separator itself
is a range. If a separator is not provided, then the ranges are
joined directly without anything in between them (often called flatten
in other languages).

permutations

Lazily computes all permutations of r using Heap's algorithm.

splitter

Lazily splits a range using an element as a separator. This can be used with any narrow string type or sliceable range type, but is most popular with string types. 
splitter

Similar to the previous overload of splitter , except this one uses another
range as a separator. This can be used with any narrow string type or sliceable
range type, but is most popular with string types. The predicate is passed to
std , and can either accept a string, or any callable
that can be executed via pred(r .

splitter

Similar to the previous overload of splitter , except this one does not use a separator.
Instead, the predicate is an unary function on the input range's element type.
The isTerminator predicate is passed to std and can
either accept a string, or any callable that can be executed via pred(element, s) .

splitter

Lazily splits the string s into words, using whitespace as the delimiter.

sum

Sums elements of r , which must be a finite
input range. Although
conceptually sum(r) is equivalent to fold !((a, b) => a +
b)(r, 0), sum uses specialized algorithms to maximize accuracy,
as follows.

uniq

Lazily iterates unique consecutive elements of the given range (functionality
akin to the uniq system
utility). Equivalence of elements is assessed by using the predicate
pred , by default "a == b" . The predicate is passed to
std , and can either accept a string, or any callable
that can be executed via pred(element, element) . If the given range is
bidirectional, uniq also yields a
bidirectional range.

Structs
Name  Description 

Group

Groups consecutively equivalent elements into a single tuple of the element and the number of its repetitions. 
Permutations

Lazily computes all permutations of r using Heap's algorithm.

Templates
Name  Description 

cumulativeFold

Similar to fold , but returns a range containing the successive reduced values.
The call cumulativeFold!(fun)(range, seed) first assigns seed to an
internal variable result , also called the accumulator.
The returned range contains the values result = fun(result, x) lazily
evaluated for each element x in range . Finally, the last element has the
same value as fold!(fun)(seed, range) .
The oneargument version cumulativeFold!(fun)(range) works similarly, but
it returns the first element unchanged and uses it as seed for the next
elements.
This function is also known as
partial_sum,
accumulate,
scan,
Cumulative Sum.

each

Eagerly iterates over r and calls pred over each element.

filter

auto filter(Range)(Range rs) if (isInputRange!(Unqual!Range));

filterBidirectional

auto filterBidirectional(Range)(Range r) if (isBidirectionalRange!(Unqual!Range));

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 oneargument version fold!(fun)(range)
works similarly, but it uses the first element of the range as the
seed (the range must be nonempty).

map

auto map(Range)(Range r) if (isInputRange!(Unqual!Range));

reduce

Implements the homonym function (also known as accumulate , compress , inject , or foldl ) present in various programming
languages of functional flavor. There is also fold which does
the same thing but with the opposite parameter order.
The call reduce!(fun)(seed, range) 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 oneargument version reduce!(fun)(range)
works similarly, but it uses the first element of the range as the
seed (the range must be nonempty).

Authors
License
Comments
Copyright © 19992017 by the D Language Foundation  Page generated by ddox.