Trait Scan 

pub trait Scan: Sized {
    type Output;

    // Required method
    fn scan<S: ScanSource>(source: &mut S) -> Option<Self::Output>;
}

Required Associated Types

type Output

Required Methods

fn scan<S: ScanSource>(source: &mut S) -> 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 Scan for ()

type Output = ()

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

impl Scan for String

type Output = String

fn scan<I: ScanSource>(iter: &mut I) -> Option<Self>

impl Scan for char

type Output = char

fn scan<I: ScanSource>(iter: &mut I) -> Option<Self>

impl Scan for f32

type Output = f32

fn scan<I: ScanSource>(iter: &mut I) -> Option<Self>

impl Scan for f64

type Output = f64

fn scan<I: ScanSource>(iter: &mut I) -> Option<Self>

impl Scan for i8

type Output = i8

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for i16

type Output = i16

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for i32

type Output = i32

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for i64

type Output = i64

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for i128

type Output = i128

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for isize

type Output = isize

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for u8

type Output = u8

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for u16

type Output = u16

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for u32

type Output = u32

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for u64

type Output = u64

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for u128

type Output = u128

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

impl Scan for usize

type Output = usize

fn scan<S: ScanSource>(source: &mut S) -> Option<Self>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

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

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

fn scan<It: ScanSource>(_iter: &mut It) -> Option<Self::Output>

Implementors

impl Scan for Byte1

type Output = u8

impl Scan for Bytes

type Output = Vec<u8>

impl Scan for Chars

type Output = Vec<char>

impl Scan for Decimal

type Output = Decimal

impl Scan for DoubleDouble

type Output = DoubleDouble

impl Scan for Float32

type Output = Float32

impl Scan for Float64

type Output = Float64

impl Scan for QuadDouble

type Output = QuadDouble

impl Scan for Usize1

type Output = usize

impl<M> Scan for MInt<M>

where M: MIntConvert + MIntBase<Inner: Scan<Output = M::Inner>>,

type Output = MInt<M>

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

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

type Output = B

impl<T: Scan> Scan for Complex<T>

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

impl<T> Scan for Saturating<T>

where T: Scan<Output = T>,

type Output = Saturating<T>

impl<T> Scan for Wrapping<T>

where T: Scan<Output = T>,

type Output = Wrapping<T>