Enum TypeAst 

#[non_exhaustive]
pub enum TypeAst<'a> {
    Some,
    Any,
    Dyn(TypeConstraintsAst<'a>),
    Ident,
    Param,
    Function(Box<FunctionAst<'a>>),
    FunctionWithConstraints {
        constraints: Spanned<'a, ConstraintsAst<'a>>,
        function: Box<Spanned<'a, FunctionAst<'a>>>,
    },
    Tuple(TupleAst<'a>),
    Slice(SliceAst<'a>),
    Object(ObjectAst<'a>),
}

Type annotation after parsing.

Compared to Type, this enum corresponds to AST, not to the logical presentation of a type.

Examples

use arithmetic_parser::InputSpan;

let input = InputSpan::new("(Num, ('T) -> ('T, 'T))");
let (_, ty) = TypeAst::parse(input)?;
let elements = match ty.extra {
    TypeAst::Tuple(elements) => elements,
    _ => unreachable!(),
};
assert_eq!(elements.start[0].extra, TypeAst::Ident);
assert_matches!(
    &elements.start[1].extra,
    TypeAst::Function { .. }
);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Some

Type placeholder (_). Corresponds to a certain type that is not specified, like _ in type annotations in Rust.

Any

Any type (any).

Dyn(TypeConstraintsAst<'a>)

Dynamically applied constraints (dyn _).

Ident

Non-ticked identifier, e.g., Bool.

Param

Ticked identifier, e.g., 'T.

Function(Box<FunctionAst<'a>>)

Functional type.

FunctionWithConstraints

Functional type with constraints.

Fields

constraints: Spanned<'a, ConstraintsAst<'a>>

Constraints on function params.

function: Box<Spanned<'a, FunctionAst<'a>>>

Function body.

Tuple(TupleAst<'a>)

Tuple type; for example, (Num, Bool).

Slice(SliceAst<'a>)

Slice type; for example, [Num] or [(Num, T); N].

Object(ObjectAst<'a>)

Object type; for example, { len: Num }. Not to be confused with object constraints.

Implementations

impl<'a> TypeAst<'a>

pub fn try_from( def: &'a str, ) -> Result<SpannedTypeAst<'a>, SpannedError<&'a str>>

Parses type AST from a string.

impl<'a> TypeAst<'a>

pub fn parse(input: InputSpan<'a>) -> NomResult<'a, Spanned<'a, Self>>

Parses input as a type. This parser can be composed using nom infrastructure.

Trait Implementations

impl<'a> Clone for TypeAst<'a>

fn clone(&self) -> TypeAst<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TypeAst<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for TypeAst<'a>

fn eq(&self, other: &TypeAst<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for TypeAst<'a>