Struct NotFollowedBy 

pub struct NotFollowedBy<G>(/* private fields */);

Zero-width negative lookahead: matches the empty string, but only when the following input does not match the wrapped grammar. Consumes nothing and prints nothing.

// "/" that is not the start of a "//" line comment.
#[derive(Grammar)]
struct Div(StringEq!("/"), NotFollowedBy<StringEq!("/")>);
assert!(Div::parse("/").is_ok());
assert!(Div::parse("//").is_err());

Trait Implementations

impl<G> Clone for NotFollowedBy<G>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G> Copy for NotFollowedBy<G>

impl<G> Debug for NotFollowedBy<G>

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

Formats the value using the given formatter.

impl<G> Default for NotFollowedBy<G>

fn default() -> Self

Returns the “default value” for a type.

impl<G> Eq for NotFollowedBy<G>

impl<G: Grammar> Grammar for NotFollowedBy<G>

type First = OptionalFirst<EmptyByteSet>

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<G> Hash for NotFollowedBy<G>

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<G> PartialEq for NotFollowedBy<G>

fn eq(&self, _other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.