Struct arithmetic_parser::grammars::Untyped

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

Wrapper for ParseLiteral types that allows to use them as a Grammar or Parser.

When used as a Grammar, type annotations are not supported; any use of an annotation will lead to a parsing error. When used as a Parser, all Features are on except for type annotations.

Examples

See ParseLiteral docs for an example of usage.

Trait Implementations

impl<T: Debug> Debug for Untyped<T>

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

Formats the value using the given formatter.

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

type Type<'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 Untyped<T>

type Base = Untyped<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 Untyped<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.