Struct Hidden 

pub struct Hidden<T>(/* private fields */);

Wrapper that hides a grammar element from BNF output.

Parses and prints just like the wrapped grammar, but is omitted from BNF. Useful for structural elements like whitespace.

type Ws = Hidden<StringOf<IsSpace>>;

Or use #[grammar(hidden)]:

#[derive(Grammar)]
#[grammar(hidden)]
struct Ws(StringOf<IsSpace>);

Trait Implementations

impl<T: Clone> Clone for Hidden<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Hidden<T>

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

Formats the value using the given formatter.

impl<T> Deref for Hidden<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for Hidden<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: Eq> Eq for Hidden<T>

impl<T: Grammar> Grammar for Hidden<T>

type First = <OptionalFirst<EmptyByteSet> 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<T: Grammar> GrammarRule for Hidden<T>

const NAME: &'static str = "Hidden"

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<T: Hash> Hash for Hidden<T>

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<T> IntoInner<T> for Hidden<T>

fn into_inner(self) -> T

Consume self, discarding whatever structure wrapped T.

impl<T: PartialEq> PartialEq for Hidden<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for Hidden<T>