Структура CharIndices

#![allow(unused)]
fn main() {
pub struct CharIndices<'a> { /* приватные поля */ }
}

Итератор по символам (char) среза строки вместе с их позициями.

Эта структура создается методом char_indices для типа str. Подробнее см. в его документации.

Методы

impl<'a> CharIndices<'a>

as_str (с версии 1.4.0)

#![allow(unused)]
fn main() {
pub fn as_str(&self) -> &'a str
}

Возвращает представление базовых данных как под-срез исходных данных.

Имеет то же время жизни, что и исходный срез, поэтому итератор можно продолжать использовать, пока этот срез существует.

offset (с версии 1.82.0)

#![allow(unused)]
fn main() {
pub fn offset(&self) -> usize
}

Возвращает позицию в байтах следующего символа или длину базовой строки, если больше нет символов.

Это означает, что когда итератор еще не полностью потреблен, возвращаемое значение будет соответствовать индексу, который будет возвращен следующим вызовом next().

Примеры

#![allow(unused)]
fn main() {
let mut chars = "a楽".char_indices();

// `next()` еще не вызывался, поэтому `offset()` возвращает байтовый
// индекс первого символа строки, который всегда равен 0.
assert_eq!(chars.offset(), 0);
// Как и ожидалось, первый вызов `next()` также возвращает 0 как индекс.
assert_eq!(chars.next(), Some((0, 'a')));

// `next()` был вызван один раз, поэтому `offset()` возвращает байтовый индекс
// второго символа ...
assert_eq!(chars.offset(), 1);
// ... который соответствует индексу, возвращаемому следующим вызовом `next()`.
assert_eq!(chars.next(), Some((1, '楽')));

// Как только итератор будет потреблен, `offset()` возвращает длину
// строки в байтах.
assert_eq!(chars.offset(), 4);
assert_eq!(chars.next(), None);
}

Реализации трейтов

impl<'a> Clone for CharIndices<'a>

clone

#![allow(unused)]
fn main() {
fn clone(&self) -> CharIndices<'a> ⓘ
}

Возвращает копию значения.

clone_from

#![allow(unused)]
fn main() {
fn clone_from(&mut self, source: &Self)
}

Выполняет копирующее присваивание из source.

impl<'a> Debug for CharIndices<'a>

fmt

#![allow(unused)]
fn main() {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
}

Форматирует значение с помощью заданного форматтера.

impl<'a> DoubleEndedIterator for CharIndices<'a>

next_back

#![allow(unused)]
fn main() {
fn next_back(&mut self) -> Option<(usize, char)>
}

Удаляет и возвращает элемент с конца итератора.

advance_back_by

