Структура Bytes

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

Итератор по байтам среза строки.

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

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

impl<'a> Clone for Bytes<'a>

fn clone

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

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

clone_from

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

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

impl<'a> Debug for Bytes<'a>

fmt

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

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

impl DoubleEndedIterator for Bytes<'_>

next_back

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

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

nth_back

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

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

rfind

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

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

advance_back_by

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

🔬 Это экспериментальное API, доступное только в ночных сборках. (iter_advance_by #77404) Перемещает итератор с конца на 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,
}

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

impl ExactSizeIterator for Bytes<'_>

len

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

Возвращает точное оставшееся количество элементов итератора.

is_empty

#![allow(unused)]
fn main() {
fn is_empty(&self) -> bool
}

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

impl Iterator for Bytes<'_>

Item

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

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

next

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

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

size_hint

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

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

count

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

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

last

#![allow(unused)]
fn main() {
fn last(self) -> Option<<Bytes<'_> as Iterator>::Item>
}

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

nth

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

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

all

#![allow(unused)]
fn main() {
fn all<F>(&mut self, f: F) -> bool
where
    F: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
}

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

any

#![allow(unused)]
fn main() {
fn any<F>(&mut self, f: F) -> bool
where
    F: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
}

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

find

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

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

position

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

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

rposition

#![allow(unused)]
fn main() {
fn rposition<P>(&mut self, predicate: P) -> Option<usize>
where
    P: FnMut(<Bytes<'_> as Iterator>::Item) -> bool,
}

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

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 элементов.

step_by

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

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

chain

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

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) Сводит элементы к одному путем многократного применения операции сокращения. Если замыкание возвращает ошибку, ошибка немедленно передается обратно вызывающей стороне.

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) Применяет функцию к элементам итератора и возвращает первый истинный результат или первую ошибку.

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 Bytes<'_>

impl TrustedLen for Bytes<'_>

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

#![allow(unused)]
fn main() {
impl<'a> Freeze for Bytes<'a>
impl<'a> RefUnwindSafe for Bytes<'a>
impl<'a> Send for Bytes<'a>
impl<'a> Sync for Bytes<'a>
impl<'a> Unpin for Bytes<'a>
impl<'a> UnwindSafe for Bytes<'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>,
}