Сводная таблица методов и адаптеров `Iterator` в Rust

Базовые методы потребления

Метод	Формат	Назначение
`next`	`fn next(&mut self) -> Option<Self::Item>`	Возвращает следующий элемент
`size_hint`	`fn size_hint(&self) -> (usize, Option<usize>)`	Оценка оставшегося количества элементов
`count`	`fn count(self) -> usize`	Потребляет итератор, возвращая количество элементов
`last`	`fn last(self) -> Option<Self::Item>`	Возвращает последний элемент
`advance_by`	`fn advance_by(&mut self, n: usize) -> Result<(), usize>`	Пропускает n элементов
`nth`	`fn nth(&mut self, n: usize) -> Option<Self::Item>`	Возвращает n-й элемент

Методы потребления с преобразованием

Метод	Формат	Назначение
`collect`	`fn collect<B>(self) -> B where B: FromIterator<Self::Item>`	Преобразует в коллекцию
`partition`	`fn partition<B, F>(self, f: F) -> (B, B)`	Разделяет на две коллекции по предикату
`try_fold`	`fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R`	Аккумулятор с возможностью ошибки
`fold`	`fn fold<B, F>(self, init: B, f: F) -> B`	Аккумулятор (редукция)
`reduce`	`fn reduce<F>(self, f: F) -> Option<Self::Item>`	Аккумулятор без начального значения
`try_reduce`	`fn try_reduce<F, R>(self, f: F) -> R`	Reduce с возможностью ошибки
`all`	`fn all<F>(&mut self, f: F) -> bool`	Проверяет, что все элементы удовлетворяют условию
`any`	`fn any<F>(&mut self, f: F) -> bool`	Проверяет, что хотя бы один элемент удовлетворяет условию
`find`	`fn find<P>(&mut self, predicate: P) -> Option<Self::Item>`	Находит первый элемент по предикату
`find_map`	`fn find_map<B, F>(&mut self, f: F) -> Option<B>`	Находит и преобразует первый подходящий элемент
`try_find`	`fn try_find<F, R>(&mut self, f: F) -> R`	Find с возможностью ошибки
`position`	`fn position<P>(&mut self, predicate: P) -> Option<usize>`	Находит позицию элемента
`rposition`	`fn rposition<P>(&mut self, predicate: P) -> Option<usize>`	Находит позицию с конца (только для ExactSizeIterator)
`max`	`fn max(self) -> Option<Self::Item>`	Максимальный элемент
`min`	`fn min(self) -> Option<Self::Item>`	Минимальный элемент
`max_by`	`fn max_by<F>(self, compare: F) -> Option<Self::Item>`	Максимум по функции сравнения
`min_by`	`fn min_by<F>(self, compare: F) -> Option<Self::Item>`	Минимум по функции сравнения
`max_by_key`	`fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>`	Максимум по ключу
`min_by_key`	`fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>`	Минимум по ключу
`sum`	`fn sum<S>(self) -> S`	Сумма элементов
`product`	`fn product<P>(self) -> P`	Произведение элементов

Адаптеры, преобразующие элементы

Метод	Формат	Назначение
`map`	`fn map<B, F>(self, f: F) -> Map<Self, F>`	Преобразует каждый элемент
`for_each`	`fn for_each<F>(self, f: F)`	Выполняет действие для каждого элемента
`filter_map`	`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>`	Фильтрация с преобразованием
`flat_map`	`fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>`	Преобразует в итератор и сглаживает
`flatten`	`fn flatten(self) -> Flatten<Self>`	Сглаживает вложенные итераторы
`inspect`	`fn inspect<F>(self, f: F) -> Inspect<Self, F>`	Побочный эффект для каждого элемента

Адаптеры фильтрации

Метод	Формат	Назначение
`filter`	`fn filter<P>(self, predicate: P) -> Filter<Self, P>`	Фильтрует элементы по условию
`take_while`	`fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>`	Берет элементы, пока условие истинно
`skip_while`	`fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>`	Пропускает элементы, пока условие истинно
`map_while`	`fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>`	Map, который может остановить итерацию

Адаптеры изменения размера

Метод	Формат	Назначение
`take`	`fn take(self, n: usize) -> Take<Self>`	Ограничивает количество элементов
`skip`	`fn skip(self, n: usize) -> Skip<Self>`	Пропускает n элементов
`step_by`	`fn step_by(self, step: usize) -> StepBy<Self>`	Берет каждый n-й элемент

Адаптеры комбинирования итераторов

Метод	Формат	Назначение
`chain`	`fn chain<U>(self, other: U) -> Chain<Self, U>`	Объединяет два итератора
`zip`	`fn zip<U>(self, other: U) -> Zip<Self, U>`	Объединяет попарно
`intersperse`	`fn intersperse(self, separator: Self::Item) -> Intersperse<Self>`	Вставляет разделитель между элементами
`intersperse_with`	`fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>`	Вставляет разделитель через функцию

Адаптеры копирования и клонирования

Метод	Формат	Назначение
`copied`	`fn copied<'a, T>(self) -> Copied<Self>`	Копирует элементы (для &T)
`cloned`	`fn cloned<'a, T>(self) -> Cloned<Self>`	Клонирует элементы (для &T)

Адаптеры циклов и повторений

Метод	Формат	Назначение
`cycle`	`fn cycle(self) -> Cycle<Self>`	Бесконечно повторяет итератор
`repeat`	`fn repeat(self) -> Repeat<Self>`	Бесконечно повторяет элемент

Адаптеры для работы с ошибками

Метод	Формат	Назначение
`try_collect`	`fn try_collect<T>(&mut self) -> T`	Collect с возможностью ошибки

Специализированные адаптеры

Метод	Формат	Назначение
`unzip`	`fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)`	Разделяет пары на две коллекции
`enumerate`	`fn enumerate(self) -> Enumerate<Self>`	Добавляет индексы
`peekable`	`fn peekable(self) -> Peekable<Self>`	Позволяет посмотреть на следующий элемент
`scan`	`fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>`	Итератор с состоянием
`fuse`	`fn fuse(self) -> Fuse<Self>`	Превращает None после первого None

Методы для двойных итераторов

Метод	Формат	Назначение
`eq`	`fn eq<I>(self, other: I) -> bool`	Проверяет равенство
`ne`	`fn ne<I>(self, other: I) -> bool`	Проверяет неравенство
`lt`	`fn lt<I>(self, other: I) -> bool`	Проверяет "меньше"
`le`	`fn le<I>(self, other: I) -> bool`	Проверяет "меньше или равно"
`gt`	`fn gt<I>(self, other: I) -> bool`	Проверяет "больше"
`ge`	`fn ge<I>(self, other: I) -> bool`	Проверяет "больше или равно"
`cmp`	`fn cmp<I>(self, other: I) -> Ordering`	Сравнивает лексикографически
`partial_cmp`	`fn partial_cmp<I>(self, other: I) -> Option<Ordering>`	Частичное сравнение
`cmp_by`	`fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering`	Сравнение по функции
`eq_by`	`fn eq_by<I, F>(self, other: I, eq: F) -> bool`	Равенство по функции

Утилиты

Метод	Формат	Назначение
`rev`	`fn rev(self) -> Rev<Self>`	Обратный порядок (только для DoubleEndedIterator)
`by_ref`	`fn by_ref(&mut self) -> &mut Self`	Заимствует итератор

Примечание: Большинство адаптеров ленивы - они выполняются только при потреблении.

Изучение языка RUST