Struct arithmetic_typing::ast::FunctionAst

#[non_exhaustive]
pub struct FunctionAst<'a> {
    pub args: Spanned<'a, TupleAst<'a>>,
    pub return_type: SpannedTypeAst<'a>,
}

Parsed functional type.

In contrast to Function, this struct corresponds to AST, not to the logical representation of functional types.

Examples

use arithmetic_parser::InputSpan;

let input = InputSpan::new("([Num; N]) -> Num");
let (rest, ty) = FunctionAst::parse(input)?;
assert!(rest.fragment().is_empty());
assert_matches!(ty.args.extra.start[0].extra, TypeAst::Slice(_));
assert_eq!(ty.return_type.extra, TypeAst::Ident);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

args: Spanned<'a, TupleAst<'a>>

Function arguments.

return_type: SpannedTypeAst<'a>

Return type of the function.

Implementations

impl<'a> FunctionAst<'a>

pub fn try_convert<Prim>(&self) -> Result<Function<Prim>, Errors<Prim>>

where Prim: PrimitiveType,

Tries to convert this type into a Function.

impl<'a> FunctionAst<'a>

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

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

Trait Implementations

impl<'a> Clone for FunctionAst<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for FunctionAst<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for FunctionAst<'a>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> TryFrom<&'a str> for FunctionAst<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(def: &'a str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> StructuralPartialEq for FunctionAst<'a>