Enum cl_typeck::inference::Type

pub enum Type {
    Variable(Variable),
    Operator(Operator),
}

A Type::Variable or Type::Operator:

• A Type::Variable can be either bound or unbound (instance: Some(_) | None)
• A Type::Operator has a name (used to identify the operator) and a list of types.

A type which contains unbound variables is considered “generic” (see Type::is_generic()).

Variants

Variable(Variable)

Operator(Operator)

Implementations

impl Type

pub fn new_var() -> RcType

Creates a new unbound type variable

pub fn new_inst(of: &RcType) -> RcType

Creates a variable that is a new instance of another Type

pub fn new_op(name: Sym, types: &[RcType]) -> RcType

Creates a new type operator

pub fn new_fn(takes: &RcType, returns: &RcType) -> RcType

Creates a new type operator representing a lambda

pub fn new_prim(name: Sym) -> RcType

Creates a new type operator representing a primitive type

pub fn new_tuple(members: &[RcType]) -> RcType

Creates a new type operator representing a tuple

pub fn set_instance(self: &RcType, of: &RcType)

Sets this type variable to be an instance of the other

Panics

Panics if self is not a type variable

pub fn is_generic(self: &RcType) -> bool

Checks whether there are any unbound type variables in this type.

let bool = Type::new_op("bool".into(), &[]);
let true_v = Type::new_inst(&bool);
let unbound = Type::new_var();
let id_fun = Type::new_fn(&unbound, &unbound);
let truthy = Type::new_fn(&unbound, &bool);
assert!(!bool.is_generic());   // bool contains no unbound type variables
assert!(!true_v.is_generic()); // true_v is bound to `bool`
assert!(unbound.is_generic()); // unbound is an unbound type variable
assert!(id_fun.is_generic());  // id_fun is a function with unbound type variables
assert!(truthy.is_generic());  // truthy is a function with one unbound type variable

pub fn deep_clone(self: &RcType) -> RcType

Makes a deep copy of a type expression.

Bound variables are shared, unbound variables are duplicated.

pub fn prune(self: &RcType) -> RcType

Returns the defining instance of self, collapsing type instances along the way.

May panic

Panics if this type variable’s instance field is already borrowed.

Examples

let t_bool = Type::new_op("bool".into(), &[]);
let t_nest = Type::new_inst(&Type::new_inst(&Type::new_inst(&t_bool)));
let pruned = t_nest.prune();
assert_eq!(pruned, t_bool);
assert_eq!(t_nest, Type::new_inst(&t_bool));

pub fn occurs_in(self: &RcType, other: &RcType) -> bool

Checks whether a type expression occurs in another type expression

Note:

• Since the test uses strict equality, self should be pruned prior to testing.
• The test is not guaranteed to terminate for recursive types.

pub fn unify(self: &RcType, other: &RcType) -> Result<(), InferenceError>

Unifies two type expressions, propagating changes via interior mutability

Trait Implementations

impl Debug for Type

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

Formats the value using the given formatter.

impl Display for Type

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

Formats the value using the given formatter.

impl PartialEq for Type

fn eq(&self, other: &Type) -> 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 Eq for Type

impl StructuralPartialEq for Type