Struct Prefix 

pub struct Prefix<P, T> {
    pub prefixed: T,
    /* private fields */
}

Sequence of two grammars, Deref-ing to the second.

Fields

prefixed: T

The prefixed value.

Implementations

impl<P, T> Prefix<P, T>

pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Prefix<P, U>

Apply f to the prefixed value, keeping prefix unchanged.

impl<P, T, E> Prefix<P, Result<T, E>>

pub fn transpose(self) -> Result<Prefix<P, T>, E>

Swap Prefix<P, Result<T, E>> for Result<Prefix<P, T>, E>.

Trait Implementations

impl<P: Clone, T: Clone> Clone for Prefix<P, T>

fn clone(&self) -> Prefix<P, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug, T: Debug> Debug for Prefix<P, T>

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

Formats the value using the given formatter.

impl<P, T> Deref for Prefix<P, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<P: Eq, T: Eq> Eq for Prefix<P, T>

impl<P: Grammar, T: Grammar> Grammar for Prefix<P, T>

type First = <<OptionalFirst<EmptyByteSet> as First>::Concat<P> as First>::Concat<T>

The set of bytes (and whether empty input is valid) this grammar could start with.

fn parse_at(input: &str, pos: usize, state: State<'_>) -> Option<(Self, usize)>

Attempt to parse Self starting at pos, returning the value and the position just past it, or None on failure.

fn scan_at(input: &str, pos: usize, state: State<'_>) -> Option<usize>

Like parse_at, but only checks well-formedness and returns the end position.

fn print_to(&self, buf: &mut String)

Serialize self back to text, appending to buf.

fn to_bnf() -> Expr

Describe this grammar as a BNF/EBNF expression, for use in a referencing rule’s own definition.

fn fail_at(pos: usize, state: State<'_>) -> bool

Record what this grammar would have expected at pos, without attempting to actually parse — used when a caller already knows (e.g. via First) that this alternative cannot match here, but still wants it traced.

fn parse(input: &str) -> Result<Self, Error>

Parse the entire input as Self, failing if any input is left unconsumed.

fn parse_prefix(input: &str) -> Result<(Self, usize), Error>

Like parse, but doesn’t require consuming all of input — returns the byte position just past the match, leaving any remaining input unexamined.

fn scan(input: &str) -> Result<(), Error>

Like parse, but only checks that input is well-formed and discards the parsed value.

fn scan_prefix(input: &str) -> Result<usize, Error>

Like scan, but doesn’t require consuming all of input — returns the byte position just past the match, leaving any remaining input unexamined.

fn print(&self) -> String

Serialize self to a new String; see print_to.

impl<P: Grammar, T: Grammar> GrammarRule for Prefix<P, T>

const NAME: &'static str = "Prefix"

The rule’s name in BNF output; defaults to the type name.

fn to_bnf_def() -> Expr

This rule’s own definition, as opposed to to_bnf, which is how other rules refer to it.

fn bnf_rule() -> String

Format this rule as a complete BNF line: NAME = <definition> ..

impl<P, T> IntoInner<T> for Prefix<P, T>

fn into_inner(self) -> T

Consume self, discarding whatever structure wrapped T.

impl<P: PartialEq, T: PartialEq> PartialEq for Prefix<P, T>

fn eq(&self, other: &Prefix<P, T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<P: PartialEq, T: PartialEq> StructuralPartialEq for Prefix<P, T>