Struct arithmetic_typing::Annotated

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

Grammar with support of type annotations. Works as a decorator.

Examples

use arithmetic_parser::grammars::{F32Grammar, Parse};
use arithmetic_typing::Annotated;

let code = "x: [Num] = (1, 2, 3);";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;

Trait Implementations

impl<T: Debug> Debug for Annotated<T>

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

Formats the value using the given formatter.

impl<T: ParseLiteral> Grammar for Annotated<T>

type Type<'a> = TypeAst<'a>

Type of the type annotation used in the grammar. This type may be parametric by the input lifetime.

fn parse_type(input: InputSpan<'_>) -> NomResult<'_, Self::Type<'_>>

Attempts to parse a type annotation.

impl<T: ParseLiteral> Parse for Annotated<T>

Supports all syntax features.

type Base = Annotated<T>

Base for the grammar providing the literal and type annotation parsers.

const FEATURES: Features = _

Features supported by this grammar.

fn parse_statements<'a, I>(input: I) -> Result<Block<'a, Self::Base>, Error>

where I: IntoInputSpan<'a>, Self: Sized,

Parses a list of statements.

fn parse_streaming_statements<'a, I>( input: I, ) -> Result<Block<'a, Self::Base>, Error>

where I: IntoInputSpan<'a>, Self: Sized,

Parses a potentially incomplete list of statements.

impl<T: ParseLiteral> ParseLiteral for Annotated<T>

type Lit = <T as ParseLiteral>::Lit

Type of the literal used in the grammar.

fn parse_literal(input: InputSpan<'_>) -> NomResult<'_, Self::Lit>

Attempts to parse a literal.