Enum gluon_base::types::Type

pub enum Type<Id, T: TypePtr<Id = Id> = ArcType<Id>> {
    Hole,
    Opaque,
    Error,
    Builtin(BuiltinType),
    Forall(T::Generics, T),
    App(T, T::Types),
    Function(ArgType, T, T),
    Record(T),
    Variant(T),
    Effect(T),
    EmptyRow,
    ExtendRow {
        fields: T::Fields,
        rest: T,
    },
    ExtendTypeRow {
        types: T::TypeFields,
        rest: T,
    },
    Ident(KindedIdent<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(T::Generics, T)

Universally quantified types

App(T, T::Types)

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

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

Fields of ExtendRow

fields: T::Fields

The fields of this record type

rest: T

The rest of the row

ExtendTypeRow

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

Fields of ExtendTypeRow

types: T::TypeFields

The associated types of this record type

rest: T

The rest of the row

Ident(KindedIdent<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> where
    T: TypePtr<Id = Id>, 

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

impl<Id, T> Type<Id, T> where
    T: From<Type<Id, T>> + TypeExt<Id = Id>,
    T::Types: Default + Extend<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 array(typ: T) -> T

pub fn array_builtin() -> T

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

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

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

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

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

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

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

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

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

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

pub fn extend_row(fields: Vec<Field<T::SpannedId, T>>, rest: T) -> T

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

pub fn empty_row() -> T

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

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

pub fn function_type<I>(arg_type: ArgType, args: I, ret: T) -> T where
    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 alias_implicit(
    name: Id,
    args: Vec<Generic<Id>>,
    typ: T,
    is_implicit: bool
) -> T

pub fn ident(id: KindedIdent<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: TypePtr<Id = Id>, 

pub fn is_array(&self) -> bool

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<'k>(&'k self, cache: &'k KindCache) -> Cow<'k, ArcKind>

impl<T> Type<Symbol, T> where
    T: TypePtr<Id = Symbol>, 

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

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

pub fn owned_name(&self) -> Option<SymbolKey>

Trait Implementations

impl<'ast, Id, T: TypePtr<Id = Id>> AstClone<'ast, Id> for Type<Id, T> where
    Id: AstClone<'ast, Id>,
    T: AstClone<'ast, Id>,
    T::Generics: AstClone<'ast, Id>,
    T::Types: AstClone<'ast, Id>,
    T::Fields: AstClone<'ast, Id>,
    T::TypeFields: AstClone<'ast, Id>,
    Id: Clone, 

fn ast_clone(&self, arena: ArenaRef<'_, 'ast, Id>) -> Self

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

fn borrow(&self) -> &Type<Id, ArcType<Id>>

Immutably borrows from an owned value.

impl<Id: Clone, T: Clone + TypePtr<Id = Id>> Clone for Type<Id, T> where
    T::Generics: Clone,
    T::Types: Clone,
    T::Fields: Clone,
    T::TypeFields: Clone, 

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 + TypePtr<Id = Id>> Debug for Type<Id, T> where
    T::Generics: Debug,
    T::Types: Debug,
    T::Fields: Debug,
    T::TypeFields: Debug, 

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

Formats the value using the given formatter.

impl<Id, T> Default for Type<Id, T> where
    T: TypePtr<Id = Id>, 

fn default() -> Self

Returns the "default value" for a type.

impl<Id: Eq, T: Eq + TypePtr<Id = Id>> Eq for Type<Id, T> where
    T::Generics: Eq,
    T::Types: Eq,
    T::Fields: Eq,
    T::TypeFields: Eq, 

impl<Id> From<Type<Id, ArcType<Id>>> for ArcType<Id> where
    Id: PartialEq, 

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

Performs the conversion.

impl<Id: Hash, T: Hash + TypePtr<Id = Id>> Hash for Type<Id, T> where
    T::Generics: Hash,
    T::Types: Hash,
    T::Fields: Hash,
    T::TypeFields: Hash, 

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, 

Feeds a slice of this type into the given [Hasher].

impl<Id: PartialEq, T: PartialEq + TypePtr<Id = Id>> PartialEq<Type<Id, T>> for Type<Id, T> where
    T::Generics: PartialEq,
    T::Types: PartialEq,
    T::Fields: PartialEq,
    T::TypeFields: PartialEq, 

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: &Type<Id, T>) -> bool

This method tests for !=.

impl<Id, T: TypePtr<Id = Id>> StructuralEq for Type<Id, T>

impl<Id, T: TypePtr<Id = Id>> StructuralPartialEq for Type<Id, T>