Enum erg_compiler::ty::Type

pub enum Type {
    Obj,
    Int,
    Nat,
    Ratio,
    Float,
    Complex,
    Bool,
    Str,
    NoneType,
    Code,
    Frame,
    Error,
    Inf,
    NegInf,
    Type,
    ClassType,
    TraitType,
    Patch,
    NotImplementedType,
    Ellipsis,
    Never,
    Mono(Str),
    Ref(Box<Type>),
    RefMut {
        before: Box<Type>,
        after: Option<Box<Type>>,
    },
    Subr(SubrType),
    Callable {
        param_ts: Vec<Type>,
        return_t: Box<Type>,
    },
    Record(Dict<Field, Type>),
    Refinement(RefinementType),
    Quantified(Box<Type>),
    And(Box<Type>, Box<Type>),
    Or(Box<Type>, Box<Type>),
    Not(Box<Type>),
    Poly {
        name: Str,
        params: Vec<TyParam>,
    },
    Proj {
        lhs: Box<Type>,
        rhs: Str,
    },
    ProjCall {
        lhs: Box<TyParam>,
        attr_name: Str,
        args: Vec<TyParam>,
    },
    Structural(Box<Type>),
    FreeVar(FreeTyVar),
    Failure,
    Uninited,
}

Variants

Obj

Int

Nat

Ratio

Float

Complex

Bool

Str

NoneType

Code

Frame

Error

Inf

NegInf

Type

ClassType

TraitType

Patch

NotImplementedType

Ellipsis

Never

Mono(Str)

Ref(Box<Type>)

RefMut

Fields

before: Box<Type>

after: Option<Box<Type>>

Subr(SubrType)

Callable

Fields

param_ts: Vec<Type>

return_t: Box<Type>

Record(Dict<Field, Type>)

Refinement(RefinementType)

Quantified(Box<Type>)

And(Box<Type>, Box<Type>)

Or(Box<Type>, Box<Type>)

Not(Box<Type>)

Poly

Fields

name: Str

params: Vec<TyParam>

Proj

Fields

lhs: Box<Type>

rhs: Str

ProjCall

Fields

lhs: Box<TyParam>

attr_name: Str

args: Vec<TyParam>

Structural(Box<Type>)

FreeVar(FreeTyVar)

Failure

Uninited

used to represent TyParam is not initialized (see erg_compiler::context::instantiate_tp)

Implementations

impl Type

pub const OBJ: &'static Self = _

pub const NONE: &'static Self = _

pub const NOT_IMPLEMENTED: &'static Self = _

pub const ELLIPSIS: &'static Self = _

pub const INF: &'static Self = _

pub const NEG_INF: &'static Self = _

pub const NEVER: &'static Self = _

pub const FAILURE: &'static Self = _

pub fn mutate(self) -> Self

pub fn quantify(self) -> Self

pub fn proj<S: Into<Str>>(self, attr: S) -> Self

pub fn structuralize(self) -> Self

pub fn is_simple_class(&self) -> bool

pub fn is_procedure(&self) -> bool

Procedure

pub fn is_mut_type(&self) -> bool

pub fn is_nonelike(&self) -> bool

pub fn is_union_type(&self) -> bool

pub fn is_intersection_type(&self) -> bool

pub fn is_refinement(&self) -> bool

pub fn is_record(&self) -> bool

pub fn is_erg_module(&self) -> bool

pub fn is_py_module(&self) -> bool

pub fn is_method(&self) -> bool

pub fn is_subr(&self) -> bool

pub fn is_quantified_subr(&self) -> bool

pub fn is_array(&self) -> bool

pub fn is_structural(&self) -> bool

pub fn as_free(&self) -> Option<&FreeTyVar>

pub fn contains_tvar(&self, target: &FreeTyVar) -> bool

pub fn contains(&self, target: &Type) -> bool

pub fn is_recursive(&self) -> bool

pub fn args_ownership(&self) -> ArgsOwnership

pub fn ownership(&self) -> Ownership

pub fn qual_name(&self) -> Str

full name of the type, if the type is a normal nominal type, then returns the inner name

let i = mono("Int!");
assert_eq!(&i.qual_name()[..], "Int!");
assert_eq!(&i.local_name()[..], "Int!");
let t = mono("http.client.Response");
assert_eq!(&t.qual_name()[..], "http.client.Response");
assert_eq!(&t.local_name()[..], "Response");

pub fn local_name(&self) -> Str

local name of the type

let i = mono("Int!");
assert_eq!(&i.qual_name()[..], "Int!");
assert_eq!(&i.local_name()[..], "Int!");
let t = mono("http.client.Response");
assert_eq!(&t.qual_name()[..], "http.client.Response");
assert_eq!(&t.local_name()[..], "Response");

pub fn contains_intersec(&self, typ: &Type) -> bool

assert!((A and B).contains_intersec(B))

pub fn union_types(&self) -> Option<(Type, Type)>

pub fn contains_union(&self, typ: &Type) -> bool

assert!((A or B).contains_union(B))

pub fn tvar_name(&self) -> Option<Str>

pub fn q_constraint(&self) -> Option<Constraint>

pub fn get_super(&self) -> Option<Type>

pub fn get_sub(&self) -> Option<Type>

pub const fn is_free_var(&self) -> bool

pub const fn is_callable(&self) -> bool

pub fn is_unbound_var(&self) -> bool

pub fn is_monomorphic(&self) -> bool

See also: is_monomorphized

