Rust Iterator Cheat Sheet

Last updated: Rust 1.17.0, Itertools 0.6.0.

To-do:

Improve formatting.
Try to fix display bugs (lines through cells).
Add sorting... somehow

How you can help:

I need feedback on what does and doesn't work. Can you understand the summaries? Do they mesh with how you perceive the methods in question work? What other information could/should be included?

If you have any corrections or suggestions, you can file them on the GitHub repository. The canonical source for this page is src/itercheat/itercheat.html.

Jump to: Generators, Sequences, Free-Standing Sequences, Values, Other, Notes.

This summarises the iterator-related methods defined by the following Rust libraries:

Std: the Rust standard library. Methods are defined on the std::iter::Iterator trait.
IT: the itertools library. Methods are defined on the itertools::Itertools trait.

Additional filtering options:

Unstable: show unstable methods.

This is intended to be used in one of a few ways:

You know what an iterator method is called, but you want a quick summary of what it does.
You know what you want to do with an iterator, but not what it's called.
You just want to browse through a summary of the available methods because you're bored.

To keep the summary as compact as possible, various bits of notation and convention are used. An incomplete list is:

Most iterator methods take their first input by-value; those that don't are marked with a $\text{&mut}$ out the front of their first argument.
Elements are underlined to indicate that the method will not compute those elements during the course of its own evaluation.
$\{\ldots\}$ is used to represent a lazily computed sequence; i.e. an iterator.
$\{\ldots\}:\{T\}$ indicates an iterator where each element is of type T.
$a$ and $b$ are used as input sequences (with subscripted letters denoting individual elements).
$c$ is used to represent the output sequence in cases where there is no direct mapping of input elements to output elements.
$i$ , $j$ , and $k$ are used to denote specific, but arbitrary, points within sequences.
$n$ , $m$ , and $l$ are used to denote the length of different sequences.
$[\ldots]$ is used to represent a collection of arbitrary type. Typically, the exact type is inferred from context, and can be anything that implements the FromIterator trait.
$f$ is a function which transforms elements.
$p$ is a predicate which determines some logical property of elements.
$\circ$ is an arbitrary binary function.
$\langle \ldots\rangle$ is used to indicate a generic type argument contains relevant information.
$\text{wh.}$ is an abbreviation for "where".

Generators

Lib	Function	Input		Output
Std	$\text{empty}$			$\{\}$
IT	$\text{iterate}$	$x : T$	$f : \text{&}T \rightarrow T$	$\{x, f(x), f(f(x)), \ldots\}$
Std	$\text{once}$	$a$		$\{a\}$
Std	$\text{repeat}$	$a$		$\{a, a, \ldots\}$
IT	$\text{repeat_call}$	$f: () \rightarrow T$		$\{f(), f(), \ldots\}$
IT	$\text{repeat_n}$	$a$ ,	$n$	$\{\underbrace{a, a, \ldots, a}_{n}\}$
IT	$\text{unfold}$	$s:S$ ,	$f: \text{&mut } S \rightarrow \text{Some}(T) ~\|~ \text{None}$	$\{c_0, \ldots, c_{l-1}\} \text{ wh.} \\~~ \text{Some}(c_0) = f(\text{&mut } s), \\~~ \ldots, \\~~ \text{Some}(c_{l-1}) = f(\text{&mut } s), \\~~ \text{None} = f(\text{&mut } s)$

Sequences

Lib	Method	Input		Output
IT	$\text{batching}$	$\{\underbrace{a_0, \ldots}, \underbrace{a_i,\ldots}, \ldots\}:\{T\}$ ,	$batch : \text{&mut }\{T\} \rightarrow U$	$\{\underbrace{c_0}_{batch(\{a_0, \ldots\})}, \underbrace{c_1}_{batch(\{a_i, \ldots\})}, \ldots\}:\{U\}$
IT	$\text{cartesian_product}$	$\{a_0, a_1, \ldots, a_{n-1}\}$ ,	$\{b_0, b_1, \ldots, b_{m-1}\}$	$\{(a_0, b_0), (a_0, b_1), \ldots, (a_0, b_{m-1}),\\~~ (a_1, b_0), (a_1, b_1), \ldots, (a_1, b_{m-1})\\~~ \ldots,\\~~ (a_{n-1}, b_0), (a_{n-1}, b_1), \ldots, (a_{n-1}, b_{m-1})\}$
Std	$\text{chain}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$\{a_0, \ldots, a_{n-1}, b_0, \ldots, b_{m-1}\}$
IT	$\text{chunks}$	$\{a_0, \ldots\}$ ,	$m$	$\{ \{a_0, \ldots, a_{m-1}\}, \{a_m, \ldots, a_{2m-1}\}, \ldots \}$
Std	$\text{cmp}$	$\{a_0, \ldots, a_{i}\}$ ,	$\{b_0, \ldots, b_{i}, b_{i+1}, \underline{\ldots}\}$	$\text{cmp}(a_0, b_0) \text{ then } \ldots \text{ then } \text{cmp}(a_i, b_i) \text{ then } \text{Less}$
		$\{a_0, \ldots, a_{i}\}$ ,	$\{b_0, \ldots, b_{i}\}$	$\text{cmp}(a_0, b_0) \text{ then } \ldots \text{ then } \text{cmp}(a_i, b_i) \text{ then } \text{Equal}$
		$\{a_0, \ldots, a_{i}, a_{i+1}, \underline{\ldots}\}$ ,	$\{b_0, \ldots, b_{i}\}$	$\text{cmp}(a_0, b_0) \text{ then } \ldots \text{ then } \text{cmp}(a_i, b_i) \text{ then } \text{Greater}$
