Enum kalosm_sample::ParseResult

pub enum ParseResult<'a, P, R> {
    Incomplete {
        new_state: P,
        required_next: Cow<'static, str>,
    },
    Finished {
        result: R,
        remaining: &'a [u8],
    },
}

The state of a parser.

Variants

Incomplete

Fields

new_state: P

The new state of the parser.

required_next: Cow<'static, str>

The text that is required next.

The parser is incomplete.

Finished

Fields

result: R

The result of the parser.

remaining: &'a [u8]

The remaining input.

The parser is finished.

Implementations

impl<'a, P, R> ParseResult<'a, P, R>

pub fn without_remaining(self) -> ParseResult<'static, P, R>

Take the remaining bytes from the parser.

pub fn unwrap_finished(self) -> R

Unwrap the parser to a finished result.

pub fn unwrap_incomplete(self) -> (P, Cow<'static, str>)

Unwrap the parser to an incomplete result.

pub fn map<F, O>(self, f: F) -> ParseResult<'a, P, O>

where F: FnOnce(R) -> O,

Map the result of the parser.

pub fn map_state<F, O>(self, f: F) -> ParseResult<'a, O, R>

where F: FnOnce(P) -> O,

Map the state of the parser.

Trait Implementations

impl<'a, P: Clone, R: Clone> Clone for ParseResult<'a, P, R>

fn clone(&self) -> ParseResult<'a, P, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, P: Debug, R: Debug> Debug for ParseResult<'a, P, R>

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

Formats the value using the given formatter.

impl<P, R> From<ParseResult<'_, P, R>> for OwnedParseResult<P, R>

fn from(result: ParseResult<'_, P, R>) -> Self

Converts to this type from the input type.

impl<'a, P: PartialEq, R: PartialEq> PartialEq for ParseResult<'a, P, R>

fn eq(&self, other: &ParseResult<'a, P, R>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, P: Eq, R: Eq> Eq for ParseResult<'a, P, R>

impl<'a, P, R> StructuralPartialEq for ParseResult<'a, P, R>