pub fn is_monomorphized(&self) -> bool

Set(Int, 3) is not monomorphic but monomorphized

pub fn into_refinement(self) -> RefinementType

pub fn deconstruct_refinement(self) -> Result<(Str, Type, Predicate), Type>

pub fn coerce(&self)

Fix type variables at their lower bound

i: ?T(:> Int)
assert i.Real == 1
i: (Int)

pub fn qvars(&self) -> Set<(Str, Constraint)>

pub fn qnames(&self) -> Set<Str>

pub fn has_uninited_qvars(&self) -> bool

pub fn is_qvar(&self) -> bool

pub fn has_qvar(&self) -> bool

if the type is polymorphic

pub fn has_no_qvar(&self) -> bool

pub fn has_unbound_var(&self) -> bool

pub fn has_no_unbound_var(&self) -> bool

pub fn typarams_len(&self) -> Option<usize>

pub fn container_len(&self) -> Option<usize>

pub fn typarams(&self) -> Vec<TyParam>

pub fn self_t(&self) -> Option<&Type>

pub fn non_default_params(&self) -> Option<&Vec<ParamTy>>

pub fn var_params(&self) -> Option<&ParamTy>

pub fn default_params(&self) -> Option<&Vec<ParamTy>>

pub fn non_var_params(&self) -> Option<impl Iterator<Item = &ParamTy> + Clone>

pub fn return_t(&self) -> Option<&Type>

pub fn mut_return_t(&mut self) -> Option<&mut Type>

pub fn derefine(&self) -> Type

pub fn replace(self, target: &Type, to: &Type) -> Type

pub fn normalize(self) -> Self

TyParam::Value(ValueObj::Type(_)) => TyParam::Type

Trait Implementations

impl BitAnd<Type> for Type

type Output = Type

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitOr<Type> for Type

type Output = Type

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl CanbeFree for Type

fn unbound_name(&self) -> Option<Str>

fn constraint(&self) -> Option<Constraint>

fn update_constraint(&self, new_constraint: Constraint, in_instantiation: bool)

impl Clone for Type

fn clone(&self) -> Type

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl Default for Type

fn default() -> Type

Returns the “default value” for a type.

impl Display for Type

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

Formats the value using the given formatter.

impl From<&Type> for TypeCode

fn from(arg: &Type) -> Self

Converts to this type from the input type.

impl From<Dict<Field, Type>> for Type

fn from(rec: Dict<Field, Type>) -> Self

Converts to this type from the input type.

impl From<Dict<Type, Type>> for Type

fn from(d: Dict<Type, Type>) -> Self

Converts to this type from the input type.

impl From<Range<&TyParam>> for Type

fn from(r: Range<&TyParam>) -> Self

Converts to this type from the input type.

impl From<Range<TyParam>> for Type

fn from(r: Range<TyParam>) -> Self

Converts to this type from the input type.

impl From<RangeInclusive<&TyParam>> for Type

fn from(r: RangeInclusive<&TyParam>) -> Self

Converts to this type from the input type.

impl From<RangeInclusive<TyParam>> for Type

fn from(r: RangeInclusive<TyParam>) -> Self

Converts to this type from the input type.

impl HasLevel for Type

fn level(&self) -> Option<usize>

fn set_level(&self, level: Level)

fn lower(&self, level: Level)

fn lift(&self)

fn generalize(&self)

fn is_generalized(&self) -> bool

impl HasType for Type

fn ref_t(&self) -> &Type

fn ref_mut_t(&mut self) -> &mut Type

fn inner_ts(&self) -> Vec<Type>

fn signature_t(&self) -> Option<&Type>

fn signature_mut_t(&mut self) -> Option<&mut Type>

fn t(&self) -> Type

fn lhs_t(&self) -> &Type

fn rhs_t(&self) -> &Type

impl Hash for Type

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 LimitedDisplay for Type

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

impl Not for Type

type Output = Type

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<Type> for Type

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

fn structural_eq(&self, other: &Self) -> bool

impl<'a> TryFrom<&'a TyParam> for &'a Type

type Error = ()

The type returned in the event of a conversion error.

fn try_from(tp: &'a TyParam) -> Result<&'a Type, ()>

Performs the conversion.

impl<'a> TryFrom<&'a ValueObj> for &'a Type

type Error = ()

The type returned in the event of a conversion error.

fn try_from(val: &'a ValueObj) -> Result<Self, ()>

Performs the conversion.

impl<'t> TryFrom<&'t Type> for &'t FreeTyVar

type Error = ()

The type returned in the event of a conversion error.

fn try_from(t: &'t Type) -> Result<&'t FreeTyVar, ()>

Performs the conversion.

impl<'t> TryFrom<&'t Type> for &'t SubrType

type Error = ()

The type returned in the event of a conversion error.

fn try_from(t: &'t Type) -> Result<&'t SubrType, ()>

Performs the conversion.

impl TryFrom<TyParam> for Type

type Error = ()

The type returned in the event of a conversion error.

fn try_from(tp: TyParam) -> Result<Type, ()>

Performs the conversion.

impl TryFrom<Type> for SubrType

type Error = ()

The type returned in the event of a conversion error.

fn try_from(t: Type) -> Result<Self, ()>

Performs the conversion.

impl TryFrom<ValueObj> for Type

type Error = ()

The type returned in the event of a conversion error.

fn try_from(val: ValueObj) -> Result<Type, ()>

Performs the conversion.

impl Eq for Type