Trait InternalIterator

pub trait InternalIterator {
    type Item;

    // Required method
    fn for_each<F>(self, f: &mut F) -> bool
       where F: FnMut(Self::Item) -> bool;

    // Provided methods
    fn collect<F>(self) -> F
       where Self: Sized,
             F: FromInternalIterator<Self::Item> { ... }
    fn map<R, F>(self, f: F) -> Map<Self, F>
       where Self: Sized,
             F: FnMut(Self::Item) -> R { ... }
}

A trait for internal iterators. An internal iterator differs from a normal iterator in that its iteration is controlled internally by the iterator itself, instead of externally by the calling code. This means that instead of returning a single item on each call to next, internal iterators call a closure for each item on a single call to for_each. This allows internal operators to be implemented recursively, something that is not possible with normal iterators.

Required Associated Types

type Item

Required Methods

fn for_each<F>(self, f: &mut F) -> bool

where F: FnMut(Self::Item) -> bool,

Calls f with each item of self.

If f returns false, iteration is aborted. If iteration was aborted, this function returns false.

Provided Methods

fn collect<F>(self) -> F

where Self: Sized, F: FromInternalIterator<Self::Item>,

Transforms self into a collection.

fn map<R, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> R,

Returns an internal iterator that applies f to each item of self.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl InternalIterator for Linearize

type Item = Point

impl<'a> InternalIterator for Trapezoidate<'a>

type Item = Trapezoid

impl<I> InternalIterator for I

where I: Iterator,

type Item = <I as Iterator>::Item