Struct arithmetic_typing::Function

pub struct Function<Prim: PrimitiveType = Num> { /* private fields */ }

Functional type.

Notation

Functional types are denoted as follows:

for<len! M; 'T: Lin> (['T; N], 'T) -> ['T; M]

Here:

• len! M and 'T: Lin are constraints on length params and type params, respectively. Length and/or type params constraints may be empty. Unconstrained type / length params (such as length N in the example) do not need to be mentioned.
• len! M means that M is a static length.
• Lin is a constraint on the type param.
• N, M and 'T are parameter names. The args and the return type may reference these parameters.
• ['T; N] and 'T are types of the function arguments.
• ['T; M] is the return type.

The for constraints can only be present on top-level functions, but not in functions mentioned in args / return types of other functions.

The -> _ part is mandatory, even if the function returns Type::void().

A function may accept variable number of arguments of the same type along with other args. (This construction is known as varargs.) This is denoted similarly to middles in Tuples. For example, (...[Num; N]) -> Num denotes a function that accepts any number of Num args and returns a Num value.

Construction

Functional types can be constructed via Self::builder() or parsed from a string.

With Self::builder(), type / length params are implicit; they are computed automatically when a function or FnWithConstraints is supplied to a TypeEnvironment. Computations include both the function itself, and any child functions.

Examples

let fn_type: Function = FunctionAst::try_from("([Num; N]) -> Num")?
    .try_convert()?;
assert_eq!(*fn_type.return_type(), Type::NUM);
assert_matches!(
    fn_type.args().parts(),
    ([Type::Tuple(t)], None, [])
        if t.as_slice().map(Slice::element) == Some(&Type::NUM)
);

Implementations

impl<Prim: PrimitiveType> Function<Prim>

pub fn builder() -> FunctionBuilder<Prim>

Returns a builder for Functions.

pub fn args(&self) -> &Tuple<Prim>

Gets the argument types of this function.

pub fn return_type(&self) -> &Type<Prim>

Gets the return type of this function.

pub fn is_concrete(&self) -> bool

Returns true iff this type does not contain type / length variables.

See TypeEnvironment for caveats of dealing with non-concrete types.

pub fn with_constraints<C: Constraint<Prim>>( self, indexes: &[usize], constraint: C, ) -> FnWithConstraints<Prim>

Marks type params with the specified indexes to have constraints.

Panics

• Panics if parameters were already computed for the function.

pub fn with_static_lengths(self, indexes: &[usize]) -> FnWithConstraints<Prim>

Marks lengths with the specified indexes as static.

Panics

• Panics if parameters were already computed for the function.

Trait Implementations

impl<Prim: Clone + PrimitiveType> Clone for Function<Prim>

fn clone(&self) -> Function<Prim>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Prim: Debug + PrimitiveType> Debug for Function<Prim>

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

Formats the value using the given formatter.

impl<Prim: PrimitiveType> Display for Function<Prim>

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

Formats the value using the given formatter.

impl<Prim: PrimitiveType> From<FnWithConstraints<Prim>> for Function<Prim>

fn from(value: FnWithConstraints<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PrimitiveType> From<Function<Prim>> for Type<Prim>

fn from(fn_type: Function<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PartialEq + PrimitiveType> PartialEq for Function<Prim>

fn eq(&self, other: &Function<Prim>) -> 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<Prim: PrimitiveType> StructuralPartialEq for Function<Prim>