Trait ScanFromStr 

pub trait ScanFromStr<'a>: Sized {
    type Output;

    // Required method
    fn scan_from<I: ScanInput<'a>>(
        s: I,
    ) -> Result<(Self::Output, usize), ScanError>;

    // Provided method
    fn wants_leading_junk_stripped() -> bool { ... }
}

This trait defines the interface to a type which can be scanned.

The exact syntax scanned is entirely arbitrary, though there are some rules of thumb that implementations should generally stick to:

• Do not ignore leading whitespace.
• Do not eagerly consume trailing whitespace, unless it is legitimately part of the scanned syntax.

In addition, if you are implementing scanning directly for the result type (i.e. Output = Self), prefer parsing only the result of the type’s Debug implementation. This ensures that there is a degree of round-tripping between format! and scan!.

If a type has multiple legitimate parsing forms, consider defining those alternate forms on abstract scanner types (i.e. Output != Self) instead.

See: ScanSelfFromStr.

Required Associated Types

type Output

The type that the implementation scans into. This does not have to be the same as the implementing type, although it typically will be.

See: ScanSelfFromStr::scan_self_from.

Required Methods

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

Perform a scan on the given input.

Implementations must return either the scanned value, and the number of bytes consumed from the input, or a reason why scanning failed.

Provided Methods

fn wants_leading_junk_stripped() -> bool

Indicates whether or not the scanner wants its input to have leading “junk”, such as whitespace, stripped.

The default implementation returns true, which is almost always the correct answer. You should only implement this explicitly (and return false) if you are implementing a scanner for which leading whitespace is important.

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<'a> ScanFromStr<'a> for SocketAddr

type Output = SocketAddr

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for bool

type Output = bool

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for char

type Output = char

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for f32

type Output = f32

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for f64

type Output = f64

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for i8

type Output = i8

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for i16

type Output = i16

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for i32

type Output = i32

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for i64

type Output = i64

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for isize

type Output = isize

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for u8

type Output = u8

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for u16

type Output = u16

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for u32

type Output = u32

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for u64

type Output = u64

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for ()

type Output = ()

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for usize

type Output = usize

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for String

type Output = String

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for Ipv4Addr

type Output = Ipv4Addr

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for Ipv6Addr

type Output = Ipv6Addr

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for SocketAddrV4

type Output = SocketAddrV4

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for SocketAddrV6

type Output = SocketAddrV6

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a> ScanFromStr<'a> for RangeFull

type Output = RangeFull

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, K, V> ScanFromStr<'a> for BTreeMap<K, V>

where K: ScanFromStr<'a, Output = K> + Ord, V: ScanFromStr<'a, Output = V>,

type Output = BTreeMap<<K as ScanFromStr<'a>>::Output, <V as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, K, V> ScanFromStr<'a> for HashMap<K, V>

where K: ScanFromStr<'a, Output = K> + Hash + Eq, V: ScanFromStr<'a, Output = V>,

type Output = HashMap<<K as ScanFromStr<'a>>::Output, <V as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T0, T1, T2, T3> ScanFromStr<'a> for (T0, T1, T2, T3)

where T0: ScanFromStr<'a>, T1: ScanFromStr<'a>, T2: ScanFromStr<'a>, T3: ScanFromStr<'a>,

type Output = (<T0 as ScanFromStr<'a>>::Output, <T1 as ScanFromStr<'a>>::Output, <T2 as ScanFromStr<'a>>::Output, <T3 as ScanFromStr<'a>>::Output)

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T1, T2, T3> ScanFromStr<'a> for (T1, T2, T3)

where T1: ScanFromStr<'a>, T2: ScanFromStr<'a>, T3: ScanFromStr<'a>,

type Output = (<T1 as ScanFromStr<'a>>::Output, <T2 as ScanFromStr<'a>>::Output, <T3 as ScanFromStr<'a>>::Output)

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T2, T3> ScanFromStr<'a> for (T2, T3)

where T2: ScanFromStr<'a>, T3: ScanFromStr<'a>,

type Output = (<T2 as ScanFromStr<'a>>::Output, <T3 as ScanFromStr<'a>>::Output)

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T3> ScanFromStr<'a> for (T3,)

where T3: ScanFromStr<'a>,

type Output = (<T3 as ScanFromStr<'a>>::Output,)

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for Option<T>

where T: ScanFromStr<'a>,

type Output = Option<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 0]

type Output = [T; 0]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 1]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 1]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 2]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 2]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 3]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 3]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 4]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 4]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 5]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 5]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 6]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 6]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 7]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 7]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for [T; 8]

where T: ScanFromStr<'a>,

type Output = [<T as ScanFromStr<'a>>::Output; 8]

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for BinaryHeap<T>

where T: ScanFromStr<'a, Output = T> + Ord,

type Output = BinaryHeap<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for BTreeSet<T>

where T: ScanFromStr<'a, Output = T> + Ord,

type Output = BTreeSet<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for LinkedList<T>

where T: ScanFromStr<'a, Output = T>,

type Output = LinkedList<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for VecDeque<T>

where T: ScanFromStr<'a, Output = T>,

type Output = VecDeque<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for Vec<T>

where T: ScanFromStr<'a, Output = T>,

type Output = Vec<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for Range<T>

where T: ScanFromStr<'a, Output = T>,

type Output = Range<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for RangeFrom<T>

where T: ScanFromStr<'a, Output = T>,

type Output = RangeFrom<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for RangeTo<T>

where T: ScanFromStr<'a, Output = T>,

type Output = RangeTo<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T> ScanFromStr<'a> for HashSet<T>

where T: ScanFromStr<'a, Output = T> + Hash + Eq,

type Output = HashSet<<T as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

impl<'a, T, E> ScanFromStr<'a> for Result<T, E>

where T: ScanFromStr<'a>, E: ScanFromStr<'a>,

type Output = Result<<T as ScanFromStr<'a>>::Output, <E as ScanFromStr<'a>>::Output>

fn scan_from<I: ScanInput<'a>>(s: I) -> Result<(Self::Output, usize), ScanError>

Implementors

impl<'a> ScanFromStr<'a> for QuotedString

type Output = String

impl<'a> ScanFromStr<'a> for Iso8601Duration

type Output = Duration

impl<'a, K, V> ScanFromStr<'a> for KeyValuePair<K, V>

where K: ScanSelfFromStr<'a>, V: ScanSelfFromStr<'a>,

type Output = (K, V)

impl<'a, Output> ScanFromStr<'a> for Binary<Output>

where Output: ScanFromBinary<'a>,

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Everything<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Hex<Output>

where Output: ScanFromHex<'a>,

type Output = Output

impl<'a, Output> ScanFromStr<'a> for HorSpace<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Ident<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Line<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Newline<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for NonSpace<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Number<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Octal<Output>

where Output: ScanFromOctal<'a>,

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Space<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Word<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, Output> ScanFromStr<'a> for Wordish<'a, Output>

where &'a str: Into<Output>,

Available on non-str_into_output_extra_broken only.

type Output = Output

impl<'a, T> ScanFromStr<'a> for Inferred<T>

where T: ScanSelfFromStr<'a>,

type Output = T