std/iter

True when arr carries no elements.

True when it yields nothing. Pulls one element at most, with no peek: a false result has consumed the first one.

How many elements arr holds: its length, O(1).

Drain it, returning how many elements it yielded: O(n).

The last element of arr, or null when it is empty: O(1).

Drain it, returning its last element, or null when it yields none.

Drain it into a fresh array. Pair with the lazy combinators (it.filter(p).map(f).collect()) when a snapshot is required ; for x in it consumes directly without the intermediate array.

Left-fold the iterator with seed init. f(acc, x) is called for every element in order ; the final accumulator is returned. A raw array coerces to Iterator<T> at the call site (arr.fold(0, add) / fold(arr, 0, add)).

Sum the elements of an iterator (an array auto-coerces at the call site).

Multiply the elements of an iterator (an array auto-coerces at the call site).

Fresh copy of arr. The returned array is independent: mutating it does not affect arr.

Use this to modify what a frozen value holds (a module constant, a view of a string's bytes), or to break aliasing between a slice view and its parent.

Naming overlaps with the Clone trait in std/core (currently without implementors). When T[] implements Clone lands, this free fn becomes the impl: arr.clone() resolves identically either way.

Lazily pair elements of self and other into tuples, stopping at the shorter of the two. Mirrors Python zip ; useful for stepping parallel arrays in lockstep (e.g. keys + values from a map). Both inputs stay T[]/ U[]: the lockstep pull needs indexed access, so unlike the source-driven combinators zip does not take a lazy Iterator. for [x, y] in zip(a, b) destructures each pair ; consumed directly it fuses to a single index loop.

Slide a fixed-size window over self, yielding each run of size consecutive elements. Step 1, no partial windows: a source shorter than size yields nothing. Mirrors Kotlin's windowed(size). Like zip, takes T[] (not a lazy Iterator) because the overlapping pull needs indexed access.

Each window is a zero-copy VIEW aliasing self (the built-in arr[lo..<hi] slice): cheap, but a later mutation of self shows through ; .clone() a window to detach it.

Lazily yield every element of self, then every element of other: a concatenated stream. Fuses to two back-to-back source loops (no intermediate array) when consumed by a for loop or a terminal.

Lazily pair each element with its index, starting at 0: the element first, so for [x, i] in it.indexed() { … } reads in the order it is yielded. A 0-arg combinator: fuses over the source with no intermediate array.

Split self into consecutive runs of size elements ; the last run holds what remains and may be shorter. Mirrors Kotlin's chunked(size).

Unlike window, each chunk is a FRESH array, not a view: the source is a lazy Iterator, so there is nothing to alias.

Lazily yield each element of self the first time it occurs, in order of first occurrence. Mirrors Kotlin's distinct().

Remembers every element seen so far, so memory grows with the number of DISTINCT elements, not with the length of the stream.

Lazily yield the non-null elements of self, typed without the null. Mirrors Kotlin's filterNotNull().

Apply f to each element and yield the elements of every resulting array in order. Useful when one input expands to zero-or-more outputs (parsing, tree flattening).

true as soon as any element satisfies pred ; false if none do. Short-circuits: pred is not invoked past the first match.

true only when every element satisfies pred. Short-circuits on the first false. Returns true on an empty source (vacuous truth).

First element matching pred, or null if none does. Short-circuits. Consumers narrow naturally : match hit :: arr.find(p) { is T -> … }.

Apply f to each element ; return the first non-null result. Combines the transform and the search in one pass: useful for parsing chains where the mapper itself decides whether an element qualifies.

Fluent lazy filter. Distinct from the eager T[]-overload above: the resolver picks this one when the receiver implements Iterator<T> (Range, an array iterator, MutableMap, …).

Fluent lazy map. Mirror of filter for transforms ; element type can change (T → U).

Fluent lazy take. Yields the first n items from self, then ends: pulling exactly n items from self, none for take(0).

Fluent lazy skip. Drops the first n items from self, then forwards every subsequent item.