All calls function f for each value x produced by an iterator until either f returns false, or the iterator is exhausted.

Any calls function f for each value x produced by an iterator until either f(x) returns true, or the iterator is exhausted.

AppendToSlice appends every value produced by an iterator to dest, and returns the modified dest (like the builtin append).

Cat (for "concatenate") returns an iterator that merges several input iterators, consuming an input iterator in its entirety to produce values before moving on to the next input iterator.

Check calls function f for each value produced by an iterator.

Count calls function f for each value x produced by an iterator.

Counter returns an iterator that produces a series of integers, starting at the given number, and increasing by step each time.

CutString is like [Cut], but operates on a string, producing strings delimited by a separator rune.

CutStringStr is like [CutString], but the delimiter is a string, not just a single rune.

Empty returns an iterator that is typed, but empty.

Enumerate produces a [Pair] for each value produced by the input iterator, where Pair.Key is an integer that starts at zero and increases by one with each produced value.

Exhaust consumes an iterator and discards the produced values.

Filter returns an iterator that consumes an input iterator and only produces those values where the provided filter function f returns true.

Final produces a [FinalValue] for each value produced by the input iterator.

FromMap returns an iterator that produces each (key, value) pair from the input [builtin.Map] (of Go type map[X]Y, not to be confused with the higher order function [Map]) as an Pair.

FromSlice returns an iterator that produces each item in the input slice.

FromString returns an iterator that produces the runes of string s.

Func performs a type cast that returns an iterator (type [It]) from any function meeting the iterator interface.

InsertToMap modifies a [builtin.Map] (of Go type map[X]Y, not to be confused with the higher order function [Map]).

Join uses a [Joiner] to build a result by walking over an iterator.

Length exhausts an iterator, returning its length.

Map returns an iterator that consumes an input iterator (of type X) and produces values (of type Y) for each input value, according to some mapping function f(x X) => y Y.

Pairwise returns an iterator that produces overlapping pairs of values produced by the input.

PairwiseEnd is like [Pairwise], however a final result pair [2]X{value, lastValue} is produced for the last value.

Reduce applies function f to each element of the sequence (in order) with the previous return value from f as the first argument and the element as the second argument (for the first call to f, the supplied initial value is used instead of a return value), returning the final value returned by f.

Repeat produces the value x, with n repetitions.

StringJoiner returns a [Joiner] for concatenating strings with a (possibly empty) separator.

Take returns an iterator that produces only (up to) the first n items of the input iterator.

Tee returns a slice of n iterators that each, individually, produce the same values otherwise produced by the input iterator.

ToMap returns a new [builtin.map] (of Go type map[X]Y, not to be confused with the higher order function [Map]).

ToSlice returns a slice of every value produced by an iterator.

ToString returns a string from an iterator that produces runes.

Walk calls a visitor function f for each value produced by an iterator.

WalkFinal is like [Walk], but the second argument to the visitor function is true if x is the last item to be produced by an iterator.

Zip returns an iterator that produces slices of the results of each input iterator, in lockstep, terminating when any input is exhausted.

ZipFlat returns an iterator that produces the results of each input iterator, in turn, terminating when any input is exhausted.

FinalValue is a value returned by the [Final] function.

Pair is any Key, Value pair.

Joiner is a type for something that can build a result by walking over an iterator using [Join].

It is an iterator, defined as a function that produces a (possibly infinite) sequence of (value, true) tuples through successive calls.