IT	$\text{coalesce}$	$\{a_0, a_1, a_2, \ldots\}$	$f : (T,T) \rightarrow \text{Ok}(T) ~\|~ \text{Err}((T, T))$	$\begin{array}{llcl} & \{x_0, \ldots\} &\text{wh.}& \left\{\begin{array}{l} f(a_0, a_1) = \text{Ok}(x_0), \\ \ldots \end{array}\right. \\ \text{or} & \{a'_0, x_1, \ldots\} &\text{wh.}& \left\{\begin{array}{l} f(a_0, a_1) = \text{Err}((a'_0, a'_1)), \\ f(a'_1, a_2) = \text{Ok}(x_1), \\ \ldots \end{array}\right. \\ \text{or} & \{a'_0, a''_1, \ldots\} &\text{wh.}& \left\{\begin{array}{l} f(a_0, a_1) = \text{Err}((a'_0, a'_1)), \\ f(a'_1, a_2) = \text{Err}(a''_1, a'_2), \\ \ldots \end{array}\right. \end{array}$
Std	$\text{collect}$	$\{a_0, \ldots\}$		$[a_0, \ldots]$
IT	$\text{collect_vec}$	$\{a_0, \ldots\}$		$[a_0, \ldots] : \text{Vec}\langle T\rangle$
Std	$\text{cycle}$	$\{a_0, \ldots, a_{n-1}\}$		$\{a_0, \ldots, a_{n-1}, a_0, \ldots, a_{n-1}, \ldots\}$
IT	$\text{dedup}$	$\{\underbrace{a_0, a_0, \ldots}, \underbrace{a_1, a_1, \ldots}, \ldots\}$		$\{a_0, a_1, \ldots\}$
IT	$\text{dropping}$	$\{\underbrace{a_0, \ldots, a_{i-1}}_{\text{consumed}}, a_i, \ldots\}$	$i \text{ wh. } i \lt n$	$\{a_i, \ldots\}$ (consumes $a_0 \ldots a_{i-1}$ immediately)
IT	$\text{dropping}$	$\{\underbrace{a_0, \ldots, a_{n-1}}_{\text{consumed}}\}$	$i \text{ wh. } i \ge n$	$\{\}$ (consumes $a_0 \ldots a_{n-1}$ immediately)
IT	$\text{dropping_back}$	$\{a_0, \ldots, a_{n-i-1}, \underbrace{a_{n-i}, \ldots, a_{n-1}}_{\text{consumed}}\}$	$i \text{ wh. } i \lt n$	$\{a_0, \ldots, a_{n-i-1}\}$ (consumes $a_{n-i} \ldots a_n$ immediately)
IT	$\text{dropping_back}$	$\{\underbrace{a_0, \ldots, a_{n-1}}_{\text{consumed}}\}$	$i \text{ wh. } i \ge n$	$\{\}$ (consumes $a_0 \ldots a_n$ immediately)
Std	$\text{enumerate}$	$\{a_0, a_1, \ldots\}$		$\{(0, a_0), (1, a_1), \ldots\}$
Std	$\text{eq}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$\text{false} \text{ wh. } n \neq m$
Std	$\text{eq}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$(a_0 = b_0) \land \ldots \land (a_{n-1} = b_{n-1})$
Std	$\text{filter}$	$\{a_0, a_1, \ldots\}$ ,	$p : \text{&}T \rightarrow \text{bool}$	$\{a_i \text{ for all } i \text{ wh. } p(\text{&}a_i)\}$
Std	$\text{filter_map}$	$\{a_0, a_1, \ldots\}$ ,	$f : T \rightarrow \text{Some}(U) ~\|~ \text{None}$	$\{x_i \text{ for all } i \text { where } f(a_i) = \text{Some}(x_i)\}$
Std	$\text{flat_map}$	$\{a_0, a_1, \ldots\}$ ,	$f : T \rightarrow \{U\}$	$\{\underbrace{x_0, x_1, \ldots}_{x = f(a_0)}, \underbrace{y_0, y_1, \ldots}_{y = f(a_1)}, \ldots\}$
IT	$\text{flatten}$	$\{\{a_0, \ldots\}, \{b_0, \ldots\}, \ldots\}$ ,		$\{a_0, \ldots, b_0, \ldots\}$
Std	$\text{ge}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$\text{false} \text{ wh. } n < m$
Std	$\text{ge}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$(a_0 \geq b_0) \land \ldots \land (a_{n-1} \geq b_{n-1})$
IT	$\text{group_by}$	$\{\underbrace{a_0, \ldots, a_{i-1}}_{g(a_x) = g_0}, \underbrace{a_i, \ldots, a_{j-1}}_{g(a_y) = g_1 \ne g_0}, \underbrace{a_j, \ldots, a_{k-1}}_{g(a_z) = g_2 \ne g_1}, \ldots\}$ ,	$g : \text{&}T \rightarrow G$	$\{ (g_0, \{a_0, \ldots, a_{i-1}\}),\\~~ (g_1, \{a_i, \ldots, a_{j-1}\}),\\~~ (g_2, \{a_j, \ldots, a_{k-1}\}), \ldots \}$
Std	$\text{gt}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$\text{false} \text{ wh. } n < m$
Std	$\text{gt}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$(a_0 > b_0) \land \ldots \land (a_{n-1} > b_{n-1})$
IT	$\text{interleave}$	$\{a_0, a_1, \ldots, a_{i-1}, a_i, \ldots\}$ ,	$\{b_0, b_1, \ldots, b_{i-1}\}$	$\{a_0, b_0, a_1, b_1, \ldots, a_{i-1}, b_{i-1}, a_i, \ldots\}$
		$\{a_0, a_1, \ldots, a_{i-1}\}$ ,	$\{b_0, b_1, \ldots, b_{i-1}\}$	$\{a_0, b_0, a_1, b_1, \ldots, a_{i-1}, b_{i-1}\}$
		$\{a_0, a_1, \ldots, a_{i-1}\}$ ,	$\{b_0, b_1, \ldots, b_{i-1}, b_i, \ldots\}$	$\{a_0, b_0, a_1, b_1, \ldots, a_{i-1}, b_{i-1}, b_i, \ldots\}$
IT	$\text{interleave_shortest}$	$\{a_0, a_1, \ldots, a_{i-1}, a_i, \underline{\ldots}\}$ ,	$\{b_0, b_1, \ldots, b_{i-1}\}$	$\{a_0, b_0, a_1, b_1, \ldots, a_{i-1}, b_{i-1}, a_i\}$
IT	$\text{interleave_shortest}$	$\{a_0, a_1, \ldots, a_{i-1}\}$	$\{b_0, b_1, \ldots, b_{i-1}, \underline{b_i, \ldots}\}$	$\{a_0, b_0, a_1, b_1, \ldots, a_{i-1}, b_{i-1}\}$
IT	$\text{intersperse}$	$\{a_0, a_1, \ldots, a_{n-1}\}$	$b$	$\{a_0, b, a_1, b, \ldots, b, a_{n-1}\}$
IT	$\text{kmerge}$	$\{ \{a_0, \ldots\}, \{b_0, \ldots\}, \ldots \} \text{ wh.} \\~~ \text{sorted}(a), \text{ sorted}(b), \ldots$		$\{ c_0, c_1, \ldots \} \text{ wh. } c_0 \le c_1 \le \ldots, \\~~ a \subseteq c, b \subseteq c, \ldots$
IT	$\text{kmerge_by}$	$\{ \{a_0, \ldots\}, \{b_0, \ldots\}, \ldots \} \text{ wh.} \\~~ \text{sorted_by}(a, {}\circ{}), \text{ sorted_by}(b, {}\circ{}), \ldots$ ,	${}\circ{} : (\text{&}T,\text{&}T) \rightarrow \text{bool}$	$\{ c_0, c_1, \ldots \} \text{ wh. } c_0 \circ c_1 \circ \ldots, \\~~ a \subseteq c, b \subseteq c, \ldots$
Std	$\text{map}$	$\{a_0, a_1, \ldots\}$ ,	$f : T \rightarrow U$	$\{f(a_0), f(a_1), \ldots\}$
IT	$\text{map_fn}$	$\{a_0, a_1, \ldots\}$ ,	$f : \text{fn}(T) \rightarrow U$	$\{f(a_0), f(a_1), \ldots\}$
IT	$\text{map_results}$	$\{a_0, \ldots\} : \{\text{Ok}(T) ~\|~ \text{Err}(E)\}$ ,	$f : (T) \rightarrow U$	$\{ a_0.\text{map}(f), \ldots \} : \{\text{Ok}(U) ~\|~ \text{Err}(E)\}$
IT	$\text{merge}$	$\{a_0, a_1, \ldots\} \text{ wh. } a_0 \le a_1 \le \ldots$ ,	$\{b_0, b_1, \ldots\} \text{ wh. } b_0 \le b_1 \le \ldots$	$\{c_0, c_1, \ldots\} \text{ wh. } c_0 \le c_1 \le \ldots, a \subseteq c, b \subseteq c$
IT	$\text{merge_by}$	$\{a_0, a_1, \ldots\} \text{ wh. } a_0 \circ a_1 \circ \ldots$ ,	$\{b_0, b_1, \ldots\} \text{ wh. } b_0 \circ b_1 \circ \ldots$ , ${}\circ{} : (\text{&}T,\text{&}T) \rightarrow \text{Ordering}$	$\{c_0, c_1, \ldots\} \text{ wh. } c_0 \circ c_1 \circ \ldots, a \subseteq c, b \subseteq c$
IT	$\text{pad_using}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$m$ , $~~$ $f : i \rightarrow T$	$\{a_0, \ldots, a_{n-1}\} \text{ wh. } n >= m \\ \{a_0, \ldots, a_{n-1}, f(n), \ldots, f(m-1)\} \text{ otherwise}$
Std	$\text{partial_cmp}$	$\{a_0, \ldots, a_{i}\}$ ,	$\{b_0, \ldots, b_{i}, b_{i+1}, \underline{\ldots}\}$	$\text{pcmp}(a_0, b_0) \text{ then } \ldots \text{ then } \text{pcmp}(a_i, b_i) \text{ then } \text{Less}$
		$\{a_0, \ldots, a_{i}\}$ ,	$\{b_0, \ldots, b_{i}\}$	$\text{pcmp}(a_0, b_0) \text{ then } \ldots \text{ then } \text{pcmp}(a_i, b_i) \text{ then } \text{Equal}$
		$\{a_0, \ldots, a_{i}, a_{i+1}, \underline{\ldots}\}$ ,	$\{b_0, \ldots, b_{i}\}$	$\text{pcmp}(a_0, b_0) \text{ then } \ldots \text{ then } \text{pcmp}(a_i, b_i) \text{ then } \text{Greater}$
Std	$\text{partition}$	$\{a_0, a_1, \ldots\}$ ,	$f: \text{&}T \rightarrow \text{bool}$	$([a_i \text{ for all } i \text{ wh. } f(\text{&}a_i) = \text{true}], \\~~ [a_i \text{ for all } i \text{ wh. } f(\text{&}a_i) = \text{false}])$
IT	$\text{partition_map}$	$\{a_0, a_1, \ldots\}$ ,	$f: T \rightarrow \text{Left}(L) ~\|~ \text{Right}(R)$	$([x_i \text{ for all } i \text{ wh. } f(a_i) = \text{Left}(x_i)], \\~~ [x_i \text{ for all } i \text{ wh. } f(a_i) = \text{Right}(x_i)])$
Std	$\text{rev}$	$\{a_0, a_1, \ldots, a_{n-2}, a_{n-1}\}$		$\{a_{n-1}, a_{n-2}, \ldots, a_1, a_0\}$
Std	$\text{scan}$	$\{a_0, a_1, \ldots\}$ ,	$s : \text{&mut }S$ , $f : (\text{&mut }S, T) \rightarrow \text{Some}(U) ~\|~ \text{None}$	$\{x_i \text{ for all } i \text{ wh. } f(s, a_i) = Some(x_i)\}$
Std	$\text{skip}$	$\{a_0, \ldots, a_{i-1}, a_{i}, \ldots\}$ ,	$i$	$\{a_{i}, \ldots\}$
Std	$\text{skip}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$i \text{ wh. } i \ge n$	$\{\}$
Std	$\text{skip_while}$	$\{a_0, \ldots, a_i, \ldots\}$ ,	$p : \text{&}T \rightarrow \text{bool}$	$\{a_i, \ldots\} \text{ wh. } i \text{ is first wh. } p(\text{&}a_i)$
IT	$\text{sorted}$	$\{a_0, \ldots\}$		$[c_0, \ldots] : \text{Vec}\langle T\rangle \text { wh. } c_0 \leq c_1 \leq \ldots$
IT	$\text{sorted_by}$	$\{a_0, \ldots\}$	${}\circ{} : (\text{&}T,\text{&}T) \rightarrow \text{Ordering}$	$[c_0, \ldots] : \text{Vec}\langle T\rangle \text { wh. } c_0 \circ c_1 \circ \ldots$
IT	$\text{step}$	$\{a_0, \ldots, a_m, \ldots, a_{2m}, \ldots\}$ ,	m	$\{a_0, a_m, a_{2m}, \ldots\}$
Std	$\text{take}$	$\{a_0, \ldots, a_{i-1}, \underline{a_{i}, \ldots}\}$ ,	$i$	$\{a_0, \ldots, a_{i-1}\}$
Std	$\text{take}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$i \text{ wh. } i \ge n$	$\{a_0, \ldots, a_{n-1}\}$
Std	$\text{take_while}$	$\{a_0, \ldots, a_{i-1}, a_i, \underline{\ldots}\}$ ,	$p : \text{&}T \rightarrow \text{bool}$	$\{a_0, \ldots, a_{i-1}\} \text{ wh. } i \text{ is first wh. } p(\text{&}a_i) = \text{false}$
IT	$\text{take_while_ref}$	$\text{&mut }\{a_0, \ldots, a_{i-1}, \underline{a_i, \ldots}\}$ ,	$p : \text{&}T \rightarrow \text{bool}$	$\{a_0, \ldots, a_{i-1}\} \text{ wh. } i \text{ is first wh. } p(\text{&}a_i) = \text{false}$
IT	$\text{tee}$	$\{a_0, a_1, \ldots\}$		$(\{a_0, a_1, \ldots\}, \{a_0, a_1, \ldots\})$
IT	$\text{tuple_windows}$	$\{a_0, \ldots\}$	$\langle (\underbrace{\_, \_, \ldots}_{n})\rangle$	$\{ (a_0, \ldots, a_{n-1}), (a_1, \ldots, a_{n}), \ldots \}$
IT	$\text{tuples}$	$\{a_0, \ldots\}$	$\langle (\underbrace{\_, \_, \ldots}_{n})\rangle$	$\{ (a_0, \ldots, a_{n-1}), (a_{n}, \ldots, a_{2n-1}), \ldots \}$
IT	$\text{unique}$	$\{a_0, \ldots\}$		$\{ a_i \text{ for all } i \text{ wh. } a_i \notin \{a_0, \ldots, a_{i-1}\} \}$
IT	$\text{unique_by}$	$\{a_0, \ldots\}$ ,	$f : \text{&}T \rightarrow U$	$\{ a_i \text{ for all } i \text{ wh. } f(a_i) \notin \{f(a_0), \ldots, f(a_{i-1})\} \}$
Std	$\text{unzip}$	$\{(a_0, b_0), (a_1, b_1), \ldots\}$		$([a_0, a_1, \ldots], [b_0, b_1, \ldots])$
IT	$\text{while_some}$	$\{a_0, \ldots, a_{i-1}, a_i, \underline{\ldots}\}$ ,		$\begin{array}{ll} \{x_j \text{ for all } j < i \text{ wh. } a_j = Some(x_j)\} \\ \text{ wh. } i \text{ is the first wh. } a_i = \text{None} \\ \end{array}$
IT	$\text{with_position}$	$\{a_0\}$		$\{\text{Only}(a_0)\}$
IT	$\text{with_position}$	$\{a_0, a_1, \ldots, a_{n-2}, a_{n-1}\}$		$\{ \text{First}(a_0), \text{Middle}(a_1), \ldots, \\~~ \text{Middle}(a_{n-2}), \text{Last}(a_{n-1}) \}$
Std	$\text{zip}$	$\{a_0, \ldots, a_i\}$ ,	$\{b_0, \ldots, b_i, \underline{b_{i+1}, \ldots}\}$	$\{(a_0, b_0), \ldots, (a_i, b_i)\}$
Std	$\text{zip}$	$\{a_0, \ldots, a_i, a_{i+1}, \underline{\ldots}\}$ ,	$\{b_0, \ldots, b_i\}$	$\{(a_0, b_0), \ldots, (a_i, b_i)\}$
IT	$\text{zip_eq}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$\{(a_0, b_0), \ldots, (a_{n-1}, b_{n-1})\}, \\~~ \text{panic wh. } n \neq m$
IT	$\text{zip_longest}$	$\{a_0, \ldots, a_{i-1}, a_i, \ldots\}$ ,	$\{b_0, \ldots, b_{i-1}\}$	$\{\text{Both}(a_0, b_0), \ldots, \text{Both}(a_{i-1}, b_{i-1}), \text{Left}(a_i), \ldots\}$
		$\{a_0, \ldots, a_{i-1}\}$ ,	$\{b_0, \ldots, b_{i-1}\}$	$\{\text{Both}(a_0, b_0), \ldots, \text{Both}(a_{i-1}, b_{i-1})\}$
		$\{a_0, \ldots, a_{i-1}\}$ ,	$\{b_0, \ldots, b_{i-1}, b_i, \ldots\}$	$\{\text{Both}(a_0, b_0), \ldots, \text{Both}(a_{i-1}, b_{i-1}), \text{Right}(b_i), \ldots\}$

Free-Standing Sequences

Note: these adaptors are only available as free-standing functions, not as methods on Iterators.

Lib	Function	Input	Output
IT	$\text{cons_tuples}$	$\{ ((a^0_0, a^1_0, \ldots), a^n_0), ((a^0_1, a^1_1, \ldots), a^n_1), \ldots \}$	$\{ (a^0_0, a^1_0, \ldots, a^n_0), (a^0_1, a^1_1, \ldots, a^n_1), \ldots \}$
IT	$\text{iproduct!}$	$\{a_0, a_1, \ldots\}$ , $\{b_0, b_1, \ldots\}$ , $\ldots$	$\{ (a_0, b_0, \ldots), \ldots, (a_0, b_1, \ldots), \ldots, \\~~ (a_1, b_0, \ldots), \ldots, (a_1, b_1, \ldots), \ldots \}$
IT	$\text{izip!}$	$\{a_0, a_1, \ldots\}$ , $\{b_0, b_1, \ldots\}$ , $\ldots$	$\{(a_0, b_0, \ldots), (a_1, b_1, \ldots), \ldots\}$

Values

Lib	Method	Input		Output
Std	$\text{all}$	$\text{&mut }\{a_0, \ldots, a_{i-1}, a_i, \underline{\ldots}\}$	$p:T \rightarrow \text{bool}$	$p(a_0) \land \ldots \land p(a_{i-1}) \text{ wh. } i \text{ is first wh. } p(a_i) = \text{false}$
Std	$\text{all}$	$\text{&mut }\{\}$	$p:T \rightarrow \text{bool}$	$\text{true}$
Std	$\text{all_equal}$	$\text{&mut }\{a_0, \ldots, a_{i-1}, a_i, \underline{\ldots}\}$		$(a_0 = a_1) \land \ldots \land (a_{i-1} = a_{i}) \text{ wh. } i \text{ is first wh. } a_{i-1} \neq a_i$
		$\text{&mut }\{a_0\}$		$\text{true}$
		$\text{&mut }\{\}$		$\text{true}$
Std	$\text{any}$	$\text{&mut }\{a_0, \ldots, a_{i-1}, a_i, \underline{\ldots}\}$	$p:T \rightarrow \text{bool}$	$p(a_0) \lor \ldots \lor p(a_{i-1}) \text{ wh. } i \text{ is first wh. } p(a_i)$
Std	$\text{any}$	$\text{&mut }\{\}$	$p:T \rightarrow \text{bool}$	$\text{false}$
Std	$\text{count}$	$\{\underbrace{\ldots}_{n}\}$		$n$
Std	$\text{find}$	$\text{&mut }\{a_0, \ldots, a_i, \underline{\ldots}\}$ ,	$p : T \rightarrow \text{bool}$	$\begin{array}{ll} \text{Some}(a_i) &\text{wh. } i \text{ is first wh. } p(\text{&}a_i) \\ \text{None} & \text{otherwise} \end{array}$
IT	$\text{find_position}$	$\text{&mut }\{a_0, \ldots, a_i, \underline{\ldots}\}$ ,	$p : T \rightarrow \text{bool}$	$\begin{array}{ll} \text{Some}((i, a_i)) &\text{wh. } i \text{ is first wh. } p(\text{&}a_i) \\ \text{None} & \text{otherwise} \end{array}$
Std	$\text{fold}$	$\{a_0, a_1, \ldots\}$ ,	$init : U$ , $\circ : (U,T) \rightarrow U$	$(((init \circ a_0) \circ a_1) \circ \ldots)$
Std	$\text{fold}$	$\{\}$	$init : U$ , $\circ : (U,T) \rightarrow U$	$init$
IT	$\text{fold1}$	$\{a_0, a_1, a_2, \ldots\}$ ,	$\circ : (T,T) \rightarrow T$	$\text{Some}(((a_0 \circ a_1) \circ a_2) \circ \ldots)$
		$\{a_0\}$		$\text{Some}(a_0)$
		$\{\}$		$\text{None}$
IT	$\text{fold_options}$	$\text{&mut }\{a_0, \ldots\}$ ,	$start : U$ , $\circ : (U,T) \rightarrow U$	$\text{Some}(\text{fold}(x, \circ)) \text{ wh. } x = \{x_i \text{ wh. all } a_i = \text{Some}(x_i)\}$
		$\text{&mut }\{\ldots, a_i, \underline{\ldots}\} \text{ wh. } a_i = \text{None}$ ,		$\text{None} \text{ wh. } i \text{ is first wh. } a_i = \text{None}$
		$\text{&mut }\{\}$		$\text{Some}(start)$
IT	$\text{fold_results}$	$\text{&mut }\{a_0, \ldots\}$ ,	$start : U$ , $\circ : (U,T) \rightarrow U$	$\text{Ok}(\text{fold}(x, \circ)) \text{ wh. } x = \{x_i \text{ wh. all } a_i = \text{Ok}(x_i)\}$
		$\text{&mut }\{\ldots, a_i, \underline{\ldots}\} \text{ wh. } a_i = \text{Err}(..)$ ,		$\text{Err}(e) \text{ wh. } i \text{ is first wh. } a_i = \text{Err}(e)$
		$\text{&mut }\{\}$		$\text{Ok}(start)$
IT	$\text{fold_while}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$init : U$ , $\circ : (U,T) \rightarrow \text{Continue}(U) ~\|~ \text{Done}(U)$ ,	$((init \circ x_0) \circ \ldots) \circ x_{n-1} \text{ wh. } a_j = \text{Continue}(x_j)$
		$\{a_0, \ldots, a_{j}, \underline{\ldots}\}$ ,		$((init \circ x_0) \circ \ldots) \circ x_{i} \text{ wh. } \\~~ a_i = \text{Done}(x_i), \\~~ a_j = \text{Continue}(x_j) \text{ for all } j < i$
		$\{\}$		$init$
IT	$\text{join}$	$\{a_0, a_1, \ldots, a_{n-1}\}$ ,	$sep: \text{&str}$	$\begin{array}{ll} d(a_0) \circ sep \circ d(a_1) \circ \ldots \circ sep \circ d(a_{n-1}) \text { wh.}\\~~ d \text{ is Display::fmt, } \circ \text{ is string concatenation} \\ \end{array}$
Std	$\text{last}$	$\{\ldots, a_{n-1}\}$		$\text{Some}(a_{n-1})$
Std	$\text{last}$	$\{\}$		$\text{None}$
Std	$\text{le}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$\text{false} \text{ wh. } n > m$
Std	$\text{le}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$(a_0 \leq b_0) \land \ldots \land (a_{n-1} \leq b_{n-1})$
Std	$\text{lt}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$\text{false} \text{ wh. } n > m$
Std	$\text{lt}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$	$(a_0 < b_0) \land \ldots \land (a_{n-1} < b_{n-1})$
Std	$\text{max}$	$\{a_0, a_1, a_2, \ldots\}$		$\text{Some}(max(max(max(a_0, a_1), a_2), \ldots))$
		$\{a_0\}$		$\text{Some}(a_0)$
		$\{\}$		$\text{None}$
Std	$\text{max_by}$	$\{a_0, \ldots\}$	${}\circ{} : (\text{&}T, \text{&}T) \rightarrow \text{Ordering}$	$\text{Some}(a_j) \text{ wh. } \ldots \circ a_i \circ a_j$
		$\{a_0\}$		$\text{Some}(a_0)$
		$\{\}$		$\text{None}$
Std	$\text{max_by_key}$	$\{a_0, \ldots\}$	$f : \text{&}T \rightarrow B$	$\text{Some}(a_i) \text{ wh.}\\~~ b = max(\{f(a_0), \ldots\}), i \text{ is the last wh. } f(a_i) = b$
		$\{a_0\}$		$\text{Some}(a_0)$
		$\{\}$		$\text{None}$
Std	$\text{min}$	$\{a_0, a_1, a_2, \ldots\}$		$\text{Some}(min(min(min(a_0, a_1), a_2), \ldots))$
		$\{a_0\}$		$\text{Some}(a_0)$
		$\{\}$		$\text{None}$
IT	$\text{minmax}$	$\{\}$		$\text{NoElements}$
		$\{a_0\}$		$\text{OneElement}(a_0)$
		$\{a_0, \ldots\}$		$\text{MinMax}(\text{min}(a), \text{max}(a))$
IT	$\text{minmax_by}$	$\{\}$ ,	${}\circ{} : (\text{&}T,\text{&}T) \rightarrow \text{Ordering}$	$\text{NoElements}$
		$\{a_0\}$		$\text{OneElement}(a_0)$
		$\{a_0, \ldots\}$		$\text{MinMax}(\text{min_by}(a, {}\circ{}), \text{max_by}(a, {}\circ{}))$
IT	$\text{minmax_by_key}$	$\{\}$ ,	$f : \text{&}T \rightarrow K$	$\text{NoElements}$
		$\{a_0\}$		$\text{OneElement}(a_0)$
		$\{a_0, \ldots\}$		$\text{MinMax}(\text{min_by_key}(a, f), \text{max_by_key}(a, f))$
Std	$\text{min_by}$	$\{a_0, \ldots\}$	${}\circ{} : (\text{&}T, \text{&}T) \rightarrow \text{Ordering}$	$\text{Some}(a_i) \text{ wh. } a_i \circ a_j \circ \ldots$
		$\{a_0\}$		$\text{Some}(a_0)$
		$\{\}$		$\text{None}$
Std	$\text{min_by_key}$	$\{a_0, \ldots\}$	$f : \text{&}T \rightarrow B$	$\text{Some}(a_i) \text{ wh.}\\~~ b = min(\{f(a_0), \ldots\}), i \text{ is the last wh. } f(a_i) = b$
		$\{a_0\}$		$\text{Some}(a_0)$
		$\{\}$		$\text{None}$
Std	$\text{ne}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$ ,	$\text{true} \text{ wh. } n \neq m$
Std	$\text{ne}$	$\{a_0, \ldots, a_{n-1}\}$ ,	$\{b_0, \ldots, b_{m-1}\}$ ,	$(a_0 \neq b_0) \land \ldots \land (a_{n-1} \neq b_{n-1})$
IT	$\text{next_tuple}$	$\text{&mut }\{a_0, \ldots, a_{n-1}\}$	$\langle (\underbrace{\_, \_, \ldots}_{m})\rangle$	$\text{None} \text{ wh. } n < m$
IT	$\text{next_tuple}$	$\text{&mut }\{a_0, \ldots, a_{m-1}, \underline{a_{m}, \ldots}\}$	$\langle (\underbrace{\_, \_, \ldots}_{m})\rangle$	$\text{Some}((a_0, \ldots, a_{m-1}))$
Std	$\text{nth}$	$\text{&mut }\{\underbrace{\ldots}_{i-1}, a_i, \underline{\ldots}\}$ ,	$i$	$\text{Some}(a_i)$
Std	$\text{nth}$	$\text{&mut }\{\underbrace{\ldots}_{{}<i}\}$ ,	$i$	$\text{None}$
Std	$\text{position}$	$\text{&mut }\{a_0, \ldots, a_i, \underline{\ldots}\}$ ,	$p : T \rightarrow \text{bool}$	$\begin{array}{ll} \text{Some}(i) &\text{wh. } i \text{ is first wh. } p(\text{&}a_i) \\ \text{None} & \text{otherwise} \end{array}$
Std	$\text{product}$	$\{a_0, a_1, \ldots\}$		$((a_0 \times a_1) \times \ldots)$
		$\{a_0\}$		$a_0$
		$\{\}$		$1$
Std	$\text{rposition}$	$\text{&mut }\{\underline{a_0, \ldots}, a_i, \ldots\}$ ,	$p : T \rightarrow \text{bool}$	$\begin{array}{ll} \text{Some}(i) &\text{wh. } i \text{ is last wh. } p(\text{&}a_i) \\ \text{None} & \text{otherwise} \end{array}$
IT	$\text{set_from}$	$\text{&mut }\{a_0, \ldots, a_{i-1}, \underline{a_i, \ldots}\} : \{\text{&mut }T\}$	$\{b_0, \ldots, b_{i-1}\} : \{T\}$	$i$ , with side effect: $\circ a_j = b_j$
		$\text{&mut }\{a_0, \ldots, a_{i-1}\} : \{\text{&mut }T\}$	$\{b_0, \ldots, b_{i-1}\} : \{T\}$
		$\text{&mut }\{a_0, \ldots, a_{i-1}\} : \{\text{&mut }T\}$	$\{b_0, \ldots, b_{i-1}, \underline{b_i, \ldots}\} : \{T\}$
Std	$\text{sum}$	$\{a_0, a_1, \ldots\}$		$((a_0 + a_1) + \ldots)$
		$\{a_0\}$		$a_0$
		$\{\}$		$0$

Other

Lib	Method	Description
IT	$\text{assert_equal}$	Ensures the items in two iterators match exactly, panicking with a descriptive message on how and where they differ.
Std	$\text{by_ref}$	Lets you act on a sequence by reference; i.e. calls that would normally consume the iterator will no longer do so. Note that this can have slightly unintuitive effects depending on what iterator methods are used on the result. e.g. $\text{take_while}$ must necessarily consume one more element than is returned in order to detect the termination condition; this element is consumed and does not remain in the underlying sequence.
Std	$\text{cloned}$	Returns an iterator which calls `Clone::clone` on each element of the input. This is commonly used to turn an `Iterator<Item=&T>` into an `Iterator<Item=T>`.
IT	$\text{combinations}$	Returns all in-order, unique combinations of length $n$ without replacement. Each combination is a `Vec` of length $n$ .
IT	$\text{diff_with}$	Determines where and how two iterators differ.
IT	$\text{foreach}$	Eagerly executes a closure $f$ on each element of the sequence.
IT	$\text{format}$	Returns a thunk which formats each item in the iterator, separated by $\text{sep}$ .
IT	$\text{format_with}$	Like `format`, except that it also accepts a callable used to customise the formatting for each item.
Std	$\text{fuse}$	Guarantees that once the input returns $\text{None}$ , it will always return $\text{None}$ .
Std	$\text{inspect}$	Calls a closure for each element in a sequence, without modifying the sequence in any way.
IT	$\text{multipeek}$	Allows you to preview (peek at) an unbounded number of future items in the sequence without removing them.
IT	$\text{multizip}$	Generalises `zip` for up to 8 iterators.
Std	$\text{peekable}$	Allows you to preview (peek at) the next item in the sequence without removing it.
IT	$\text{peeking_take_while}$	Like `take_while_ref`, but works on peekable iterators rather than cloneable ones.
IT	$\text{put_back}$	Creates an iterator where you can "put back" one item.
IT	$\text{put_back_n}$	Creates an iterator where you can "put back" an arbitrary number of items.
IT	$\text{rciter}$	Wraps an iterator such that it can be iterated by multiple handles.
IT	$\text{tuple_combinations}$	Returns all in-order, unique combinations of length $n$ without replacement. Each combination is a tuple of length $n$ .

Notes

Q: Who is the audience for this?

Definitely not absolute beginners!

The problem is that beginner-friendly descriptions of the available iterator methods are long and wordy, which makes them difficult to quickly scan through. Summarising them requires notation, and there are enough different kinds of behaviours that the notation needs to be relatively extensive.

I've tried to keep the notation used as simple as possible, but that can only go so far. My primary concern with this is creating a summary that can be skimmed relatively quickly, not to make iterators accessible to beginners.

This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.