Структура EscapeDebug

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

Тип, возвращаемый методом str::escape_debug.

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

impl<'a> Clone for EscapeDebug<'a>

Функция	Синтаксис	Пример	Назначение
clone	`fn clone(&self) -> EscapeDebug<'a> ⓘ`	`let cloned = escape_debug.clone();`	Возвращает копию значения
clone_from	`fn clone_from(&mut self, source: &Self)`	`escape_debug.clone_from(&other);`	Выполняет копирующее присваивание из `source`

impl<'a> Debug for EscapeDebug<'a>

Функция	Синтаксис	Пример	Назначение
fmt	`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`	`println!("{:?}", escape_debug);`	Форматирует значение с помощью заданного форматтера

impl<'a> Display for EscapeDebug<'a>

Функция	Синтаксис	Пример	Назначение
fmt	`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`	`println!("{}", escape_debug);`	Форматирует значение с помощью заданного форматтера

impl<'a> Iterator for EscapeDebug<'a>

Функция	Синтаксис	Пример	Назначение
type Item	`type Item = char`	-	Тип элементов, по которым выполняется итерация
next	`fn next(&mut self) -> Option<char>`	`let next_char = escape_debug.next();`	Перемещает итератор и возвращает следующее значение
size_hint	`fn size_hint(&self) -> (usize, Option<usize>)`	`let hint = escape_debug.size_hint();`	Возвращает границы оставшейся длины итератора
try_fold	`fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R`	`let sum = escape_debug.try_fold(0,	acc, c
fold	`fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc`	`let sum = escape_debug.fold(0,	acc, c
next_chunk	`fn next_chunk<const N: usize>(&mut self) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>`	`let chunk = escape_debug.next_chunk::<3>()?;`	🔬 Возвращает массив, содержащий следующие N значений
count	`fn count(self) -> usize`	`let total = escape_debug.count();`	Подсчитывает количество итераций и возвращает его
last	`fn last(self) -> Option<Self::Item>`	`let last_char = escape_debug.last();`	Возвращает последний элемент итератора
advance_by	`fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>`	`escape_debug.advance_by(3)?;`	🔬 Перемещает итератор на n элементов
nth	`fn nth(&mut self, n: usize) -> Option<Self::Item>`	`let third = escape_debug.nth(2);`	Возвращает n-й элемент итератора
step_by	`fn step_by(self, step: usize) -> StepBy<Self> ⓘ`	`let stepped = escape_debug.step_by(2);`	Создает итератор с заданным шагом
chain	`fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> ⓘ`	`let combined = escape_debug.chain(other_chars);`	Объединяет два итератора в последовательный
zip	`fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> ⓘ`	`let zipped = escape_debug.zip(other_chars);`	"Объединяет" два итератора в итератор пар
intersperse	`fn intersperse(self, separator: Self::Item) -> Intersperse<Self> ⓘ`	`let with_spaces = escape_debug.intersperse(' ');`	🔬 Помещает копию `separator` между элементами
intersperse_with	`fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘ`	`let with_sep = escape_debug.intersperse_with(
map	`fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ`	`let uppercased = escape_debug.map(	c
for_each	`fn for_each<F>(self, f: F)`	`escape_debug.for_each(	c
filter	`fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘ`	`let filtered = escape_debug.filter(	c
filter_map	`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘ`	`let digits = escape_debug.filter_map(	c
enumerate	`fn enumerate(self) -> Enumerate<Self> ⓘ`	`for (i, c) in escape_debug.enumerate() { ... }`	Добавляет индекс к каждому элементу
peekable	`fn peekable(self) -> Peekable<Self> ⓘ`	`let peekable = escape_debug.peekable();`	Создает итератор с возможностью просмотра следующего элемента
skip_while	`fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> ⓘ`	`let skipped = escape_debug.skip_while(	c
take_while	`fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘ`	`let taken = escape_debug.take_while(	c
map_while	`fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘ`	`let mapped = escape_debug.map_while(	c
skip	`fn skip(self, n: usize) -> Skip<Self> ⓘ`	`let skipped = escape_debug.skip(3);`	Пропускает первые n элементов
take	`fn take(self, n: usize) -> Take<Self> ⓘ`	`let taken = escape_debug.take(5);`	Берет первые n элементов
scan	`fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> ⓘ`	`let scanned = escape_debug.scan(0,	state, c
flat_map	`fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘ`	`let flattened = escape_debug.flat_map(	c
flatten	`fn flatten(self) -> Flatten<Self> ⓘ`	`let flattened = escape_debug.flatten();`	Сглаживает вложенную структуру
map_windows	`fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘ`	`let windows = escape_debug.map_windows::<_, _, 2>(	arr
fuse	`fn fuse(self) -> Fuse<Self> ⓘ`	`let fused = escape_debug.fuse();`	Создает итератор, завершающийся после первого `None`
inspect	`fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ`	`let inspected = escape_debug.inspect(	c
by_ref	`fn by_ref(&mut self) -> &mut Self`	`let part = escape_debug.by_ref().take(5).collect::<String>();`	Создает адаптер "по ссылке" для итератора
collect	`fn collect<B>(self) -> B`	`let string: String = escape_debug.collect();`	Преобразует итератор в коллекцию
try_collect	`fn try_collect<B>(&mut self) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType`	`let result: Result<String, _> = escape_debug.try_collect();`	🔬 Преобразует итератор в коллекцию с обработкой ошибок
collect_into	`fn collect_into<E>(self, collection: &mut E) -> &mut E`	`let mut s = String::new(); escape_debug.collect_into(&mut s);`	🔬 Собирает все элементы в коллекцию
partition	`fn partition<B, F>(self, f: F) -> (B, B)`	`let (letters, digits): (String, String) = escape_debug.partition(	c
partition_in_place	`fn partition_in_place<'a, T, P>(self, predicate: P) -> usize`	`let count = escape_debug.partition_in_place(	c
is_partitioned	`fn is_partitioned<P>(self, predicate: P) -> bool`	`let partitioned = escape_debug.is_partitioned(	c
try_for_each	`fn try_for_each<F, R>(&mut self, f: F) -> R`	`let result: Result<(), _> = escape_debug.try_for_each(	c
reduce	`fn reduce<F>(self, f: F) -> Option<Self::Item>`	`let max_char = escape_debug.reduce(	a, b
try_reduce	`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`	`let result: Result<Option, _> = escape_debug.try_reduce(	a, b
all	`fn all<F>(&mut self, f: F) -> bool`	`let all_letters = escape_debug.all(	c
any	`fn any<F>(&mut self, f: F) -> bool`	`let has_digit = escape_debug.any(	c
find	`fn find<P>(&mut self, predicate: P) -> Option<Self::Item>`	`let first_digit = escape_debug.find(	c
find_map	`fn find_map<B, F>(&mut self, f: F) -> Option<B>`	`let digit_value = escape_debug.find_map(	c
try_find	`fn try_find<R>(&mut self, f: impl FnMut(&Self::Item) -> R) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType`	`let result: Result<Option, _> = escape_debug.try_find(	c
position	`fn position<P>(&mut self, predicate: P) -> Option<usize>`	`let pos = escape_debug.position(	c
rposition	`fn rposition<P>(&mut self, predicate: P) -> Option<usize>`	`let pos = escape_debug.rposition(	c
max	`fn max(self) -> Option<Self::Item>`	`let max_char = escape_debug.max();`	Возвращает максимальный элемент
min	`fn min(self) -> Option<Self::Item>`	`let min_char = escape_debug.min();`	Возвращает минимальный элемент
max_by_key	`fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>`	`let max = escape_debug.max_by_key(	c
max_by	`fn max_by<F>(self, compare: F) -> Option<Self::Item>`	`let max = escape_debug.max_by(	a, b
min_by_key	`fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>`	`let min = escape_debug.min_by_key(	c
min_by	`fn min_by<F>(self, compare: F) -> Option<Self::Item>`	`let min = escape_debug.min_by(	a, b
rev	`fn rev(self) -> Rev<Self> ⓘ`	`let reversed = escape_debug.rev();`	Изменяет направление итератора
unzip	`fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)`	`let (chars, bytes): (Vec, Vec) = escape_debug.map(	c
copied	`fn copied<'a, T>(self) -> Copied<Self> ⓘ`	`let copied_chars = escape_debug.copied();`	Создает итератор, который копирует все элементы
cloned	`fn cloned<'a, T>(self) -> Cloned<Self> ⓘ`	`let cloned_chars = escape_debug.cloned();`	Создает итератор, который клонирует все элементы
cycle	`fn cycle(self) -> Cycle<Self> ⓘ`	`let cycled = escape_debug.cycle();`	Бесконечно повторяет итератор
array_chunks	`fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N> ⓘ`	`for chunk in escape_debug.array_chunks::<3>() { ... }`	🔬 Возвращает итератор по N элементов за раз
sum	`fn sum<S>(self) -> S`	`let total: u32 = escape_debug.map(	c
product	`fn product<P>(self) -> P`	`let product: u32 = escape_debug.map(	c
cmp	`fn cmp<I>(self, other: I) -> Ordering`	`let ordering = escape_debug.cmp(other_chars);`	Лексикографически сравнивает элементы с другими
cmp_by	`fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering`	`let ordering = escape_debug.cmp_by(other_chars,	a, b
partial_cmp	`fn partial_cmp<I>(self, other: I) -> Option<Ordering>`	`let ordering = escape_debug.partial_cmp(other_chars);`	Частично сравнивает элементы с другими
partial_cmp_by	`fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>`	`let ordering = escape_debug.partial_cmp_by(other_chars,	a, b
eq	`fn eq<I>(self, other: I) -> bool`	`let equal = escape_debug.eq(other_chars);`	Проверяет равенство элементов с другими
eq_by	`fn eq_by<I, F>(self, other: I, eq: F) -> bool`	`let equal = escape_debug.eq_by(other_chars,	a, b
ne	`fn ne<I>(self, other: I) -> bool`	`let not_equal = escape_debug.ne(other_chars);`	Проверяет неравенство элементов с другими
lt	`fn lt<I>(self, other: I) -> bool`	`let less = escape_debug.lt(other_chars);`	Проверяет, меньше ли элементы, чем другие
le	`fn le<I>(self, other: I) -> bool`	`let less_or_equal = escape_debug.le(other_chars);`	Проверяет, меньше или равны ли элементы
gt	`fn gt<I>(self, other: I) -> bool`	`let greater = escape_debug.gt(other_chars);`	Проверяет, больше ли элементы, чем другие
ge	`fn ge<I>(self, other: I) -> bool`	`let greater_or_equal = escape_debug.ge(other_chars);`	Проверяет, больше или равны ли элементы
is_sorted	`fn is_sorted(self) -> bool`	`let sorted = escape_debug.is_sorted();`	Проверяет, отсортированы ли элементы
is_sorted_by	`fn is_sorted_by<F>(self, compare: F) -> bool`	`let sorted = escape_debug.is_sorted_by(	a, b
is_sorted_by_key	`fn is_sorted_by_key<F, K>(self, f: F) -> bool`	`let sorted = escape_debug.is_sorted_by_key(	c

impl<'a> FusedIterator for EscapeDebug<'a> (с версии 1.34.0)

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

#![allow(unused)]
fn main() {
impl<'a> Freeze for EscapeDebug<'a>
impl<'a> RefUnwindSafe for EscapeDebug<'a>
impl<'a> Send for EscapeDebug<'a>
impl<'a> Sync for EscapeDebug<'a>
impl<'a> Unpin for EscapeDebug<'a>
impl<'a> UnwindSafe for EscapeDebug<'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> ToString for T
where
    T: Display + ?Sized,
}

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

Обозначения:

🔬 - экспериментальное API, доступное только в ночных сборках
ⓘ - обозначение, что функция возвращает итератор

Библиотека RUST