Enum Type 

#[non_exhaustive]
pub enum Type<Prim: PrimitiveType = Num> {
    Any,
    Dyn(DynConstraints<Prim>),
    Prim(Prim),
    Function(Box<Function<Prim>>),
    Tuple(Tuple<Prim>),
    Object(Object<Prim>),
    Var(TypeVar),
}

Enumeration encompassing all types supported by the type system.

Parametric by the PrimitiveType.

Notation

• Self::Any is represented as any.
• Self::Dyn types are represented as documented in DynConstraints.
• Primitive types are represented using the Display implementation of the corresponding PrimitiveType.
• Vars are represented as documented in TypeVar.
• Notation for functional and tuple types is documented separately.

Examples

There are conversions to construct Types eloquently:

let tuple: Type = (Type::BOOL, Type::NUM).into();
assert_eq!(tuple.to_string(), "(Bool, Num)");
let slice = tuple.repeat(UnknownLen::param(0));
assert_eq!(slice.to_string(), "[(Bool, Num); N]");
let fn_type: Type = Function::builder()
    .with_arg(slice)
    .returning(Type::NUM)
    .into();
assert_eq!(fn_type.to_string(), "([(Bool, Num); N]) -> Num");

A Type can also be parsed from a string:

let slice = <Type>::try_from(&TypeAst::try_from("[(Bool, Num)]")?)?;
assert_matches!(slice, Type::Tuple(t) if t.as_slice().is_some());
let fn_type = <Type>::try_from(&TypeAst::try_from("([(Bool, Num); N]) -> Num")?)?;
assert_matches!(fn_type, Type::Function(_));

Any type

Self::Any, denoted as any, is a catch-all type similar to any in TypeScript. It allows to circumvent type system limitations at the cost of being exteremely imprecise. any type can be used in any context (destructured, called with args of any quantity and type and so on), with each application of the type evaluated independently. Thus, the same any variable can be treated as a function, a tuple, a primitive type, etc.

let code = r#"
    wildcard: any = 1; // `any` can be assigned from anything
    wildcard == 1 && wildcard == (2, 3);
    (x, y, ...) = wildcard; // destructuring `any` always succeeds
    wildcard(1, |x| x + 1); // calling `any` as a funcion works as well
"#;
let ast = Annotated::<F32Grammar>::parse_statements(code)?;
let mut env = TypeEnvironment::new();
env.process_statements(&ast)?;

// Destructure outputs are certain types that can be inferred
// from their usage, rather than `any`!
assert_matches!(env["x"], Type::Var(_));
let bogus_code = "x + 1 == 2; x(1)";
let ast = Annotated::<F32Grammar>::parse_statements(bogus_code)?;
let errors = env.process_statements(&ast).unwrap_err();
let err = errors.iter().next().unwrap();
assert_eq!(*err.main_span().fragment(), "x(1)");

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.

Any

Any type aka “I’ll think about typing later”. Similar to any type in TypeScript. See the dedicated section for more details.

Dyn(DynConstraints<Prim>)

Arbitrary type implementing certain constraints. Similar to dyn _ types in Rust or use of interfaces in type position in TypeScript.

See DynConstraints for details.

Prim(Prim)

Primitive type.

Function(Box<Function<Prim>>)

Functional type.

Tuple(Tuple<Prim>)

Tuple type.

Object(Object<Prim>)

Object type.

Var(TypeVar)

Type variable.

Implementations

impl Type

pub const NUM: Self

Numeric primitive type.

impl<Prim: WithBoolean> Type<Prim>

pub const BOOL: Self

Boolean primitive type.

impl<Prim: PrimitiveType> Type<Prim>

pub fn void() -> Self

Returns a void type (an empty tuple).

pub fn param(index: usize) -> Self

Creates a bounded type variable with the specified index.

pub fn slice( element: impl Into<Type<Prim>>, length: impl Into<TupleLen>, ) -> Self

Creates a slice type.

pub fn repeat(self, length: impl Into<TupleLen>) -> Slice<Prim>

Creates a slice type by repeating this type.

pub fn is_void(&self) -> bool

Checks if this type is void (i.e., an empty tuple).

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.

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<Prim> From<()> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: ()) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>> From<(T,)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T,)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>> From<(T, U)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>> From<(T, U, V)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>, W: Into<Type<Prim>>> From<(T, U, V, W)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V, W)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>, W: Into<Type<Prim>>, X: Into<Type<Prim>>> From<(T, U, V, W, X)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V, W, X)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>, W: Into<Type<Prim>>, X: Into<Type<Prim>>, Y: Into<Type<Prim>>> From<(T, U, V, W, X, Y)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V, W, X, Y)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>, W: Into<Type<Prim>>, X: Into<Type<Prim>>, Y: Into<Type<Prim>>, Z: Into<Type<Prim>>> From<(T, U, V, W, X, Y, Z)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V, W, X, Y, Z)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>, W: Into<Type<Prim>>, X: Into<Type<Prim>>, Y: Into<Type<Prim>>, Z: Into<Type<Prim>>, A: Into<Type<Prim>>> From<(T, U, V, W, X, Y, Z, A)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V, W, X, Y, Z, A)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>, W: Into<Type<Prim>>, X: Into<Type<Prim>>, Y: Into<Type<Prim>>, Z: Into<Type<Prim>>, A: Into<Type<Prim>>, B: Into<Type<Prim>>> From<(T, U, V, W, X, Y, Z, A, B)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V, W, X, Y, Z, A, B)) -> Self

Converts to this type from the input type.

impl<Prim, T: Into<Type<Prim>>, U: Into<Type<Prim>>, V: Into<Type<Prim>>, W: Into<Type<Prim>>, X: Into<Type<Prim>>, Y: Into<Type<Prim>>, Z: Into<Type<Prim>>, A: Into<Type<Prim>>, B: Into<Type<Prim>>, C: Into<Type<Prim>>> From<(T, U, V, W, X, Y, Z, A, B, C)> for Type<Prim>

where Prim: PrimitiveType,

fn from(tuple: (T, U, V, W, X, Y, Z, A, B, C)) -> Self

Converts to this type from the input type.

impl<Prim: WithBoolean> From<Assertions> for Type<Prim>

fn from(value: Assertions) -> Self

Converts to this type from the input type.

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

fn from(constraints: DynConstraints<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PrimitiveType> From<FnWithConstraints<Prim>> for Type<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: PrimitiveType> From<Object<Prim>> for Type<Prim>

fn from(object: Object<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: WithBoolean> From<Prelude> for Type<Prim>

fn from(value: Prelude) -> Self

Converts to this type from the input type.

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

fn from(slice: Slice<Prim>) -> Self

Converts to this type from the input type.

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

fn from(tuple: Tuple<Prim>) -> Self

Converts to this type from the input type.

impl<Prim: PrimitiveType> PartialEq for Type<Prim>

fn eq(&self, other: &Self) -> 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, Prim: PrimitiveType> TryFrom<&LocatedSpan<&'a str, TypeAst<'a>>> for Type<Prim>

type Error = Errors<'a, Prim>

The type returned in the event of a conversion error.

fn try_from(ast: &SpannedTypeAst<'a>) -> Result<Self, Self::Error>

Performs the conversion.