[][src]Struct combine::parser::byte::OctDigit

pub struct OctDigit<I>(_, _)
where
    I: Stream<Item = u8>,
    I::Error: ParseError<u8, I::Range, I::Position>
;

Trait Implementations

impl<I> Parser for OctDigit<I> where
    I: Stream<Item = u8>,
    I::Error: ParseError<u8, I::Range, I::Position>, 
[src]

type Input = I

The type which is taken as input for the parser. The type must implement the Stream trait which allows the parser to read items from the type. Read more

type Output = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::Output

The type which is returned if the parser is successful.

type PartialState = <Expected<Satisfy<I, fn(_: u8) -> bool>> as Parser>::PartialState

Determines the state necessary to resume parsing after more input is supplied. Read more

fn easy_parse<I>(
    &mut self,
    input: I
) -> Result<(Self::Output, I), ParseError<I>> where
    I: Stream,
    Stream<I>: StreamOnce<Item = I::Item, Range = I::Range, Error = ParseError<Stream<I>>, Position = I::Position>,
    I::Position: Default,
    Self: Sized + Parser<Input = Stream<I>>, 
[src]

Entry point of the parser. Takes some input and tries to parse it, returning an easy to use and format error if parsing did not succeed. Read more

fn parse(
    &mut self,
    input: Self::Input
) -> Result<(Self::Output, Self::Input), <Self::Input as StreamOnce>::Error>
[src]

Entry point of the parser. Takes some input and tries to parse it. Read more

fn parse_with_state(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Self::Input as StreamOnce>::Error>
[src]

Entry point of the parser when using partial parsing. Takes some input and tries to parse it. Read more

fn parse_stream(
    &mut self,
    input: &mut Self::Input
) -> ParseResult<Self::Output, Self::Input>
[src]

Parses using the stream input by calling [Stream::uncons] one or more times. Read more

fn parse_stream_consumed(
    &mut self,
    input: &mut Self::Input
) -> ConsumedResult<Self::Output, Self::Input>
[src]

Parses using the stream input by calling [Stream::uncons] one or more times. Read more

fn parse_stream_consumed_partial(
    &mut self,
    input: &mut Self::Input,
    state: &mut Self::PartialState
) -> ConsumedResult<Self::Output, Self::Input>
[src]

Important traits for &'a mut W
fn by_ref(&mut self) -> &mut Self where
    Self: Sized
[src]

Borrows a parser instead of consuming it. Read more

fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 
[src]

Discards the value of the self parser and returns the value of p. Fails if any of the parsers fails. Read more

fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 
[src]

Discards the value of the p parser and returns the value of self. Fails if any of the parsers fails. Read more

fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input = Self::Input>, 
[src]

Parses with self followed by p. Succeeds if both parsers succeed, otherwise fails. Returns a tuple with both values on success. Read more

fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input = Self::Input, Output = Self::Output>, 
[src]

Returns a parser which attempts to parse using self. If self fails without consuming any input it tries to consume the same input using p. Read more

fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input = Self::Input>, 
[src]

Parses using self and then passes the value to f which returns a parser used to parse the rest of the input. Read more

fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input = Self::Input>, 
[src]

Variant of then which parses using self and then passes the value to f as a &mut reference. Read more

fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 
[src]

Uses f to map over the parsed value. Read more

fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Self::Input as StreamOnce>::Error>, 
[src]

Uses f to map over the output of self. If f returns an error the parser fails. Read more

fn message<S>(self, msg: S) -> Message<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 
[src]

Parses with self and if it fails, adds the message msg to the error. Read more

fn expected<S>(self, msg: S) -> Expected<Self> where
    Self: Sized,
    S: Into<Info<<Self::Input as StreamOnce>::Item, <Self::Input as StreamOnce>::Range>>, 
[src]

Parses with self and if it fails without consuming any input any expected errors are replaced by msg. msg is then used in error messages as "Expected msg". Read more

fn silent(self) -> Silent<Self> where
    Self: Sized
[src]

Parses with self, if it fails without consuming any input any expected errors that would otherwise be emitted by self are suppressed. Read more

fn and_then<F, O, E, I>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input = I> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    I: Stream,
    E: Into<<I::Error as ParseError<I::Item, I::Range, I::Position>>::StreamError>, 
[src]

Parses with self and applies f on the result if self parses successfully. f may optionally fail with an error which is automatically converted to a ParseError. Read more

Important traits for Iter<'a, P, S, M>
fn iter(
    self,
    input: &mut Self::Input
) -> Iter<Self, Self::PartialState, FirstMode> where
    Self: Parser + Sized
[src]

Creates an iterator from a parser and a state. Can be used as an alternative to [many] when collecting directly into a Extend type is not desirable. Read more

Important traits for Iter<'a, P, S, M>
fn partial_iter<'a, 's, M>(
    self,
    mode: M,
    input: &'a mut Self::Input,
    partial_state: &'s mut Self::PartialState
) -> Iter<'a, Self, &'s mut Self::PartialState, M> where
    Self: Parser + Sized,
    M: ParseMode, 
[src]

Creates an iterator from a parser and a state. Can be used as an alternative to [many] when collecting directly into a Extend type is not desirable. Read more

Important traits for Box<W>
fn boxed<'a>(
    self
) -> Box<dyn Parser<Input = Self::Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 
[src]

Turns the parser into a trait object by putting it in a Box. Can be used to easily return parsers from functions without naming the type. Read more

Important traits for Either<L, R>
fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input = Self::Input, Output = Self::Output>, 
[src]

Wraps the parser into the Either enum which allows combinators such as then to return multiple different parser types (merging them to one) Read more

Important traits for Either<L, R>
fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input = Self::Input, Output = Self::Output>, 
[src]

Wraps the parser into the Either enum which allows combinators such as then to return multiple different parser types (merging them to one) Read more

impl<I: Clone> Clone for OctDigit<I> where
    I: Stream<Item = u8>,
    I::Error: ParseError<u8, I::Range, I::Position>, 
[src]

fn clone_from(&mut self, source: &Self)
1.0.0
[src]

Performs copy-assignment from source. Read more

Auto Trait Implementations

impl<I> Send for OctDigit<I> where
    I: Send,
    <I as StreamOnce>::Range: Send

impl<I> Sync for OctDigit<I> where
    I: Sync,
    <I as StreamOnce>::Range: Sync

Blanket Implementations

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

impl<T, U> TryFrom for T where
    T: From<U>, 
[src]

type Error = !

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

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

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

The type returned in the event of a conversion error.

impl<T> Any for T where
    T: 'static + ?Sized
[src]