Enum Rec

pub enum Rec<T> {
    AliasSubstituted,
    Parsed(T),
}

Modifier that makes a result of parsing optional in order to trigger the parser to restart parsing after alias substitution

Rec stands for “recursion”, as it is used to make the parser work recursively.

This enum type has two variants: AliasSubstituted and Parsed. The former contains no meaningful value and is returned from a parsing function that has performed alias substitution without consuming any tokens. In this case, the caller of the parsing function must inspect the new source code produced by the substitution so that the syntax is correctly recognized in the new code.

Assume we have an alias definition untrue='! true', for example. When the word untrue is recognized as an alias name during parse of a simple command, the simple command parser function must stop parsing and return AliasSubstituted. This allows the caller, the pipeline parser function, to recognize the ! reserved word token as negation.

When a parser function successfully parses something, it returns the result in the Parsed variant. The caller then continues the remaining parse.

Variants

AliasSubstituted

Result of alias substitution

Parsed(T)

Successful parse result

Implementations

impl<T> Rec<T>

pub fn is_alias_substituted(&self) -> bool

Tests if self is AliasSubstituted.

pub fn unwrap(self) -> T

Extracts the result of successful parsing.

Panics

If self is AliasSubstituted.

pub fn map<U, F>(self, f: F) -> Result<Rec<U>>

where F: FnOnce(T) -> Result<U>,

Transforms the result value in self.

Trait Implementations

impl<T: Clone> Clone for Rec<T>

fn clone(&self) -> Rec<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Rec<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Rec<T>

fn eq(&self, other: &Rec<T>) -> 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<T: Copy> Copy for Rec<T>

impl<T: Eq> Eq for Rec<T>

impl<T> StructuralPartialEq for Rec<T>