Структура IntoIncoming

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

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

Итератор, который бесконечно принимает подключения на TcpListener.

Эта структура создается методом TcpListener::into_incoming. Смотрите его документацию для получения дополнительной информации.

Примеры

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

fn main() {
use std::net::TcpListener;

let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
let mut incoming = listener.into_incoming();

for stream_result in incoming {
    match stream_result {
        Ok(stream) => {
            println!("новое подключение: {}", stream.peer_addr().unwrap());
        }
        Err(e) => {
            println!("ошибка подключения: {}", e);
        }
    }
}
}

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

Debug для IntoIncoming

#![allow(unused)]
fn main() {
impl Debug for IntoIncoming
}

fmt

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

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

Iterator для IntoIncoming

#![allow(unused)]
fn main() {
impl Iterator for IntoIncoming
}

Ассоциированный тип Item

#![allow(unused)]
fn main() {
type Item = Result<TcpStream, Error>
}

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

next

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

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

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 значений. Подробнее

size_hint

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

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

count

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

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

last

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

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

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,
}

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

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)

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

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)

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

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,
}

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

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,
}

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

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,
}

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

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>,
}

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

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,
}

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

FusedIterator для IntoIncoming

#![allow(unused)]
fn main() {
impl FusedIterator for IntoIncoming
}

Реализует трейт FusedIterator, что означает, что после возврата None итератор всегда будет возвращать None.

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

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

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

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

impl<T> Borrow<T> for T
where
    T: ?Sized,

impl<T> BorrowMut<T> for T
where
    T: ?Sized,

impl<T> From<T> for T

impl<T, U> Into<U> for T
where
    U: From<T>,

impl<I> IntoIterator for I
where
    I: Iterator,

impl<T, U> TryFrom<U> for T
where
    U: Into<T>,

impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
}

Особенности использования

IntoIncoming - это альтернатива Incoming, которая принимает владение TcpListener. Это может быть полезно в сценариях, где вы хотите переместить слушатель в итератор и больше не нуждаетесь в исходном объекте слушателя.