Enum Parsed

pub enum Parsed<Token, Stream, Context> {
    Success {
        token: Token,
        stream: Stream,
    },
    Failure(Context),
    Error(Context),
}

Parsed represent the result of a parse().

Variants

Success

When parser successfully parse the stream

Fields

token: Token

token produced by the parser.

stream: Stream

the stream used by the parser, should have less item than before.

Failure(Context)

When parser fail to parse the stream. This is not fatal and is a normal behavior for a parser.

Error(Context)

When parser encouter an error, this should be fatal. Could be a programming error or something wrong will the stream.

Implementations

impl<Token, Stream, Context> Parsed<Token, Stream, Context>

pub const fn new_success(token: Token, stream: Stream) -> Self

Shortcut for Parsed::Success { token, stream }

pub const fn new_failure(content: Context) -> Self

Shortcut for Parsed::Failure(context_handle)

pub const fn new_error(content: Context) -> Self

Shortcut for Parsed::Error(context_handle)

pub const fn as_ref(&self) -> Parsed<&Token, &Stream, &Context>

Borrow Parsed to make temporary Parsed of reference

pub fn map_success<MappedToken, Map>( self, map: Map, ) -> Parsed<MappedToken, Stream, Context>

where Map: FnOnce(Success<Token, Stream>) -> Success<MappedToken, Stream>,

Allow to quickly access success to map it.

pub fn map_token<MappedToken, Map>( self, map: Map, ) -> Parsed<MappedToken, Stream, Context>

where Map: FnOnce(Token) -> MappedToken,

Allow to quickly access token to map it.

pub fn map_stream<Map>(self, map: Map) -> Parsed<Token, Stream, Context>

where Map: FnOnce(Stream) -> Stream,

Allow to quickly access stream to map it.

pub fn map_context<MappedAtom, Map>( self, map: Map, ) -> Parsed<Token, Stream, MappedAtom>

where Map: FnOnce(Context) -> MappedAtom,

Allow to quickly access context to map it.

pub fn add_context<C, Map>(self, map: Map) -> Parsed<Token, Stream, Context>

where Map: FnOnce() -> C, Context: Contexting<C>,

Shortcut to add a Atom to the Context

pub fn unwrap(self) -> Success<Token, Stream>

where Context: Debug,

Return Success if Parsed is Success otherwise panic. Use only for testing purpose.

pub fn unwrap_context(self) -> Context

where Token: Debug, Stream: Debug,

Return Context if Parsed is Failure or Error otherwise panic. Use only for testing purpose.

pub const fn is_success(&self) -> bool

Return true if Parsed is Success.

Trait Implementations

impl<Token: Clone, Stream: Clone, Context: Clone> Clone for Parsed<Token, Stream, Context>

fn clone(&self) -> Parsed<Token, Stream, Context>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Token: Debug, Stream: Debug, Context: Debug> Debug for Parsed<Token, Stream, Context>

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

Formats the value using the given formatter.

impl<'de, Token, Stream, Context> Deserialize<'de> for Parsed<Token, Stream, Context>

where Token: Deserialize<'de>, Stream: Deserialize<'de>, Context: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Token, Stream, Context> Display for Parsed<Token, Stream, Context>

where Token: Debug, Stream: Streaming, Context: ProvideElement,

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

Formats the value using the given formatter.

impl<Token, Stream, Context> From<Success<Token, Stream>> for Parsed<Token, Stream, Context>

fn from(_: Success<Token, Stream>) -> Self

Converts to this type from the input type.

impl<Token, Stream, Context> FromResidual<ParsedAux<Infallible, Context>> for Parsed<Token, Stream, Context>

fn from_residual(residual: ParsedAux<Infallible, Context>) -> Self

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

Constructs the type from a compatible Residual type.

impl<Token, Stream, Context> FromResidual<Result<Infallible, Context>> for Parsed<Token, Stream, Context>

fn from_residual(residual: Result<Infallible, Context>) -> Self

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

Constructs the type from a compatible Residual type.

impl<Token, Stream, Context> FromResidual for Parsed<Token, Stream, Context>

fn from_residual(residual: Parsed<Infallible, Infallible, Context>) -> Self

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

Constructs the type from a compatible Residual type.

impl<Token: Hash, Stream: Hash, Context: Hash> Hash for Parsed<Token, Stream, Context>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Token: Ord, Stream: Ord, Context: Ord> Ord for Parsed<Token, Stream, Context>

fn cmp(&self, other: &Parsed<Token, Stream, Context>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Token: PartialEq, Stream: PartialEq, Context: PartialEq> PartialEq for Parsed<Token, Stream, Context>

fn eq(&self, other: &Parsed<Token, Stream, Context>) -> 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<Token: PartialOrd, Stream: PartialOrd, Context: PartialOrd> PartialOrd for Parsed<Token, Stream, Context>

fn partial_cmp( &self, other: &Parsed<Token, Stream, Context>, ) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Token, Stream, Context> Serialize for Parsed<Token, Stream, Context>

where Token: Serialize, Stream: Serialize, Context: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Token, Stream, Context> Try for Parsed<Token, Stream, Context>

type Output = Success<Token, Stream>

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

The type of the value produced by ? when not short-circuiting.

type Residual = Parsed<Infallible, Infallible, Context>

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

The type of the value passed to FromResidual::from_residual as part of ? when short-circuiting.

fn from_output(output: Self::Output) -> Self

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

Constructs the type from its Output type.

fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

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

Used in ? to decide whether the operator should produce a value (because this returned ControlFlow::Continue) or propagate a value back to the caller (because this returned ControlFlow::Break).

impl<Token: Eq, Stream: Eq, Context: Eq> Eq for Parsed<Token, Stream, Context>

impl<Token, Stream, Context> StructuralPartialEq for Parsed<Token, Stream, Context>