Enum gluon_base::types::Type

pub enum Type<Id, T = ArcType<Id>> {
    Hole,
    Opaque,
    Error,
    Builtin(BuiltinType),
    Forall(Vec<Generic<Id>>, T, Option<Vec<T>>),
    App(T, AppVec<T>),
    Function(ArgType, T, T),
    Record(T),
    Variant(T),
    Effect(T),
    EmptyRow,
    ExtendRow {
        types: Vec<Field<Id, Alias<Id, T>>>,
        fields: Vec<Field<Id, T>>,
        rest: T,
    },
    Ident(Id),
    Projection(AppVec<Id>),
    Variable(TypeVariable),
    Generic(Generic<Id>),
    Alias(AliasRef<Id, T>),
    Skolem(Skolem<Id>),
}

The representation of gluon’s types.

For efficiency this enum is not stored directly but instead a pointer wrapper which derefs to Type is used to enable types to be shared. It is recommended to use the static functions on Type such as Type::app and Type::record when constructing types as those will construct the pointer wrapper directly.

Variants

Hole

An unbound type _, awaiting ascription.

Opaque

An opaque type

Error

A type used to mark type errors

Builtin(BuiltinType)

A builtin type

Forall(Vec<Generic<Id>>, T, Option<Vec<T>>)

Universally quantified types

App(T, AppVec<T>)

A type application with multiple arguments. For example, Map String Int would be represented as App(Map, [String, Int]).

Function(ArgType, T, T)

Function type which can have a explicit or implicit argument

Record(T)

Record constructor, of kind Row -> Type

Variant(T)

Variant constructor, of kind Row -> Type

Effect(T)

Effect constructor, of kind Row -> Type -> Type

EmptyRow

The empty row, of kind Row

ExtendRow

Fields

types: Vec<Field<Id, Alias<Id, T>>>

The associated types of this record type

fields: Vec<Field<Id, T>>

The fields of this record type

rest: T

The rest of the row

Row extension, of kind ... -> Row -> Row

Ident(Id)

An identifier type. These are created during parsing, but should all be resolved into Type::Aliases during type checking.

Identifiers are also sometimes used inside aliased types to avoid cycles in reference counted pointers. This is a bit of a wart at the moment and may cause spurious unification failures.

Projection(AppVec<Id>)

Variable(TypeVariable)

An unbound type variable that may be unified with other types. These will eventually be converted into Type::Generics during generalization.

Generic(Generic<Id>)

A variable that needs to be instantiated with a fresh type variable when the binding is referred to.

Alias(AliasRef<Id, T>)

Skolem(Skolem<Id>)

Implementations

impl<Id, T> Type<Id, T>

pub fn as_variable(&self) -> Option<&TypeVariable>

impl<Id, T> Type<Id, T>where
    T: From<Type<Id, T>>,

pub fn hole() -> T

pub fn opaque() -> T

pub fn error() -> T

pub fn builtin(typ: BuiltinType) -> T

pub fn forall(params: Vec<Generic<Id>>, typ: T) -> T

pub fn forall_with_vars(
    params: Vec<Generic<Id>>,
    typ: T,
    vars: Option<Vec<T>>
) -> T

pub fn array(typ: T) -> T

pub fn array_builtin() -> T

pub fn app(id: T, args: AppVec<T>) -> T

pub fn variant(fields: Vec<Field<Id, T>>) -> T

pub fn poly_variant(fields: Vec<Field<Id, T>>, rest: T) -> T

pub fn effect(fields: Vec<Field<Id, T>>) -> T

pub fn poly_effect(fields: Vec<Field<Id, T>>, rest: T) -> T

pub fn tuple<S, I>(symbols: &mut S, elems: I) -> Twhere
    S: ?Sized + IdentEnv<Ident = Id>,
    I: IntoIterator<Item = T>,

pub fn tuple_<S, I>(symbols: &mut S, elems: I) -> Type<Id, T>where
    S: ?Sized + IdentEnv<Ident = Id>,
    I: IntoIterator<Item = T>,

pub fn record(
    types: Vec<Field<Id, Alias<Id, T>>>,
    fields: Vec<Field<Id, T>>
) -> T

pub fn poly_record(
    types: Vec<Field<Id, Alias<Id, T>>>,
    fields: Vec<Field<Id, T>>,
    rest: T
) -> T

pub fn extend_row(
    types: Vec<Field<Id, Alias<Id, T>>>,
    fields: Vec<Field<Id, T>>,
    rest: T
) -> T

pub fn empty_row() -> T

pub fn function(args: Vec<T>, ret: T) -> Twhere
    T: Clone,

pub fn function_implicit<I>(args: I, ret: T) -> Twhere
    I: IntoIterator<Item = T>,
    I::IntoIter: DoubleEndedIterator<Item = T>,

pub fn function_type<I>(arg_type: ArgType, args: I, ret: T) -> Twhere
    I: IntoIterator<Item = T>,
    I::IntoIter: DoubleEndedIterator<Item = T>,

pub fn generic(typ: Generic<Id>) -> T

pub fn skolem(typ: Skolem<Id>) -> T

pub fn variable(typ: TypeVariable) -> T

pub fn alias(name: Id, args: Vec<Generic<Id>>, typ: T) -> T

pub fn ident(id: Id) -> T

pub fn projection(id: AppVec<Id>) -> T

pub fn function_builtin() -> T

pub fn string() -> T

pub fn char() -> T

pub fn byte() -> T

pub fn int() -> T

pub fn float() -> T

pub fn unit() -> T

impl<Id, T> Type<Id, T>where
    T: Deref<Target = Type<Id, T>>,

pub fn as_function(&self) -> Option<(&T, &T)>

pub fn as_explicit_function(&self) -> Option<(&T, &T)>

pub fn as_function_with_type(&self) -> Option<(ArgType, &T, &T)>

pub fn unapplied_args(&self) -> Cow<'_, [T]>where
    T: Clone,

pub fn alias_ident(&self) -> Option<&Id>

pub fn applied_alias(&self) -> Option<&AliasRef<Id, T>>

pub fn is_non_polymorphic_record(&self) -> bool

pub fn params(&self) -> &[Generic<Id>]

pub fn kind(&self) -> Cow<'_, ArcKind>

impl<T> Type<Symbol, T>where
    T: Deref<Target = Type<Symbol, T>>,

pub fn name(&self) -> Option<&SymbolRef>

Returns the name of self Example: Option a => Option Int => Int

Trait Implementations

impl<Id: Clone, T: Clone> Clone for Type<Id, T>

fn clone(&self) -> Type<Id, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Id: Debug, T: Debug> Debug for Type<Id, T>

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

Formats the value using the given formatter.

impl<Id> From<Type<Id, ArcType<Id>>> for ArcType<Id>

fn from(typ: Type<Id, ArcType<Id>>) -> ArcType<Id>

Converts to this type from the input type.

impl<Id> From<Type<Id, AstType<Id>>> for AstType<Id>

fn from(typ: Type<Id, AstType<Id>>) -> Self

Converts to this type from the input type.

impl<Id: Hash, T: Hash> Hash for Type<Id, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Id: PartialEq, T: PartialEq> PartialEq<Type<Id, T>> for Type<Id, T>

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

impl<Id, T> StructuralEq for Type<Id, T>

impl<Id, T> StructuralPartialEq for Type<Id, T>