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", so this trait is not object safe.

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, M::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>