Trait IterScan 

pub trait IterScan: Sized {
    type Output;

    // Required method
    fn scan<'a, I: Iterator<Item = &'a str>>(
        iter: &mut I,
    ) -> Option<Self::Output>;
}

Required Associated Types

type Output

Required Methods

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self::Output>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl IterScan for char

type Output = char

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for f32

type Output = f32

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for f64

type Output = f64

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for i8

type Output = i8

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for i16

type Output = i16

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for i32

type Output = i32

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for i64

type Output = i64

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for i128

type Output = i128

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for isize

type Output = isize

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for u8

type Output = u8

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for u16

type Output = u16

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for u32

type Output = u32

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for u64

type Output = u64

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for u128

type Output = u128

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for ()

type Output = ()

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl IterScan for usize

type Output = usize

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl IterScan for String

type Output = String

fn scan<'a, I: Iterator<Item = &'a str>>(iter: &mut I) -> Option<Self>

impl<A: IterScan> IterScan for (A,)

type Output = (<A as IterScan>::Output,)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan> IterScan for (A, B)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan> IterScan for (A, B, C)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan> IterScan for (A, B, C, D)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan, E: IterScan> IterScan for (A, B, C, D, E)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output, <E as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan, E: IterScan, F: IterScan> IterScan for (A, B, C, D, E, F)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output, <E as IterScan>::Output, <F as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan, E: IterScan, F: IterScan, G: IterScan> IterScan for (A, B, C, D, E, F, G)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output, <E as IterScan>::Output, <F as IterScan>::Output, <G as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan, E: IterScan, F: IterScan, G: IterScan, H: IterScan> IterScan for (A, B, C, D, E, F, G, H)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output, <E as IterScan>::Output, <F as IterScan>::Output, <G as IterScan>::Output, <H as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan, E: IterScan, F: IterScan, G: IterScan, H: IterScan, I: IterScan> IterScan for (A, B, C, D, E, F, G, H, I)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output, <E as IterScan>::Output, <F as IterScan>::Output, <G as IterScan>::Output, <H as IterScan>::Output, <I as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan, E: IterScan, F: IterScan, G: IterScan, H: IterScan, I: IterScan, J: IterScan> IterScan for (A, B, C, D, E, F, G, H, I, J)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output, <E as IterScan>::Output, <F as IterScan>::Output, <G as IterScan>::Output, <H as IterScan>::Output, <I as IterScan>::Output, <J as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

impl<A: IterScan, B: IterScan, C: IterScan, D: IterScan, E: IterScan, F: IterScan, G: IterScan, H: IterScan, I: IterScan, J: IterScan, K: IterScan> IterScan for (A, B, C, D, E, F, G, H, I, J, K)

type Output = (<A as IterScan>::Output, <B as IterScan>::Output, <C as IterScan>::Output, <D as IterScan>::Output, <E as IterScan>::Output, <F as IterScan>::Output, <G as IterScan>::Output, <H as IterScan>::Output, <I as IterScan>::Output, <J as IterScan>::Output, <K as IterScan>::Output)

fn scan<'a, It: Iterator<Item = &'a str>>( _iter: &mut It, ) -> Option<Self::Output>

Implementors

impl IterScan for Byte1

type Output = u8

impl IterScan for Bytes

type Output = Vec<u8>

impl IterScan for Chars

type Output = Vec<char>

impl IterScan for Usize1

type Output = usize

impl IterScan for Decimal

type Output = Decimal

impl IterScan for DoubleDouble

type Output = DoubleDouble

impl IterScan for Float32

type Output = Float32

impl IterScan for Float64

type Output = Float64

impl IterScan for QuadDouble

type Output = QuadDouble

impl<M> IterScan for MInt<M>

where M: MIntConvert + MIntBase<Inner: FromStr>,

type Output = MInt<M>

impl<T> IterScan for Saturating<T>

where T: IterScan<Output = T>,

type Output = Saturating<T>

impl<T> IterScan for Wrapping<T>

where T: IterScan<Output = T>,

type Output = Wrapping<T>

impl<T, B> IterScan for SizedCollect<T, B>

where T: IterScan, B: FromIterator<<T as IterScan>::Output>,

type Output = B

impl<T: IterScan> IterScan for Complex<T>

type Output = Complex<<T as IterScan>::Output>