The package async defines asynchronous adapters.

bufioiter defines iterator source/collector that corresponds to std library `bufio`.

containeriter defines iterator source/collector that corresponds to std library `container/*`.

cryptoiter defines iterator source/collector that corresponds to std `crypto/*`.

databaseiter defines iterator source/collector that corresponds to std library `database/*`.

encodingiter defines iterator source/collector that corresponds to std library `encoding` and all its descendants (`encoding/*`).

errbox boxes iter.Seq[V, error] and converts to iter.Seq[V].

ioiter defines iterator source/collector that corresponds to std library `io/*`.

Wrapper for iterable objects; heap, list, ring, slice, map, channel, etc.

iterreader defines functions that converts an iterator to io.Reader.

package mapper is collection of small mapping helpers.

mathiter defines iterator source/collector that corresponds to std `math/*`.

reflectiter defines iterator source/collector that corresponds to std library `reflect`.

stringsiter defines iterator source/collector that corresponds to std library `strings`.

Alternate returns an iterator that yields alternatively each seq.

Alternate returns an iterator that yields alternatively each seq.

Any returns true if any of values from seq satisfies fn.

Any2 returns true if any of key-value pairs from seq satisfies fn.

AppendBytes appends byte slices from seq to b, and returns the extended slice.

AppendSeq2 appends the values from seq to the KeyValue slice and returns the extended slice.

Assert returns an iterator over seq but each value is type-asserted to be type V.

Assert2 returns an iterator over seq but each key-value pair is type-asserted to be type K and V respectively.

AtterAll is like [AtterRange] but start is 0 and end is result of [Lenner.Len].

AtterIndices returns an iterator over pairs of indices and values retrieved from an Atter using the indices.

AtterRange is like [AtterIndices] but indices is result of calling [Range] with start and end.

Chan returns an iterator over ch.

ChanSend sends values from seq to c.

CheckEach returns an iterator over seq.

CheckEach2 returns an iterator over seq.

Collect2 collects values from seq into a new KeyValue slice and returns it.

Compact skips consecutive runs of equal elements from seq.

Compact2 skips consecutive runs of equal k-v pairs from seq.

CompactFunc is like [Compact] but uses an equality function to compare elements.

CompactFunc2 is like [Compact2] but uses an equality function to compare elements.

ConcatSliceLike logically concatenates [SliceLike][T] implementations to form a single concatenated [SliceLike][T].

Contains reports whether v is present in seq.

Contains2 reports whether k-v pair is present in seq.

ContainsFunc reports whether at least one element v of s satisfies f(v).

ContainsFunc2 reports whether at least one k-v pair of s satisfies f(k, v).

Cycle converts seq into an infinite iterator by repeatedly calling seq.

Cycle2 converts seq into an infinite iterator by repeatedly calling seq.

CycleBuffered is like [Cycle] but seq is called only once.

CycleBuffered2 is like [Cycle2] but seq is called only once.

Decorate decorates seq by prepend and append, by yielding additional elements before and after seq yields.

Decorate2 decorates seq by prepend and append, by yielding additional elements before and after seq yields.

Discard fully consumes seq without doing anything.

Discard2 fully consumes seq without doing anything.

Divide splits values from seq to key-value pairs by applying fn to convert [iter.Seq][U] to [iter.Seq2][K, V].

Empty returns an iterator over nothing.

Empty2 returns an iterator over nothing.

Enumerate adds 0-indexed integer counts to every values from seq.

Every checks every values from seq satisfying fn.

Every2 checks every key-value pairs from seq satisfying fn.

Find iterates over seq and the first value equals to v with its count.

Find2 iterates over seq and the first k-v pair equals to k and v with its count.

FindFunc iterates over seq and the first value satisfying fn(v) with its count.

FindFunc2 iterates over seq and the first k-v pair satisfying fn(v) with its count.

FindLast is like [Find] but returns the final occurrence of v.

FindLast2 is like [Find2] but returns the final occurrence of k-v pair.

FindLastFunc is like [FindFunc] but returns the final occurrence of v.

FindLastFunc2 is like [FindFunc2] but returns the final occurrence of k-v pair.

First returns the first value from seq.

First2 returns the first key-value pair from seq.

Flatten returns an iterator over each value of slices from seq.

FlattenF returns an iterator over flattened key-value pairs from seq.

FlattenL returns an iterator over flattened key-value pairs from seq.

Flatten returns and iterator over values from iterators from seq.

FlattenSeq2 returns and iterator over key-value pairs from iterators from seq.

FlattenSeqF returns an iterator over flattened key-value pairs from seq.

FlattenSeqF returns an iterator over flattened pairs from seq.

ForEach iterates over seq and calls fn with every value seq yields.

ForEach2 iterates over seq and calls fn with every key-value pair seq yields.

ForEachGo iterates over seq and calls fn with every value from seq in G's Go method.

ForEachGo2 iterates over seq and calls fn with every key-value pair from seq in G's Go method.

FromKeyValue unwraps iter.Seq[KeyValue[K, V]] into iter.Seq2[K, V] serving as a counterpart for [ToKeyValue].

InsertReduceGroup is like [ReduceGroup] but inserts result to m.

Last returns the last value from seq.

Last2 returns the last key-value pair from seq.

Limit returns an iterator over seq that stops after n values.

