Enum erg_type::Type

pub enum Type {
    Obj,
    Int,
    Nat,
    Ratio,
    Float,
    Bool,
    Str,
    NoneType,
    Code,
    Frame,
    Error,
    Inf,
    NegInf,
    Type,
    ClassType,
    TraitType,
    Patch,
    NotImplemented,
    Ellipsis,
    Never,
    BuiltinMono(Str),
    Mono {
        path: PathBuf,
        name: 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(QuantifiedType),
    And(Box<Type>, Box<Type>),
    Not(Box<Type>, Box<Type>),
    Or(Box<Type>, Box<Type>),
    BuiltinPoly {
        name: Str,
        params: Vec<TyParam>,
    },
    Poly {
        path: PathBuf,
        name: Str,
        params: Vec<TyParam>,
    },
    MonoQVar(Str),
    PolyQVar {
        name: Str,
        params: Vec<TyParam>,
    },
    MonoProj {
        lhs: Box<Type>,
        rhs: Str,
    },
    FreeVar(FreeTyVar),
    Failure,
    Uninited,
}

Variants

Obj

Int

Nat

Ratio

Float

Bool

Str

NoneType

Code

Frame

Error

Inf

NegInf

Type

ClassType

TraitType

Patch

NotImplemented

Ellipsis

Never

BuiltinMono(Str)

Mono

Fields

path: PathBuf

name: 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(QuantifiedType)

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

Not(Box<Type>, Box<Type>)

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

BuiltinPoly

Fields

name: Str

params: Vec<TyParam>

Poly

Fields

path: PathBuf

name: Str

params: Vec<TyParam>

MonoQVar(Str)

PolyQVar

Fields

name: Str

params: Vec<TyParam>

MonoProj

Fields

lhs: Box<Type>

rhs: Str

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 is_mono_q(&self) -> bool

pub fn mutate(self) -> Self

本来は型環境が必要

pub fn is_simple_class(&self) -> bool

pub fn is_procedural(&self) -> bool

Procedure or MutType?

pub fn is_mut_type(&self) -> bool

pub fn is_nonelike(&self) -> bool

pub fn is_intersection_type(&self) -> bool

pub fn is_type(&self) -> bool

pub fn is_quantified(&self) -> bool

pub fn contains_tvar(&self, name: &str) -> bool

pub fn args_ownership(&self) -> ArgsOwnership

pub fn ownership(&self) -> Ownership

pub fn name(&self) -> Str

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

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

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

pub const fn is_free_var(&self) -> bool

pub fn is_monomorphic(&self) -> bool

FIXME: Int or Str should be monomorphic

pub const fn is_callable(&self) -> bool

pub fn is_unbound_var(&self) -> bool

pub fn has_qvar(&self) -> bool

pub fn is_cachable(&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 typarams(&self) -> Vec<TyParam>

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

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

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

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

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

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

pub fn update_constraint(&self, new_constraint: Constraint)

pub fn update_cyclicity(&self, new_cyclicity: Cyclicity)

pub fn derefine(&self) -> Type

Trait Implementations

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() -> Self

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<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 update_level(&self, level: Level)

fn lift(&self)

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,

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