Enum binator::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

Fields

token: Token

token produced by the parser.

stream: Stream

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

When parser successfully parse the stream

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 + PartialOrd,

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

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<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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method 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>