Limit2 returns an iterator over seq that stops after n key-value pairs.

LimitAfter is like [LimitUntil] but also yields the first value dissatisfying f(v).

LimitAfter2 is like [LimitUntil2] but also yields the first pair dissatisfying f(k, v).

LimitUntil returns an iterator over seq that yields until f returns false.

LimitUntil2 returns an iterator over seq that yields until f returns false.

MapKeys returns an iterator over pairs of keys and values retrieved from a map using the keys.

MapSorted returns an iterator over key-value pairs from m.

MapSorted is like [MapSorted] but uses comparison function f to sort keys.

Max returns the maximum value of seq.

MaxFunc returns the maximum value of seq using comparison function fn.

MergeSort implements merge sort algorithm.

MergeSortFunc is like [MergeSort] but uses comparison function.

MergeSortSliceLike is like [MergeSort] that uses [SliceLike] interface instead of []T.

MergeSortSliceLikeFunc is like [MergeSortSliceLike] but uses comparison function instead.

Min returns the minimum value of seq.

MinFunc returns the minimum value of seq using comparison function fn.

Nexter returns an iterator over Nexter implementation, e.g.

Nth returns the nth element from seq by yielding up to n+1 elements.

Nth2 returns the nth pair from seq by yielding up to n+1 pairs.

Omit returns an iterator over seq but drops data seq yields.

Omit2 returns an iterator over seq but drops data seq yields.

OmitF drops former part of key-value pairs that seq generates.

OmitL drops latter part of key-value pairs that seq generates.

Once adapts a single value as an iterator; the iterator yields v and stops.

Once2 adapts a single k-v pair as an iterator; the iterator yields k, v and stops.

Pairs combines seq1 and seq2 into an iterator over key-value pairs.

Permutations returns an iterator that yields permutations of in.

Range returns an iterator over sequential Numeric values in the half-open interval [start, end).

RangeInclusive is like [Range] but also allows control over inclusiveness.

ReduceGroup sums up values from seq for every unique keys separately, then collects pairs of key and converted value into a new map and returns it.

Repeat returns an iterator over v repeated n times.

Repeat2 returns an iterator over the pair of k and v repeated n times.

RepeatFunc returns an iterator that generates result from fnV n times.

RepeatFunc2 returns an iterator that generates result of fnK and fnV n times.

Replace is [ReplaceFunc] where matcher f tests if k equals old.

Replace2 is [ReplaceFunc2] where matcher f tests if k-v pair equals pair of oldK, oldV.

ReplaceFunc returns an iterator over seq but the first n values that matches f is replaced with new.

ReplaceFunc2 returns an iterator over seq but the first n key-value pairs that matches f is replaced with new.

RunningReduce returns an iterator over every intermediate reducer results.

Skip returns an iterator over seq that skips n elements from seq.

Skip2 returns an iterator over seq that skips n key-value pairs from seq.

SkipLast returns an iterator over seq that skips last n elements of seq.

SkipLast2 returns an iterator over seq that skips last n key-value pairs of seq.

SkipWhile returns an iterator over seq that skips elements until f returns false.

SkipWhile2 returns an iterator over seq that skips key-value pairs until f returns false.

Step returns an iterator over numerics values starting from initial and added step at each step.

StepBy returns an iterator over pair of index and value associated the index.

Tap returns an iterator over seq without any modification to values from seq.

Tap2 returns an iterator over seq without any modification to pairs from seq.

TapLast returns an iterator over values from seq.

TapLast2 returns an iterator over key-value pairs from seq.

ToKeyValue converts [iter.Seq2][K, V] into iter.Seq[KeyValue[K, V]].

Transpose returns an iterator over seq that yields K and V reversed.

TryAppendSeq is like [slices.AppendSeq] but stops collecting at the first error and returns the extended result before the error.

TryCollect is like [slices.Collect] but stops collecting at the first error and returns the extended result before the error.

TryFind is like [FindFunc] but stops if seq yields non-nil error.

TryForEach is like [ForEach] but returns an error if seq yields non-nil error.

TryReduce is like [xiter.Reduce] but returns an error if seq yields non-nil error.

Unify unifies key-value pairs from seq into single values by applying fn to convert [iter.Seq2][K, V] to [iter.Seq][U].

Unique is [UniqueFunc] where the value itself is an identifier.

Unique2 is [UniqueFunc2] where the key-value pair itself is an identifier.

UniqueFunc returns an iterator over every unique values from seq.

UniqueFunc2 returns an iterator over every unique key-value pairs from seq.

Values2 returns an iterator that yields the KeyValue slice elements in order.

Window returns an iterator over overlapping sub-slices of n size (moving windows).

WindowSeq allocates n sized buffer and fills it with values from seq in FIFO-manner.

WithGroupId returns an iterator over pair of unique index for the group id and value from seq.

WrapSeqIterable wraps seq into SeqIterable[V].

WrapSeqIterable2 wraps seq into SeqIterable2[V].

IntoIterable wraps basic IntoIter2 method.

IntoIterable2 wraps basic IntoIter2 method.

Iterable wraps basic Iter method.

Iterable2 wraps basic Iter2 method.

as per https://go.dev/ref/spec#arithmetic_operators.

KeyValues adds the Iter2 method to slice of KeyValue-s.