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

Fields

fields: T::Fields

The fields of this record type

rest: T

The rest of the row

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

ExtendTypeRow

Fields

types: T::TypeFields

The associated types of this record type

rest: T

The rest of the row

Row extension, of kind ... -> Row -> 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, I>(symbols: &mut S, elems: I) -> T

where S: ?Sized + IdentEnv<Ident = Id>, T::SpannedId: From<(Id, Span<BytePos>)>, I: IntoIterator<Item = T>, T: From<(Type<Id, T>, Flags)> + HasSpan,

pub fn tuple_<S, I>(symbols: &mut S, elems: I) -> Type<Id, T>

where S: ?Sized + IdentEnv<Ident = Id>, T::SpannedId: From<(Id, Span<BytePos>)>, I: IntoIterator<Item = T>, T: From<(Type<Id, T>, Flags)> + HasSpan,

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> AstClone<'ast, Id> for Type<Id, T>

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

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

impl<Id> Borrow<Type<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<'de, Id, T> DeserializeState<'de, Seed<Id, T>> for Type<Id, T>

where T: Clone + TypePtr<Id = Id> + From<Type<Id, T>> + Any + DeserializeState<'de, Seed<Id, T>>, T::Types: Default + Extend<T>, T::Generics: Default + Extend<Generic<Id>> + Clone, T::Fields: DeserializeState<'de, Seed<Id, T>>, T::TypeFields: DeserializeState<'de, Seed<Id, T>>, Id: DeserializeState<'de, Seed<Id, T>> + Clone + Any,

fn deserialize_state<__D>( __seed: &mut Seed<Id, T>, __deserializer: __D ) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserializes Self using seed and the deserializer

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

where Id: PartialEq,

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

Converts to this type from the input type.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Id: PartialEq, T: PartialEq + TypePtr<Id = Id>> PartialEq 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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Id, T> SerializeState<SeSeed> for Type<Id, T>

where T: TypePtr<Id = Id> + SerializeState<SeSeed>, Id: SerializeState<SeSeed>, T::Fields: SerializeState<SeSeed>, T::TypeFields: SerializeState<SeSeed>,

fn serialize_state<__S>( &self, __serializer: __S, __seed: &SeSeed ) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serializes self

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, T: TypePtr<Id = Id>> StructuralEq for Type<Id, T>

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