Enum IResult

pub enum IResult<I, O, E = u32> {
    Done(I, O),
    Error(ErrorKind<E>),
    Incomplete(Needed),
}

A Result of any parsing action.

If the input is invalid, an IResult::Error will be returned. Note that incomplete data is not considered invalid, and so will not return an error, but rather a IResult::Incomplete(_). Holds the result of parsing functions

It depends on I, the input type, O, the output type, and E, the error type (by default u32)

Variants

Done(I, O)

indicates a correct parsing, the first field containing the rest of the unparsed data, the second field contains the parsed data

Error(ErrorKind<E>)

contains a Err, an enum that can indicate an error code, a position in the input, and a pointer to another error, making a list of errors in the parsing tree

Incomplete(Needed)

Incomplete contains a Needed, an enum than can represent a known quantity of input data, or unknown

Implementations

impl<I, O, E> IResult<I, O, E>

pub fn map_err<N, F>(self, f: F) -> IResult<I, O, N>

where F: FnOnce(ErrorKind<E>) -> ErrorKind<N>,

Maps a IResult<I, O, E> to IResult<I, O, N> by appling a function to a contained Error value, leaving Done and Incomplete value untouched.

pub fn unwrap_err(self) -> ErrorKind<E>

Unwrap the contained Error(E) value, or panic if the IResult is not Error.

pub fn to_full_result(self) -> Result<O, IError<E>>

Convert the IResult to a std::result::Result

pub fn to_result(self) -> Result<O, ErrorKind<E>>

Convert the IResult to a std::result::Result, or panic if the IResult is Incomplete

impl<I, O, E> IResult<I, O, E>

pub fn is_done(&self) -> bool

pub fn is_err(&self) -> bool

pub fn is_incomplete(&self) -> bool

pub fn or(self, other: IResult<I, O, E>) -> IResult<I, O, E>

pub fn map<N, F>(self, f: F) -> IResult<I, N, E>

where F: FnOnce(O) -> N,

Maps a IResult<I, O, E> to IResult<I, N, E> by appling a function to a contained Done value, leaving Error and Incomplete value untouched.

pub fn map_inc<F>(self, f: F) -> IResult<I, O, E>

where F: FnOnce(Needed) -> Needed,

Maps a IResult<I, O, E> to IResult<I, O, E> by appling a function to a contained Incomplete value, leaving Done and Error value untouched.

pub fn unwrap(self) -> (I, O)

Unwrap the contained Done(I, O) value, or panic if the IResult is not Done.

pub fn unwrap_or(self, default: (I, O)) -> (I, O)

Unwrap the contained Done(I, O) value or a default if the IResult is not Done.

pub fn unwrap_inc(self) -> Needed

Unwrap the contained Incomplete(n) value, or panic if the IResult is not Incomplete.

Trait Implementations

impl<I, O, E> Clone for IResult<I, O, E>

where I: Clone, O: Clone, E: Clone,

fn clone(&self) -> IResult<I, O, E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I, O, E> Debug for IResult<I, O, E>

where I: Debug, O: Debug, E: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a, I, O, E> GetInput<&'a [I]> for IResult<&'a [I], O, E>

fn remaining_input(&self) -> Option<&'a [I]>

impl<'a, O, E> GetInput<&'a str> for IResult<&'a str, O, E>

fn remaining_input(&self) -> Option<&'a str>

impl<O, E> GetInput<()> for IResult<(), O, E>

fn remaining_input(&self) -> Option<()>

impl<'a, I, O, E> GetOutput<&'a [O]> for IResult<I, &'a [O], E>

fn output(&self) -> Option<&'a [O]>

impl<'a, I, E> GetOutput<&'a str> for IResult<I, &'a str, E>

fn output(&self) -> Option<&'a str>

impl<I, E> GetOutput<()> for IResult<I, (), E>

fn output(&self) -> Option<()>

impl<I, O, E> PartialEq for IResult<I, O, E>

where I: PartialEq, O: PartialEq, E: PartialEq,

fn eq(&self, other: &IResult<I, O, E>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I, O, E> Eq for IResult<I, O, E>

where I: Eq, O: Eq, E: Eq,

impl<I, O, E> StructuralPartialEq for IResult<I, O, E>