Trait lark_parser::syntax::Syntax

pub trait Syntax<'parse>: DebugWith {
    type Data;
    fn test(&mut self, parser: &Parser<'parse>) -> bool;
    fn expect(
        &mut self, 
        parser: &mut Parser<'parse>
    ) -> Result<Self::Data, ErrorReported>;
}

Associated Types

type Data

The value that is produced (often, but not always, Self) by the parsing routine.

Loading content...

Required methods

fn test(&mut self, parser: &Parser<'parse>) -> bool

Routine to check if this syntax applies. This often does a much more shallow check than expect, e.g., just checking an initial token or two.

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

Routine to do the parsing itself. This will produce a parse error if the syntax is not found at the current point.

Relationship to test: If test returns false, errors are guaranteed. Even if test returns true, however, errors are still possible, since test does a more shallow check.

Loading content...

Implementations on Foreign Types

impl<T, 'parse, '_> Syntax<'parse> for &'_ mut T where
    T: Syntax<'parse>, 

type Data = T::Data

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

Loading content...

Implementors

impl<'parse> Syntax<'parse> for EntitySyntax

type Data = ParsedEntity

fn test(&mut self, parser: &Parser) -> bool

fn expect(&mut self, parser: &mut Parser) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for FunctionSignature

type Data = ParsedFunctionSignature

fn test(&mut self, parser: &Parser) -> bool

fn expect(&mut self, parser: &mut Parser) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for SpannedGlobalIdentifier

type Data = Spanned<GlobalIdentifier, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for SpannedLocalIdentifier

type Data = Spanned<&'parse str, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Field

type Data = Spanned<ParsedField, FileName>

fn test(&mut self, parser: &Parser) -> bool

fn expect(&mut self, parser: &mut Parser) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Member

type Data = Spanned<ParsedMember, FileName>

fn test(&mut self, parser: &Parser) -> bool

fn expect(&mut self, parser: &mut Parser) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for CloseCurly

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for CloseParenthesis

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for CloseSquare

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Colon

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Comma

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Dot

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Equals

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for ExclamationPoint

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Let

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Minus

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for OpenCurly

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for OpenParenthesis

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for OpenSquare

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Plus

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for RightArrow

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Semicolon

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Slash

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for Star

type Data = Spanned<LexToken, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<'parse> Syntax<'parse> for TypeReference

type Data = ParsedTypeReference

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<ParsedTypeReference, ErrorReported>

impl<D, 'parse> Syntax<'parse> for Matched<D> where
    D: Delimiter<'parse>, 

type Data = Spanned<ParsedMatch, FileName>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<D, T, 'parse> Syntax<'parse> for Delimited<D, T> where
    D: Delimiter<'parse>,
    T: Syntax<'parse>, 

type Data = T::Data

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<G, V, 'parse> Syntax<'parse> for Guard<G, V> where
    G: NonEmptySyntax<'parse>,
    V: Syntax<'parse>, 

type Data = V::Data

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<T, 'parse> Syntax<'parse> for CommaList<T> where
    T: Syntax<'parse>, 

type Data = Seq<T::Data>

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Seq<T::Data>, ErrorReported>

impl<T, 'parse> Syntax<'parse> for SkipNewline<T> where
    T: Syntax<'parse>, 

type Data = T::Data

fn test(&mut self, parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Self::Data, ErrorReported>

impl<T, S, 'parse> Syntax<'parse> for SeparatedList<T, S> where
    T: Syntax<'parse>,
    S: Syntax<'parse>, 

type Data = Seq<T::Data>

fn test(&mut self, _parser: &Parser<'parse>) -> bool

fn expect(
    &mut self,
    parser: &mut Parser<'parse>
) -> Result<Seq<T::Data>, ErrorReported>

Loading content...