Struct IntoChars

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

🔬 Экспериментальный API только для ночных сборок. (string_into_chars #133125)

Итератор по символам строки.

Этот структ создается методом into_chars у String. Для дополнительной информации смотрите его документацию.

Реализации

impl IntoChars

as_str

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

🔬 Экспериментальный API только для ночных сборок. (string_into_chars #133125)

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

Примеры

#![allow(unused)]
#![feature(string_into_chars)]

fn main() {
let mut chars = String::from("abc").into_chars();

assert_eq!(chars.as_str(), "abc");
chars.next();
assert_eq!(chars.as_str(), "bc");
chars.next();
chars.next();
assert_eq!(chars.as_str(), "");
}

into_string

#![allow(unused)]
fn main() {
pub fn into_string(self) -> String
}

🔬 Экспериментальный API только для ночных сборок. (string_into_chars #133125)

Потребляет IntoChars, возвращая оставшуюся строку.

Примеры

#![allow(unused)]
#![feature(string_into_chars)]

fn main() {
let chars = String::from("abc").into_chars();
assert_eq!(chars.into_string(), "abc");

let mut chars = String::from("def").into_chars();
chars.next();
assert_eq!(chars.into_string(), "ef");
}

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

impl Clone for IntoChars

clone

#![allow(unused)]
fn main() {
fn clone(&self) -> IntoChars ⓘ
}

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

clone_from

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

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

impl Debug for IntoChars

fmt

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

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

impl DoubleEndedIterator for IntoChars

next_back

#![allow(unused)]
fn main() {
fn next_back(&mut self) -> Option<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

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

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

try_rfold

#![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

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

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

rfind

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

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

impl Iterator for IntoChars

Item

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

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

next

#![allow(unused)]
fn main() {
fn next(&mut self) -> Option<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<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

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

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

step_by

#![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

#![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

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

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

for_each

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

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

filter

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

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

filter_map

#![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

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

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

peekable

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

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

skip_while

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

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

take_while

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

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

map_while

#![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

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

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

take

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

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

scan

#![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

#![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

#![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(), окна при отображении также перекрываются. [Подробнее](Read more)

fuse

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

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

inspect

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

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

by_ref

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

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

collect

#![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

#![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

#![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

#![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

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

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

reduce

#![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

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

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

any

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

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

find

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

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

find_map

#![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

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

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

rposition

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

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

max

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

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

min

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

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

max_by_key

#![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

#![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

#![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

#![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

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

Меняет направление итератора на противоположное.

unzip

#![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

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

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

cloned

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

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

cycle

#![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

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

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

product

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

cmp

#![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

#![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

#![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

#![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

#![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

#![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

#![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

#![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

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

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

is_sorted_by

#![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

#![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 IntoChars

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

#![allow(unused)]
fn main() {
impl Freeze for IntoChars
impl RefUnwindSafe for IntoChars
impl Send for IntoChars
impl Sync for IntoChars
impl Unpin for IntoChars
impl UnwindSafe for IntoChars
}

Blanket Реализации

#![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>,
}