Trait Grinder

pub trait Grinder {
    type Item: Chisel;
    type Error;

    // Required methods
    fn next(&mut self) -> Self::Item;
    fn emit(&mut self, err: Self::Error);

    // Provided methods
    fn vent<F, E>(self, f: F) -> Vent<Self, F, E>
       where Self: Sized,
             F: Fn(E) { ... }
    fn unwrap(self) -> Unwrap<Self>
       where Self: Sized { ... }
    fn map_err<F, E>(self, f: F) -> MapErrGrinder<Self, F, E>
       where Self: Sized,
             F: Fn(E) -> Self::Error { ... }
    fn peekable(self) -> Peekable<Self>
       where Self: Sized { ... }
    fn lookaheadable(self) -> Lookahead<Self>
       where Self: Sized { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
       where Self: Sized,
             F: Fn(&<Self::Item as Chisel>::Value) -> bool { ... }
}

Required Associated Types

type Item: Chisel

type Error

Required Methods

fn next(&mut self) -> Self::Item

fn emit(&mut self, err: Self::Error)

Provided Methods

fn vent<F, E>(self, f: F) -> Vent<Self, F, E>

where Self: Sized, F: Fn(E),

fn unwrap(self) -> Unwrap<Self>

where Self: Sized,

fn map_err<F, E>(self, f: F) -> MapErrGrinder<Self, F, E>

where Self: Sized, F: Fn(E) -> Self::Error,

fn peekable(self) -> Peekable<Self>

where Self: Sized,

fn lookaheadable(self) -> Lookahead<Self>

where Self: Sized,

fn filter<F>(self, f: F) -> Filter<Self, F>

where Self: Sized, F: Fn(&<Self::Item as Chisel>::Value) -> bool,

Trait Implementations

impl<I, C: Chisel<Value = I>, E> Iterator for dyn Grinder<Item = C, Error = E>

type Item = I

The type of the elements being iterated over.

fn next(&mut self) -> Option<I>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

Implementors

impl<I, E, C, T> Grinder for Unwrap<T>

where C: Chisel<Value = Result<I, E>>, T: Grinder<Item = C, Error = E>,

type Item = Option<I>

type Error = <T as Grinder>::Error

impl<I: Iterator> Grinder for Iter<I>

type Item = Option<<I as Iterator>::Item>

type Error = ()

impl<R: Read> Grinder for Read<R>

type Item = Option<Result<u8, Error>>

type Error = ()

impl<T> Grinder for Lookahead<T>

where T: Grinder,

type Item = <T as Grinder>::Item

type Error = <T as Grinder>::Error

impl<T> Grinder for Peekable<T>

where T: Grinder,

type Item = <T as Grinder>::Item

type Error = <T as Grinder>::Error

impl<T> Grinder for Utf8<T>

where T: Grinder<Item = Option<u8>>,

type Item = Option<(usize, char, u8)>

type Error = <T as Grinder>::Error

impl<T, E, F> Grinder for MapErrGrinder<T, F, E>

where T: Grinder, F: Fn(E) -> T::Error,

type Item = <T as Grinder>::Item

type Error = E

impl<T, F> Grinder for Filter<T, F>

where T: Grinder, F: Fn(&<T::Item as Chisel>::Value) -> bool,

type Item = <T as Grinder>::Item

type Error = <T as Grinder>::Error

impl<T: Grinder, E, F> Grinder for Vent<T, F, E>

where F: Fn(E),

type Item = <T as Grinder>::Item

type Error = E