#![allow(unused)]
fn main() {
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_advance_by #77404) Перемещает итератор с конца на n элементов.

nth_back (с версии 1.37.0)

#![allow(unused)]
fn main() {
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
}

Возвращает n-й элемент с конца итератора.

try_rfold (с версии 1.27.0)

#![allow(unused)]
fn main() {
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Output = B>,
}

Обратная версия Iterator::try_fold(): берет элементы, начиная с конца итератора.

rfold (с версии 1.27.0)

#![allow(unused)]
fn main() {
fn rfold<B, F>(self, init: B, f: F) -> B
where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B,
}

Метод итератора, который сводит элементы итератора к единственному конечному значению, начиная с конца.

rfind (с версии 1.27.0)

#![allow(unused)]
fn main() {
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
}

Ищет элемент итератора с конца, удовлетворяющий предикату.

impl<'a> Iterator for CharIndices<'a>

type Item

#![allow(unused)]
fn main() {
type Item = (usize, char)
}

Тип элементов, по которым выполняется итерация (пара: индекс и символ).

next

#![allow(unused)]
fn main() {
fn next(&mut self) -> Option<(usize, char)>
}

Перемещает итератор и возвращает следующее значение.

count

#![allow(unused)]
fn main() {
fn count(self) -> usize
}

Потребляет итератор, подсчитывая количество итераций и возвращая его.

size_hint

#![allow(unused)]
fn main() {
fn size_hint(&self) -> (usize, Option<usize>)
}

Возвращает границы оставшейся длины итератора.

last

#![allow(unused)]
fn main() {
fn last(self) -> Option<(usize, char)>
}

Потребляет итератор, возвращая последний элемент.

next_chunk

#![allow(unused)]
fn main() {
fn next_chunk<const N: usize>(&mut self) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where
    Self: Sized,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_next_chunk #98326) Перемещает итератор и возвращает массив, содержащий следующие N значений.

advance_by

#![allow(unused)]
fn main() {
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_advance_by #77404) Перемещает итератор на n элементов.

nth

#![allow(unused)]
fn main() {
fn nth(&mut self, n: usize) -> Option<Self::Item>
}

Возвращает n-й элемент итератора.

step_by (с версии 1.28.0)

#![allow(unused)]
fn main() {
fn step_by(self, step: usize) -> StepBy<Self> ⓘ
where
    Self: Sized,
}

Создает итератор, начинающийся с той же точки, но с шагом заданного размера на каждой итерации.

chain (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> ⓘ
where
    Self: Sized,
    U: IntoIterator<Item = Self::Item>,
}

Берет два итератора и создает новый итератор, проходящий по обоим последовательно.

zip (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> ⓘ
where
    Self: Sized,
    U: IntoIterator,
}

"Объединяет" два итератора в один итератор пар.

intersperse

#![allow(unused)]
fn main() {
fn intersperse(self, separator: Self::Item) -> Intersperse<Self> ⓘ
where
    Self: Sized,
    Self::Item: Clone,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_intersperse #79524) Создает новый итератор, который помещает копию separator между соседними элементами исходного итератора.

intersperse_with

#![allow(unused)]
fn main() {
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘ
where
    Self: Sized,
    G: FnMut() -> Self::Item,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_intersperse #79524) Создает новый итератор, который помещает элемент, сгенерированный separator, между соседними элементами исходного итератора.

map (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
where
    Self: Sized,
    F: FnMut(Self::Item) -> B,
}

Берет замыкание и создает итератор, который вызывает это замыкание для каждого элемента.

for_each (с версии 1.21.0)

#![allow(unused)]
fn main() {
fn for_each<F>(self, f: F)
where
    Self: Sized,
    F: FnMut(Self::Item),
}

Вызывает замыкание для каждого элемента итератора.

filter (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘ
where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
}

Создает итератор, который использует замыкание для определения, должен ли элемент быть выдан.

filter_map (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘ
where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
}

Создает итератор, который одновременно фильтрует и преобразует.

enumerate (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn enumerate(self) -> Enumerate<Self> ⓘ
where
    Self: Sized,
}

Создает итератор, который дает текущий счетчик итераций, а также следующее значение.

peekable (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn peekable(self) -> Peekable<Self> ⓘ
where
    Self: Sized,
}

Создает итератор, который может использовать методы peek и peek_mut для просмотра следующего элемента итератора без его потребления.

skip_while (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> ⓘ
where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
}

Создает итератор, который пропускает элементы на основе предиката.

take_while (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘ
where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
}

Создает итератор, который выдает элементы на основе предиката.

map_while (с версии 1.57.0)

#![allow(unused)]
fn main() {
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘ
where
    Self: Sized,
    P: FnMut(Self::Item) -> Option<B>,
}

Создает итератор, который одновременно выдает элементы на основе предиката и преобразует их.

skip (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn skip(self, n: usize) -> Skip<Self> ⓘ
where
    Self: Sized,
}

Создает итератор, который пропускает первые n элементов.

take (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn take(self, n: usize) -> Take<Self> ⓘ
where
    Self: Sized,
}

Создает итератор, который выдает первые n элементов или меньше, если базовый итератор заканчивается раньше.

scan (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> ⓘ
where
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Option<B>,
}

Адаптер итератора, который, как и fold, хранит внутреннее состояние, но, в отличие от fold, создает новый итератор.

flat_map (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘ
where
    Self: Sized,
    U: IntoIterator,
    F: FnMut(Self::Item) -> U,
}

Создает итератор, который работает как map, но сглаживает вложенную структуру.

flatten (с версии 1.29.0)

#![allow(unused)]
fn main() {
fn flatten(self) -> Flatten<Self> ⓘ
where
    Self: Sized,
    Self::Item: IntoIterator,
}

Создает итератор, который сглаживает вложенную структуру.

map_windows

#![allow(unused)]
fn main() {
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘ
where
    Self: Sized,
    F: FnMut(&[Self::Item; N]) -> R,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_map_windows #87155) Вызывает заданную функцию f для каждого непрерывного окна размера N над self и возвращает итератор по результатам f. Как и в slice::windows(), окна при отображении также перекрываются.

fuse (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn fuse(self) -> Fuse<Self> ⓘ
where
    Self: Sized,
}

Создает итератор, который завершается после первого None.

inspect (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ
where
    Self: Sized,
    F: FnMut(&Self::Item),
}

Выполняет действие с каждым элементом итератора, передавая значение дальше.

by_ref (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn by_ref(&mut self) -> &mut Self
where
    Self: Sized,
}

Создает адаптер "по ссылке" для данного экземпляра Iterator.

collect (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn collect<B>(self) -> B
where
    B: FromIterator<Self::Item>,
    Self: Sized,
}

Преобразует итератор в коллекцию.

try_collect

#![allow(unused)]
fn main() {
fn try_collect<B>(&mut self) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType
where
    Self: Sized,
    Self::Item: Try,
    <Self::Item as Try>::Residual: Residual<B>,
    B: FromIterator<<Self::Item as Try>::Output>,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iterator_try_collect #94047) Преобразует итератор в коллекцию с обработкой ошибок, прерываясь при первой неудаче.

collect_into

#![allow(unused)]
fn main() {
fn collect_into<E>(self, collection: &mut E) -> &mut E
where
    E: Extend<Self::Item>,
    Self: Sized,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_collect_into #94780) Собирает все элементы из итератора в коллекцию.

partition (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn partition<B, F>(self, f: F) -> (B, B)
where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool,
}

Потребляет итератор, создавая две коллекции из него.

partition_in_place

#![allow(unused)]
fn main() {
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
where
    T: 'a,
    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
    P: FnMut(&T) -> bool,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_partition_in_place #62543) Переупорядочивает элементы этого итератора на месте в соответствии с заданным предикатом так, чтобы все элементы, возвращающие true, предшествовали всем элементам, возвращающим false. Возвращает количество найденных элементов true.

is_partitioned

#![allow(unused)]
fn main() {
fn is_partitioned<P>(self, predicate: P) -> bool
where
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_is_partitioned #62544) Проверяет, разделены ли элементы этого итератора согласно заданному предикату, так что все элементы, возвращающие true, предшествуют всем элементам, возвращающим false.

try_fold (с версии 1.27.0)

#![allow(unused)]
fn main() {
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Output = B>,
}

Метод итератора, который применяет функцию, пока она возвращает успех, производя единственное конечное значение.

try_for_each (с версии 1.27.0)

#![allow(unused)]
fn main() {
fn try_for_each<F, R>(&mut self, f: F) -> R
where
    Self: Sized,
    F: FnMut(Self::Item) -> R,
    R: Try<Output = ()>,
}

Метод итератора, который применяет функцию с возможностью ошибки к каждому элементу итератора, останавливаясь при первой ошибке и возвращая эту ошибку.

fold (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn fold<B, F>(self, init: B, f: F) -> B
where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B,
}

Складывает каждый элемент в аккумулятор путем применения операции, возвращая конечный результат.

reduce (с версии 1.51.0)

#![allow(unused)]
fn main() {
fn reduce<F>(self, f: F) -> Option<Self::Item>
where
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> Self::Item,
}

Сводит элементы к одному путем многократного применения операции сокращения.

try_reduce

#![allow(unused)]
fn main() {
fn try_reduce<R>(&mut self, f: impl FnMut(Self::Item, Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where
    Self: Sized,
    R: Try<Output = Self::Item>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iterator_try_reduce #87053) Сводит элементы к одному путем многократного применения операции сокращения. Если замыкание возвращает ошибку, ошибка немедленно передается обратно вызывающей стороне.

all (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn all<F>(&mut self, f: F) -> bool
where
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
}

Проверяет, соответствует ли каждый элемент итератора предикату.

any (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn any<F>(&mut self, f: F) -> bool
where
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
}

Проверяет, соответствует ли хотя бы один элемент итератора предикату.

find (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
}

Ищет элемент итератора, удовлетворяющий предикату.

find_map (с версии 1.30.0)

#![allow(unused)]
fn main() {
fn find_map<B, F>(&mut self, f: F) -> Option<B>
where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
}

Применяет функцию к элементам итератора и возвращает первый не-None результат.

try_find

#![allow(unused)]
fn main() {
fn try_find<R>(&mut self, f: impl FnMut(&Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
where
    Self: Sized,
    R: Try<Output = bool>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (try_find #63178) Применяет функцию к элементам итератора и возвращает первый истинный результат или первую ошибку.

position (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn position<P>(&mut self, predicate: P) -> Option<usize>
where
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
}

Ищет элемент в итераторе, возвращая его индекс.

rposition (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn rposition<P>(&mut self, predicate: P) -> Option<usize>
where
    P: FnMut(Self::Item) -> bool,
    Self: Sized + ExactSizeIterator + DoubleEndedIterator,
}

Ищет элемент в итераторе справа, возвращая его индекс.

max (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn max(self) -> Option<Self::Item>
where
    Self: Sized,
    Self::Item: Ord,
}

Возвращает максимальный элемент итератора.

min (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn min(self) -> Option<Self::Item>
where
    Self: Sized,
    Self::Item: Ord,
}

Возвращает минимальный элемент итератора.

max_by_key (с версии 1.6.0)

#![allow(unused)]
fn main() {
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
where
    B: Ord,
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
}

Возвращает элемент, который дает максимальное значение от указанной функции.

max_by (с версии 1.15.0)

#![allow(unused)]
fn main() {
fn max_by<F>(self, compare: F) -> Option<Self::Item>
where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
}

Возвращает элемент, который дает максимальное значение относительно указанной функции сравнения.

min_by_key (с версии 1.6.0)

#![allow(unused)]
fn main() {
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
where
    B: Ord,
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
}

Возвращает элемент, который дает минимальное значение от указанной функции.

min_by (с версии 1.15.0)

#![allow(unused)]
fn main() {
fn min_by<F>(self, compare: F) -> Option<Self::Item>
where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
}

Возвращает элемент, который дает минимальное значение относительно указанной функции сравнения.

rev (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn rev(self) -> Rev<Self> ⓘ
where
    Self: Sized + DoubleEndedIterator,
}

Изменяет направление итератора на противоположное.

unzip (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>,
}

Преобразует итератор пар в пару контейнеров.

copied (с версии 1.36.0)

#![allow(unused)]
fn main() {
fn copied<'a, T>(self) -> Copied<Self> ⓘ
where
    T: Copy + 'a,
    Self: Sized + Iterator<Item = &'a T>,
}

Создает итератор, который копирует все свои элементы.

cloned (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn cloned<'a, T>(self) -> Cloned<Self> ⓘ
where
    T: Clone + 'a,
    Self: Sized + Iterator<Item = &'a T>,
}

Создает итератор, который клонирует все свои элементы.

cycle (с версии 1.0.0)

#![allow(unused)]
fn main() {
fn cycle(self) -> Cycle<Self> ⓘ
where
    Self: Sized + Clone,
}

Бесконечно повторяет итератор.

array_chunks

#![allow(unused)]
fn main() {
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N> ⓘ
where
    Self: Sized,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_array_chunks #100450) Возвращает итератор по N элементов итератора за раз.

sum (с версии 1.11.0)

#![allow(unused)]
fn main() {
fn sum<S>(self) -> S
where
    Self: Sized,
    S: Sum<Self::Item>,
}

Суммирует элементы итератора.

product (с версии 1.11.0)

#![allow(unused)]
fn main() {
fn product<P>(self) -> P
where
    Self: Sized,
    P: Product<Self::Item>,
}

Итерируется по всему итератору, перемножая все элементы.

cmp (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn cmp<I>(self, other: I) -> Ordering
where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord,
    Self: Sized,
}

Лексикографически сравнивает элементы этого Iterator с элементами другого.

cmp_by

#![allow(unused)]
fn main() {
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_order_by #64295) Лексикографически сравнивает элементы этого Iterator с элементами другого относительно указанной функции сравнения.

partial_cmp (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn partial_cmp<I>(self, other: I) -> Option<Ordering>
where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
}

Лексикографически сравнивает элементы PartialOrd этого Iterator с элементами другого. Сравнение работает как короткое замыкание, возвращая результат без сравнения оставшихся элементов. Как только порядок может быть определен, оценка останавливается и возвращается результат.

partial_cmp_by

#![allow(unused)]
fn main() {
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_order_by #64295) Лексикографически сравнивает элементы этого Iterator с элементами другого относительно указанной функции сравнения.

eq (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn eq<I>(self, other: I) -> bool
where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>,
    Self: Sized,
}

Определяет, равны ли элементы этого Iterator элементам другого.

eq_by

#![allow(unused)]
fn main() {
fn eq_by<I, F>(self, other: I, eq: F) -> bool
where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
}

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_order_by #64295) Определяет, равны ли элементы этого Iterator элементам другого относительно указанной функции равенства.

ne (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn ne<I>(self, other: I) -> bool
where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>,
    Self: Sized,
}

Определяет, не равны ли элементы этого Iterator элементам другого.

lt (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn lt<I>(self, other: I) -> bool
where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
}

Определяет, лексикографически ли меньше элементы этого Iterator, чем элементы другого.

le (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn le<I>(self, other: I) -> bool
where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
}

Определяет, лексикографически ли меньше или равны элементы этого Iterator элементам другого.

gt (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn gt<I>(self, other: I) -> bool
where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
}

Определяет, лексикографически ли больше элементы этого Iterator, чем элементы другого.

ge (с версии 1.5.0)

#![allow(unused)]
fn main() {
fn ge<I>(self, other: I) -> bool
where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>,
    Self: Sized,
}

Определяет, лексикографически ли больше или равны элементы этого Iterator элементам другого.

is_sorted (с версии 1.82.0)

#![allow(unused)]
fn main() {
fn is_sorted(self) -> bool
where
    Self: Sized,
    Self::Item: PartialOrd,
}

Проверяет, отсортированы ли элементы этого итератора.

is_sorted_by (с версии 1.82.0)

#![allow(unused)]
fn main() {
fn is_sorted_by<F>(self, compare: F) -> bool
where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> bool,
}

Проверяет, отсортированы ли элементы этого итератора с использованием заданной функции сравнения.

is_sorted_by_key (с версии 1.82.0)

#![allow(unused)]
fn main() {
fn is_sorted_by_key<F, K>(self, f: F) -> bool
where
    Self: Sized,
    F: FnMut(Self::Item) -> K,
    K: PartialOrd,
}

Проверяет, отсортированы ли элементы этого итератора с использованием заданной функции извлечения ключа.

impl FusedIterator for CharIndices<'_> (с версии 1.26.0)

Автоматические реализации трейтов

#![allow(unused)]
fn main() {
impl<'a> Freeze for CharIndices<'a>
impl<'a> RefUnwindSafe for CharIndices<'a>
impl<'a> Send for CharIndices<'a>
impl<'a> Sync for CharIndices<'a>
impl<'a> Unpin for CharIndices<'a>
impl<'a> UnwindSafe for CharIndices<'a>
}

Общие реализации

#![allow(unused)]
fn main() {
impl<T> Any for T
where
    T: 'static + ?Sized,
}

#![allow(unused)]
fn main() {
impl<T> Borrow<T> for T
where
    T: ?Sized,
}

#![allow(unused)]
fn main() {
impl<T> BorrowMut<T> for T
where
    T: ?Sized,
}

#![allow(unused)]
fn main() {
impl<T> CloneToUninit for T
where
    T: Clone,
}

#![allow(unused)]
fn main() {
impl<T> From<T> for T
}

#![allow(unused)]
fn main() {
impl<T, U> Into<U> for T
where
    U: From<T>,
}

#![allow(unused)]
fn main() {
impl<I> IntoIterator for I
where
    I: Iterator,
}

#![allow(unused)]
fn main() {
impl<T> ToOwned for T
where
    T: Clone,
}

#![allow(unused)]
fn main() {
impl<T, U> TryFrom<U> for T
where
    U: Into<T>,
}

#![allow(unused)]
fn main() {
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
}