language-servers/erg
1
0
Fork 0
mirror of https://github.com/erg-lang/erg.git synced 2025-10-03 14:04:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Unify Type::Class/Trait

Browse source
This commit is contained in:
Shunsuke Shibayama 2022-09-03 22:22:49 +09:00
parent 263c43d74b
commit 22cb113fcd
17 changed files with 365 additions and 570 deletions
Download patch file Download diff file Expand all files Collapse all files

49
compiler/erg_compiler/context/compare.rs
View file

@ -184,44 +184,44 @@ impl Context {
&& self.supertype_of(&Type, &subr.return_t), && self.supertype_of(&Type, &subr.return_t),
), ),
( (
Type::MonoClass(n), Type::Mono(n),
Subr(SubrType { Subr(SubrType {
kind: SubrKind::Func, kind: SubrKind::Func,
.. ..
}), }),
) if &n[..] == "GenericFunc" => (Absolutely, true), ) if &n[..] == "GenericFunc" => (Absolutely, true),
( (
Type::MonoClass(n), Type::Mono(n),
Subr(SubrType { Subr(SubrType {
kind: SubrKind::Proc, kind: SubrKind::Proc,
.. ..
}), }),
) if &n[..] == "GenericProc" => (Absolutely, true), ) if &n[..] == "GenericProc" => (Absolutely, true),
( (
Type::MonoClass(n), Type::Mono(n),
Subr(SubrType { Subr(SubrType {
kind: SubrKind::FuncMethod(_), kind: SubrKind::FuncMethod(_),
.. ..
}), }),
) if &n[..] == "GenericFuncMethod" => (Absolutely, true), ) if &n[..] == "GenericFuncMethod" => (Absolutely, true),
( (
Type::MonoClass(n), Type::Mono(n),
Subr(SubrType { Subr(SubrType {
kind: SubrKind::ProcMethod { .. }, kind: SubrKind::ProcMethod { .. },
.. ..
}), }),
) if &n[..] == "GenericProcMethod" => (Absolutely, true), ) if &n[..] == "GenericProcMethod" => (Absolutely, true),
(Type::MonoClass(l), Type::PolyClass { name: r, .. }) (Type::Mono(l), Type::Poly { name: r, .. })
if &l[..] == "GenericArray" && &r[..] == "Array" => if &l[..] == "GenericArray" && &r[..] == "Array" =>
{ {
(Absolutely, true) (Absolutely, true)
} }
(Type::MonoClass(l), Type::PolyClass { name: r, .. }) (Type::Mono(l), Type::Poly { name: r, .. })
if &l[..] == "GenericDict" && &r[..] == "Dict" => if &l[..] == "GenericDict" && &r[..] == "Dict" =>
{ {
(Absolutely, true) (Absolutely, true)
} }
(Type::MonoClass(l), Type::MonoClass(r)) (Type::Mono(l), Type::Mono(r))
if &l[..] == "GenericCallable" if &l[..] == "GenericCallable"
&& (&r[..] == "GenericFunc" && (&r[..] == "GenericFunc"
|| &r[..] == "GenericProc" || &r[..] == "GenericProc"
@ -234,7 +234,7 @@ impl Context {
Some((Type::Never, Type::Obj)) => (Absolutely, true), Some((Type::Never, Type::Obj)) => (Absolutely, true),
_ => (Maybe, false), _ => (Maybe, false),
}, },
(Type::MonoClass(n), Subr(_)) if &n[..] == "GenericCallable" => (Absolutely, true), (Type::Mono(n), Subr(_)) if &n[..] == "GenericCallable" => (Absolutely, true),
(lhs, rhs) if lhs.is_simple_class() && rhs.is_simple_class() => (Absolutely, false), (lhs, rhs) if lhs.is_simple_class() && rhs.is_simple_class() => (Absolutely, false),
_ => (Maybe, false), _ => (Maybe, false),
} }
@ -258,7 +258,7 @@ impl Context {
} }
_ => {} _ => {}
} }
match self.trait_supertype_of(lhs, rhs) { match self.classsupertype_of(lhs, rhs) {
(Absolutely, judge) => { (Absolutely, judge) => {
self.register_cache(rhs, lhs, judge); self.register_cache(rhs, lhs, judge);
return judge; return judge;
@ -292,9 +292,6 @@ impl Context {
} }
fn classes_supertype_of(&self, lhs: &Type, rhs: &Type) -> (Credibility, bool) { fn classes_supertype_of(&self, lhs: &Type, rhs: &Type) -> (Credibility, bool) {
if !lhs.is_class() || !rhs.is_class() {
return (Maybe, false);
}
for (rhs_sup, _) in self.rec_get_nominal_super_class_ctxs(rhs) { for (rhs_sup, _) in self.rec_get_nominal_super_class_ctxs(rhs) {
match self.cheap_supertype_of(lhs, rhs_sup) { match self.cheap_supertype_of(lhs, rhs_sup) {
(Absolutely, true) => { (Absolutely, true) => {
@ -313,11 +310,8 @@ impl Context {
// e.g. Eq(Nat) :> Nat // e.g. Eq(Nat) :> Nat
// Nat.super_traits = [Add(Nat), Eq(Nat), ...] // Nat.super_traits = [Add(Nat), Eq(Nat), ...]
fn trait_supertype_of(&self, lhs: &Type, rhs: &Type) -> (Credibility, bool) { fn classsupertype_of(&self, lhs: &Type, rhs: &Type) -> (Credibility, bool) {
if !lhs.is_trait() { for (rhs_sup, _) in self.rec_get_nominal_super_classctxs(rhs) {
return (Maybe, false);
}
for (rhs_sup, _) in self.rec_get_nominal_super_trait_ctxs(rhs) {
match self.cheap_supertype_of(lhs, rhs_sup) { match self.cheap_supertype_of(lhs, rhs_sup) {
(Absolutely, true) => { (Absolutely, true) => {
return (Absolutely, true); return (Absolutely, true);
@ -575,26 +569,11 @@ impl Context {
// REVIEW: RefMut is invariant, maybe // REVIEW: RefMut is invariant, maybe
(Ref(lhs), rhs) | (RefMut(lhs), rhs) => self.supertype_of(lhs, rhs), (Ref(lhs), rhs) | (RefMut(lhs), rhs) => self.supertype_of(lhs, rhs),
( (
PolyClass { Poly {
name: ln, name: ln,
params: lparams, params: lparams,
}, },
PolyClass { Poly {
name: rn,
params: rparams,
},
) => {
if ln != rn || lparams.len() != rparams.len() {
return false;
}
self.poly_supertype_of(lhs, lparams, rparams)
}
(
PolyTrait {
name: ln,
params: lparams,
},
PolyTrait {
name: rn, name: rn,
params: rparams, params: rparams,
}, },
@ -619,7 +598,7 @@ impl Context {
pub(crate) fn cyclic_supertype_of(&self, lhs: &FreeTyVar, rhs: &Type) -> bool { pub(crate) fn cyclic_supertype_of(&self, lhs: &FreeTyVar, rhs: &Type) -> bool {
// if `rhs` is {S: Str | ... }, `defined_rhs` will be Str // if `rhs` is {S: Str | ... }, `defined_rhs` will be Str
let (defined_rhs, _) = self.rec_get_nominal_type_ctx(rhs).unwrap(); let (defined_rhs, _) = self.rec_get_nominal_type_ctx(rhs).unwrap();
let super_traits = self.rec_get_nominal_super_trait_ctxs(rhs); let super_traits = self.rec_get_nominal_super_classctxs(rhs);
for (sup_trait, _) in super_traits.into_iter() { for (sup_trait, _) in super_traits.into_iter() {
if self.sup_conforms(lhs, defined_rhs, sup_trait) { if self.sup_conforms(lhs, defined_rhs, sup_trait) {
return true; return true;

6
compiler/erg_compiler/context/initialize/const_func.rs
View file

@ -1,18 +1,18 @@
use erg_common::Str; use erg_common::Str;
use erg_type::constructors::class; use erg_type::constructors::mono;
use erg_type::value::ValueObj; use erg_type::value::ValueObj;
use erg_type::ValueArgs; use erg_type::ValueArgs;
/// Type -> Type /// Type -> Type
pub fn class_func(_args: ValueArgs, __name__: Option<Str>) -> ValueObj { pub fn class_func(_args: ValueArgs, __name__: Option<Str>) -> ValueObj {
let t = class(__name__.unwrap_or(Str::ever("<Lambda>"))); let t = mono(__name__.unwrap_or(Str::ever("<Lambda>")));
ValueObj::t(t) ValueObj::t(t)
} }
/// Type -> Type /// Type -> Type
pub fn inherit_func(_args: ValueArgs, __name__: Option<Str>) -> ValueObj { pub fn inherit_func(_args: ValueArgs, __name__: Option<Str>) -> ValueObj {
let t = class(__name__.unwrap_or(Str::ever("<Lambda>"))); let t = mono(__name__.unwrap_or(Str::ever("<Lambda>")));
ValueObj::t(t) ValueObj::t(t)
} }

402
compiler/erg_compiler/context/initialize/mod.rs
View file

@ -152,23 +152,23 @@ impl Context {
let proj = mono_proj(mono_q("Self"), "ImmutType"); let proj = mono_proj(mono_q("Self"), "ImmutType");
let f_t = func(vec![param_t("old", proj.clone())], None, vec![], proj); let f_t = func(vec![param_t("old", proj.clone())], None, vec![], proj);
let t = pr1_met(mono_q("Self"), None, f_t, NoneType); let t = pr1_met(mono_q("Self"), None, f_t, NoneType);
let t = quant(t, set! { subtypeof(mono_q("Self"), trait_("Immutizable")) }); let t = quant(t, set! { subtypeof(mono_q("Self"), mono("Immutizable")) });
mutable.register_decl("update!", t, Public); mutable.register_decl("update!", t, Public);
let mut immutizable = let mut immutizable =
Self::mono_trait("Immutizable", vec![trait_("Mutable")], Self::TOP_LEVEL); Self::mono_trait("Immutizable", vec![mono("Mutable")], Self::TOP_LEVEL);
immutizable.register_decl("ImmutType", Type, Public); immutizable.register_decl("ImmutType", Type, Public);
let mut mutizable = Self::mono_trait("Mutizable", vec![], Self::TOP_LEVEL); let mut mutizable = Self::mono_trait("Mutizable", vec![], Self::TOP_LEVEL);
mutizable.register_decl("MutType!", Type, Public); mutizable.register_decl("MutType!", Type, Public);
let mut in_ = Self::poly_trait( let mut in_ = Self::poly_trait(
"In", "In",
vec![PS::t("T", NonDefault)], vec![PS::t("T", NonDefault)],
vec![poly_trait("Input", vec![ty_tp(mono_q("T"))])], vec![poly("Input", vec![ty_tp(mono_q("T"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let op_t = fn1_met(mono_q("T"), mono_q("I"), Bool); let op_t = fn1_met(mono_q("T"), mono_q("I"), Bool);
let op_t = quant( let op_t = quant(
op_t, op_t,
set! { static_instance("T", Type), subtypeof(mono_q("I"), poly_trait("In", vec![ty_tp(mono_q("T"))])) }, set! { static_instance("T", Type), subtypeof(mono_q("I"), poly("In", vec![ty_tp(mono_q("T"))])) },
); );
in_.register_decl("__in__", op_t, Public); in_.register_decl("__in__", op_t, Public);
// Erg does not have a trait equivalent to `PartialEq` in Rust // Erg does not have a trait equivalent to `PartialEq` in Rust
@ -177,7 +177,7 @@ impl Context {
let mut eq = Self::poly_trait( let mut eq = Self::poly_trait(
"Eq", "Eq",
vec![PS::t("R", WithDefault)], vec![PS::t("R", WithDefault)],
vec![poly_trait("Output", vec![ty_tp(mono_q("R"))])], vec![poly("Output", vec![ty_tp(mono_q("R"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
// __eq__: |Self <: Eq()| Self.(Self) -> Bool // __eq__: |Self <: Eq()| Self.(Self) -> Bool
@ -185,7 +185,7 @@ impl Context {
let op_t = quant( let op_t = quant(
op_t, op_t,
set! { set! {
subtypeof(mono_q("Self"), poly_trait("Eq", vec![ty_tp(mono_q("R"))])), subtypeof(mono_q("Self"), poly("Eq", vec![ty_tp(mono_q("R"))])),
static_instance("R", Type) static_instance("R", Type)
}, },
); );
@ -193,49 +193,49 @@ impl Context {
let mut partial_ord = Self::poly_trait( let mut partial_ord = Self::poly_trait(
"PartialOrd", "PartialOrd",
vec![PS::t("R", WithDefault)], vec![PS::t("R", WithDefault)],
vec![poly_trait("PartialEq", vec![ty_tp(mono_q("R"))])], vec![poly("PartialEq", vec![ty_tp(mono_q("R"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let op_t = fn1_met(mono_q("Self"), mono_q("R"), Bool); let op_t = fn1_met(mono_q("Self"), mono_q("R"), Bool);
let op_t = quant( let op_t = quant(
op_t, op_t,
set! { set! {
subtypeof(mono_q("Self"), poly_trait("PartialOrd", vec![ty_tp(mono_q("R"))])), subtypeof(mono_q("Self"), poly("PartialOrd", vec![ty_tp(mono_q("R"))])),
static_instance("R", Type) static_instance("R", Type)
}, },
); );
partial_ord.register_decl("__lt__", op_t.clone(), Public); partial_ord.register_decl("__lt__", op_t.clone(), Public);
let ord = Self::mono_trait( let ord = Self::mono_trait(
"Ord", "Ord",
vec![poly_trait("Eq", vec![]), poly_trait("PartialOrd", vec![])], vec![poly("Eq", vec![]), poly("PartialOrd", vec![])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let num = Self::mono_trait( let num = Self::mono_trait(
"Num", "Num",
vec![ vec![
poly_trait("Add", vec![]), poly("Add", vec![]),
poly_trait("Sub", vec![]), poly("Sub", vec![]),
poly_trait("Mul", vec![]), poly("Mul", vec![]),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let mut seq = Self::poly_trait( let mut seq = Self::poly_trait(
"Seq", "Seq",
vec![PS::t("T", NonDefault)], vec![PS::t("T", NonDefault)],
vec![poly_trait("Output", vec![ty_tp(mono_q("T"))])], vec![poly("Output", vec![ty_tp(mono_q("T"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let self_t = mono_q("Self"); let self_t = mono_q("Self");
let t = fn0_met(self_t.clone(), Nat); let t = fn0_met(self_t.clone(), Nat);
let t = quant( let t = quant(
t, t,
set! {subtypeof(self_t.clone(), poly_trait("Seq", vec![TyParam::erased(Type)]))}, set! {subtypeof(self_t.clone(), poly("Seq", vec![TyParam::erased(Type)]))},
); );
seq.register_decl("__len__", t, Public); seq.register_decl("__len__", t, Public);
let t = fn1_met(self_t.clone(), Nat, mono_q("T")); let t = fn1_met(self_t.clone(), Nat, mono_q("T"));
let t = quant( let t = quant(
t, t,
set! {subtypeof(self_t, poly_trait("Seq", vec![ty_tp(mono_q("T"))])), static_instance("T", Type)}, set! {subtypeof(self_t, poly("Seq", vec![ty_tp(mono_q("T"))])), static_instance("T", Type)},
); );
// Seq.get: |Self <: Seq(T)| Self.(Nat) -> T // Seq.get: |Self <: Seq(T)| Self.(Nat) -> T
seq.register_decl("get", t, Public); seq.register_decl("get", t, Public);
@ -249,10 +249,10 @@ impl Context {
let mut add = Self::poly_trait( let mut add = Self::poly_trait(
"Add", "Add",
params.clone(), params.clone(),
vec![poly_trait("Output", vec![ty_tp(mono_q("R"))])], // Rについて共変(__add__の型とは関係ない) vec![poly("Output", vec![ty_tp(mono_q("R"))])], // Rについて共変(__add__の型とは関係ない)
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let self_bound = subtypeof(mono_q("Self"), poly_trait("Add", ty_params.clone())); let self_bound = subtypeof(mono_q("Self"), poly("Add", ty_params.clone()));
let op_t = fn1_met(mono_q("Self"), r.clone(), mono_proj(mono_q("Self"), "AddO")); let op_t = fn1_met(mono_q("Self"), r.clone(), mono_proj(mono_q("Self"), "AddO"));
let op_t = quant(op_t, set! {r_bound.clone(), self_bound}); let op_t = quant(op_t, set! {r_bound.clone(), self_bound});
add.register_decl("__add__", op_t, Public); add.register_decl("__add__", op_t, Public);
@ -260,61 +260,57 @@ impl Context {
let mut sub = Self::poly_trait( let mut sub = Self::poly_trait(
"Sub", "Sub",
params.clone(), params.clone(),
vec![poly_trait("Output", vec![ty_tp(mono_q("R"))])], vec![poly("Output", vec![ty_tp(mono_q("R"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let op_t = fn1_met(mono_q("Self"), r.clone(), mono_proj(mono_q("Self"), "SubO")); let op_t = fn1_met(mono_q("Self"), r.clone(), mono_proj(mono_q("Self"), "SubO"));
let self_bound = subtypeof(mono_q("Self"), poly_trait("Sub", ty_params.clone())); let self_bound = subtypeof(mono_q("Self"), poly("Sub", ty_params.clone()));
let op_t = quant(op_t, set! {r_bound.clone(), self_bound}); let op_t = quant(op_t, set! {r_bound.clone(), self_bound});
sub.register_decl("__sub__", op_t, Public); sub.register_decl("__sub__", op_t, Public);
sub.register_decl("SubO", Type, Public); sub.register_decl("SubO", Type, Public);
let mut mul = Self::poly_trait( let mut mul = Self::poly_trait(
"Mul", "Mul",
params.clone(), params.clone(),
vec![poly_trait("Output", vec![ty_tp(mono_q("R"))])], vec![poly("Output", vec![ty_tp(mono_q("R"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let op_t = fn1_met(mono_q("Self"), r.clone(), mono_proj(mono_q("Self"), "MulO")); let op_t = fn1_met(mono_q("Self"), r.clone(), mono_proj(mono_q("Self"), "MulO"));
let self_bound = subtypeof(mono_q("Self"), poly_trait("Mul", ty_params.clone())); let self_bound = subtypeof(mono_q("Self"), poly("Mul", ty_params.clone()));
let op_t = quant(op_t, set! {r_bound.clone(), self_bound}); let op_t = quant(op_t, set! {r_bound.clone(), self_bound});
mul.register_decl("__mul__", op_t, Public); mul.register_decl("__mul__", op_t, Public);
mul.register_decl("MulO", Type, Public); mul.register_decl("MulO", Type, Public);
let mut div = Self::poly_trait( let mut div = Self::poly_trait(
"Div", "Div",
params.clone(), params.clone(),
vec![poly_trait("Output", vec![ty_tp(mono_q("R"))])], vec![poly("Output", vec![ty_tp(mono_q("R"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let op_t = fn1_met(mono_q("Self"), r, mono_proj(mono_q("Self"), "DivO")); let op_t = fn1_met(mono_q("Self"), r, mono_proj(mono_q("Self"), "DivO"));
let self_bound = subtypeof(mono_q("Self"), poly_trait("Div", ty_params.clone())); let self_bound = subtypeof(mono_q("Self"), poly("Div", ty_params.clone()));
let op_t = quant(op_t, set! {r_bound.clone(), self_bound}); let op_t = quant(op_t, set! {r_bound.clone(), self_bound});
div.register_decl("__div__", op_t, Public); div.register_decl("__div__", op_t, Public);
div.register_decl("DivO", Type, Public); div.register_decl("DivO", Type, Public);
self.register_type(trait_("Unpack"), unpack, Const); self.register_type(mono("Unpack"), unpack, Const);
self.register_type(trait_("Named"), named, Const); self.register_type(mono("Named"), named, Const);
self.register_type(trait_("Mutable"), mutable, Const); self.register_type(mono("Mutable"), mutable, Const);
self.register_type(trait_("Immutizable"), immutizable, Const); self.register_type(mono("Immutizable"), immutizable, Const);
self.register_type(trait_("Mutizable"), mutizable, Const); self.register_type(mono("Mutizable"), mutizable, Const);
self.register_type(poly_trait("In", vec![ty_tp(mono_q("T"))]), in_, Const); self.register_type(poly("In", vec![ty_tp(mono_q("T"))]), in_, Const);
self.register_type(poly_trait("Eq", vec![ty_tp(mono_q("R"))]), eq, Const); self.register_type(poly("Eq", vec![ty_tp(mono_q("R"))]), eq, Const);
self.register_type( self.register_type(
poly_trait("PartialOrd", vec![ty_tp(mono_q("R"))]), poly("PartialOrd", vec![ty_tp(mono_q("R"))]),
partial_ord, partial_ord,
Const, Const,
); );
self.register_type(trait_("Ord"), ord, Const); self.register_type(mono("Ord"), ord, Const);
self.register_type(trait_("Num"), num, Const); self.register_type(mono("Num"), num, Const);
self.register_type(poly_trait("Seq", vec![ty_tp(mono_q("T"))]), seq, Const); self.register_type(poly("Seq", vec![ty_tp(mono_q("T"))]), seq, Const);
self.register_type(poly_trait("Input", vec![ty_tp(mono_q("T"))]), input, Const); self.register_type(poly("Input", vec![ty_tp(mono_q("T"))]), input, Const);
self.register_type( self.register_type(poly("Output", vec![ty_tp(mono_q("T"))]), output, Const);
poly_trait("Output", vec![ty_tp(mono_q("T"))]), self.register_type(poly("Add", ty_params.clone()), add, Const);
output, self.register_type(poly("Sub", ty_params.clone()), sub, Const);
Const, self.register_type(poly("Mul", ty_params.clone()), mul, Const);
); self.register_type(poly("Div", ty_params), div, Const);
self.register_type(poly_trait("Add", ty_params.clone()), add, Const);
self.register_type(poly_trait("Sub", ty_params.clone()), sub, Const);
self.register_type(poly_trait("Mul", ty_params.clone()), mul, Const);
self.register_type(poly_trait("Div", ty_params), div, Const);
self.register_const_param_defaults( self.register_const_param_defaults(
"Eq", "Eq",
vec![ConstTemplate::Obj(ValueObj::t(mono_q("Self")))], vec![ConstTemplate::Obj(ValueObj::t(mono_q("Self")))],
@ -344,31 +340,31 @@ impl Context {
fn init_builtin_classes(&mut self) { fn init_builtin_classes(&mut self) {
let mut obj = Self::mono_class("Obj", vec![], vec![], Self::TOP_LEVEL); let mut obj = Self::mono_class("Obj", vec![], vec![], Self::TOP_LEVEL);
let t = fn0_met(mono_q("Self"), mono_q("Self")); let t = fn0_met(mono_q("Self"), mono_q("Self"));
let t = quant(t, set! {subtypeof(mono_q("Self"), class("Obj"))}); let t = quant(t, set! {subtypeof(mono_q("Self"), mono("Obj"))});
obj.register_impl("clone", t, Const, Public); obj.register_impl("clone", t, Const, Public);
obj.register_impl("__module__", Str, Const, Public); obj.register_impl("__module__", Str, Const, Public);
obj.register_impl("__sizeof__", fn0_met(Obj, Nat), Const, Public); obj.register_impl("__sizeof__", fn0_met(Obj, Nat), Const, Public);
obj.register_impl("__repr__", fn0_met(Obj, Str), Immutable, Public); obj.register_impl("__repr__", fn0_met(Obj, Str), Immutable, Public);
obj.register_impl("__str__", fn0_met(Obj, Str), Immutable, Public); obj.register_impl("__str__", fn0_met(Obj, Str), Immutable, Public);
obj.register_impl("__dict__", fn0_met(Obj, dict(Str, Obj)), Immutable, Public); obj.register_impl("__dict__", fn0_met(Obj, dict(Str, Obj)), Immutable, Public);
obj.register_impl("__bytes__", fn0_met(Obj, class("Bytes")), Immutable, Public); obj.register_impl("__bytes__", fn0_met(Obj, mono("Bytes")), Immutable, Public);
obj.register_const("MutType!", ValueObj::t(class("Obj!"))); obj.register_const("MutType!", ValueObj::t(mono("Obj!")));
// let mut record = Self::mono_trait("Record", vec![Obj], Self::TOP_LEVEL); // let mut record = Self::mono_trait("Record", vec![Obj], Self::TOP_LEVEL);
// let mut class = Self::mono_class("Class", vec![Type, Obj], Self::TOP_LEVEL); // let mut class = Self::mono_class("Class", vec![Type, Obj], Self::TOP_LEVEL);
let mut int = Self::mono_class( let mut int = Self::mono_class(
"Int", "Int",
vec![Ratio, Obj], vec![Ratio, Obj],
vec![ vec![
trait_("Ord"), mono("Ord"),
poly_trait("Eq", vec![ty_tp(Int)]), poly("Eq", vec![ty_tp(Int)]),
poly_trait("Add", vec![ty_tp(Int)]), poly("Add", vec![ty_tp(Int)]),
poly_trait("Sub", vec![ty_tp(Int)]), poly("Sub", vec![ty_tp(Int)]),
poly_trait("Mul", vec![ty_tp(Int)]), poly("Mul", vec![ty_tp(Int)]),
poly_trait("Div", vec![ty_tp(Int)]), poly("Div", vec![ty_tp(Int)]),
trait_("Num"), mono("Num"),
// trait_("Rational"), // class("Rational"),
// trait_("Integral"), // class("Integral"),
trait_("Mutizable"), mono("Mutizable"),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -382,23 +378,23 @@ impl Context {
int.register_const("SubO", ValueObj::t(Int)); int.register_const("SubO", ValueObj::t(Int));
int.register_const("MulO", ValueObj::t(Int)); int.register_const("MulO", ValueObj::t(Int));
int.register_const("DivO", ValueObj::t(Ratio)); int.register_const("DivO", ValueObj::t(Ratio));
int.register_const("MutType!", ValueObj::t(class("Int!"))); int.register_const("MutType!", ValueObj::t(mono("Int!")));
int.register_impl("Real", Int, Const, Public); int.register_impl("Real", Int, Const, Public);
int.register_impl("Imag", Int, Const, Public); int.register_impl("Imag", Int, Const, Public);
let mut nat = Self::mono_class( let mut nat = Self::mono_class(
"Nat", "Nat",
vec![Int, Ratio, Obj], vec![Int, Ratio, Obj],
vec![ vec![
trait_("Ord"), mono("Ord"),
poly_trait("Eq", vec![ty_tp(Nat)]), poly("Eq", vec![ty_tp(Nat)]),
poly_trait("Add", vec![ty_tp(Nat)]), poly("Add", vec![ty_tp(Nat)]),
poly_trait("Sub", vec![ty_tp(Nat)]), poly("Sub", vec![ty_tp(Nat)]),
poly_trait("Mul", vec![ty_tp(Nat)]), poly("Mul", vec![ty_tp(Nat)]),
poly_trait("Div", vec![ty_tp(Nat)]), poly("Div", vec![ty_tp(Nat)]),
trait_("Num"), mono("Num"),
// trait_("Rational"), // class("Rational"),
// trait_("Integral"), // class("Integral"),
trait_("Mutizable"), mono("Mutizable"),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -423,21 +419,21 @@ impl Context {
nat.register_const("SubO", ValueObj::t(Int)); nat.register_const("SubO", ValueObj::t(Int));
nat.register_const("MulO", ValueObj::t(Nat)); nat.register_const("MulO", ValueObj::t(Nat));
nat.register_const("DivO", ValueObj::t(Ratio)); nat.register_const("DivO", ValueObj::t(Ratio));
nat.register_const("MutType!", ValueObj::t(class("Nat!"))); nat.register_const("MutType!", ValueObj::t(mono("Nat!")));
nat.register_impl("Real", Nat, Const, Public); nat.register_impl("Real", Nat, Const, Public);
nat.register_impl("Imag", Nat, Const, Public); nat.register_impl("Imag", Nat, Const, Public);
let mut float = Self::mono_class( let mut float = Self::mono_class(
"Float", "Float",
vec![Obj], vec![Obj],
vec![ vec![
trait_("Num"), mono("Num"),
// trait_("Eq"), // Float doesn't have an Eq implementation // class("Eq"), // Float doesn't have an Eq implementation
trait_("Ord"), mono("Ord"),
poly_trait("Add", vec![ty_tp(Float)]), poly("Add", vec![ty_tp(Float)]),
poly_trait("Sub", vec![ty_tp(Float)]), poly("Sub", vec![ty_tp(Float)]),
poly_trait("Mul", vec![ty_tp(Float)]), poly("Mul", vec![ty_tp(Float)]),
poly_trait("Div", vec![ty_tp(Float)]), poly("Div", vec![ty_tp(Float)]),
trait_("Mutizable"), mono("Mutizable"),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -450,21 +446,21 @@ impl Context {
float.register_const("SubO", ValueObj::t(Float)); float.register_const("SubO", ValueObj::t(Float));
float.register_const("MulO", ValueObj::t(Float)); float.register_const("MulO", ValueObj::t(Float));
float.register_const("DivO", ValueObj::t(Float)); float.register_const("DivO", ValueObj::t(Float));
float.register_const("MutType!", ValueObj::t(class("Float!"))); float.register_const("MutType!", ValueObj::t(mono("Float!")));
float.register_impl("Real", Float, Const, Public); float.register_impl("Real", Float, Const, Public);
float.register_impl("Imag", Float, Const, Public); float.register_impl("Imag", Float, Const, Public);
let mut ratio = Self::mono_class( let mut ratio = Self::mono_class(
"Ratio", "Ratio",
vec![Obj], vec![Obj],
vec![ vec![
trait_("Num"), mono("Num"),
poly_trait("Eq", vec![ty_tp(Ratio)]), poly("Eq", vec![ty_tp(Ratio)]),
trait_("Ord"), mono("Ord"),
poly_trait("Add", vec![ty_tp(Ratio)]), poly("Add", vec![ty_tp(Ratio)]),
poly_trait("Sub", vec![ty_tp(Ratio)]), poly("Sub", vec![ty_tp(Ratio)]),
poly_trait("Mul", vec![ty_tp(Ratio)]), poly("Mul", vec![ty_tp(Ratio)]),
poly_trait("Div", vec![ty_tp(Ratio)]), poly("Div", vec![ty_tp(Ratio)]),
trait_("Mutizable"), mono("Mutizable"),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -477,40 +473,40 @@ impl Context {
ratio.register_const("SubO", ValueObj::t(Ratio)); ratio.register_const("SubO", ValueObj::t(Ratio));
ratio.register_const("MulO", ValueObj::t(Ratio)); ratio.register_const("MulO", ValueObj::t(Ratio));
ratio.register_const("DivO", ValueObj::t(Ratio)); ratio.register_const("DivO", ValueObj::t(Ratio));
ratio.register_const("MutType!", ValueObj::t(class("Ratio!"))); ratio.register_const("MutType!", ValueObj::t(mono("Ratio!")));
ratio.register_impl("Real", Ratio, Const, Public); ratio.register_impl("Real", Ratio, Const, Public);
ratio.register_impl("Imag", Ratio, Const, Public); ratio.register_impl("Imag", Ratio, Const, Public);
let mut bool_ = Self::mono_class( let mut bool_ = Self::mono_class(
"Bool", "Bool",
vec![Nat, Int, Ratio, Obj], vec![Nat, Int, Ratio, Obj],
vec![ vec![
trait_("Num"), mono("Num"),
// trait_("Rational"), // class("Rational"),
// trait_("Integral"), // class("Integral"),
poly_trait("Eq", vec![ty_tp(Bool)]), poly("Eq", vec![ty_tp(Bool)]),
poly_trait("Add", vec![ty_tp(Bool)]), poly("Add", vec![ty_tp(Bool)]),
trait_("Ord"), mono("Ord"),
// mono("SelfAdd"), // mono("SelfAdd"),
// mono("SelfSub"), // mono("SelfSub"),
// mono("SelfMul"), // mono("SelfMul"),
// mono("SelfDiv"), // mono("SelfDiv"),
trait_("Mutizable"), mono("Mutizable"),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
bool_.register_impl("__and__", fn1_met(Bool, Bool, Bool), Const, Public); bool_.register_impl("__and__", fn1_met(Bool, Bool, Bool), Const, Public);
bool_.register_impl("__or__", fn1_met(Bool, Bool, Bool), Const, Public); bool_.register_impl("__or__", fn1_met(Bool, Bool, Bool), Const, Public);
bool_.register_const("MutType!", ValueObj::t(class("Bool!"))); bool_.register_const("MutType!", ValueObj::t(mono("Bool!")));
let mut str_ = Self::mono_class( let mut str_ = Self::mono_class(
"Str", "Str",
vec![Obj], vec![Obj],
vec![ vec![
poly_trait("Eq", vec![ty_tp(Str)]), poly("Eq", vec![ty_tp(Str)]),
trait_("Ord"), mono("Ord"),
trait_("Mutizable"), mono("Mutizable"),
poly_trait("Seq", vec![ty_tp(Str)]), poly("Seq", vec![ty_tp(Str)]),
poly_trait("Add", vec![ty_tp(Str)]), poly("Add", vec![ty_tp(Str)]),
poly_trait("Mul", vec![ty_tp(Nat)]), poly("Mul", vec![ty_tp(Nat)]),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -534,21 +530,21 @@ impl Context {
vec![], vec![],
None, None,
vec![param_t("encoding", Str), param_t("errors", Str)], vec![param_t("encoding", Str), param_t("errors", Str)],
class("Bytes"), mono("Bytes"),
), ),
Immutable, Immutable,
Public, Public,
); );
str_.register_const("AddO", ValueObj::t(Str)); str_.register_const("AddO", ValueObj::t(Str));
str_.register_const("MulO", ValueObj::t(Str)); str_.register_const("MulO", ValueObj::t(Str));
str_.register_const("MutType!", ValueObj::t(class("Str!"))); str_.register_const("MutType!", ValueObj::t(mono("Str!")));
let mut type_ = Self::mono_class( let mut type_ = Self::mono_class(
"Type", "Type",
vec![Obj], vec![Obj],
vec![ vec![
poly_trait("Eq", vec![ty_tp(Type)]), poly("Eq", vec![ty_tp(Type)]),
poly_trait("In", vec![ty_tp(Obj)]), // x in Type poly("In", vec![ty_tp(Obj)]), // x in Type
trait_("Named"), mono("Named"),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -556,7 +552,7 @@ impl Context {
let module = Self::mono_class( let module = Self::mono_class(
"Module", "Module",
vec![Obj], vec![Obj],
vec![poly_trait("Eq", vec![ty_tp(Module)]), trait_("Named")], vec![poly("Eq", vec![ty_tp(Module)]), mono("Named")],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let mut array_ = Self::poly_class( let mut array_ = Self::poly_class(
@ -564,16 +560,16 @@ impl Context {
vec![PS::t_nd("T"), PS::named_nd("N", Nat)], vec![PS::t_nd("T"), PS::named_nd("N", Nat)],
vec![Obj], vec![Obj],
vec![ vec![
poly_trait( poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Array", "Array",
vec![ty_tp(mono_q("T")), mono_q_tp("N")], vec![ty_tp(mono_q("T")), mono_q_tp("N")],
))], ))],
), ),
trait_("Mutizable"), mono("Mutizable"),
poly_trait("Seq", vec![ty_tp(mono_q("T"))]), poly("Seq", vec![ty_tp(mono_q("T"))]),
poly_trait("Output", vec![ty_tp(mono_q("T"))]), poly("Output", vec![ty_tp(mono_q("T"))]),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -608,10 +604,10 @@ impl Context {
); );
let t = quant( let t = quant(
t, t,
set! {static_instance("N", Nat), static_instance("T", trait_("Mutable"))}, set! {static_instance("N", Nat), static_instance("T", mono("Mutable"))},
); );
array_.register_impl("map!", t, Immutable, Public); array_.register_impl("map!", t, Immutable, Public);
let mut_type = ValueObj::t(poly_class( let mut_type = ValueObj::t(poly(
"Array!", "Array!",
vec![TyParam::t(mono_q("T")), TyParam::mono_q("N").mutate()], vec![TyParam::t(mono_q("T")), TyParam::mono_q("N").mutate()],
)); ));
@ -619,34 +615,34 @@ impl Context {
array_.register_const("MutType!", mut_type); array_.register_const("MutType!", mut_type);
let mut int_mut = Self::mono_class( let mut int_mut = Self::mono_class(
"Int!", "Int!",
vec![Int, class("Ratio!"), Obj], vec![Int, mono("Ratio!"), Obj],
vec![trait_("Mutable")], vec![mono("Mutable")],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
// TODO: make Tuple6, Tuple7, ... etc. // TODO: make Tuple6, Tuple7, ... etc.
let tuple_ = Self::mono_class( let tuple_ = Self::mono_class(
"Tuple", "Tuple",
vec![Obj], vec![Obj],
vec![poly_trait("Eq", vec![ty_tp(class("Tuple"))])], vec![poly("Eq", vec![ty_tp(mono("Tuple"))])],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let tuple1 = Self::poly_class( let tuple1 = Self::poly_class(
"Tuple1", "Tuple1",
vec![PS::t_nd("A")], vec![PS::t_nd("A")],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class("Tuple1", vec![ty_tp(mono_q("A"))]))], vec![ty_tp(poly("Tuple1", vec![ty_tp(mono_q("A"))]))],
)], )],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let tuple2 = Self::poly_class( let tuple2 = Self::poly_class(
"Tuple2", "Tuple2",
vec![PS::t_nd("A"), PS::t_nd("B")], vec![PS::t_nd("A"), PS::t_nd("B")],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Tuple2", "Tuple2",
vec![ty_tp(mono_q("A")), ty_tp(mono_q("B"))], vec![ty_tp(mono_q("A")), ty_tp(mono_q("B"))],
))], ))],
@ -656,10 +652,10 @@ impl Context {
let tuple3 = Self::poly_class( let tuple3 = Self::poly_class(
"Tuple3", "Tuple3",
vec![PS::t_nd("A"), PS::t_nd("B"), PS::t_nd("C")], vec![PS::t_nd("A"), PS::t_nd("B"), PS::t_nd("C")],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Tuple3", "Tuple3",
vec![ty_tp(mono_q("A")), ty_tp(mono_q("B")), ty_tp(mono_q("C"))], vec![ty_tp(mono_q("A")), ty_tp(mono_q("B")), ty_tp(mono_q("C"))],
))], ))],
@ -669,10 +665,10 @@ impl Context {
let tuple4 = Self::poly_class( let tuple4 = Self::poly_class(
"Tuple4", "Tuple4",
vec![PS::t_nd("A"), PS::t_nd("B"), PS::t_nd("C"), PS::t_nd("D")], vec![PS::t_nd("A"), PS::t_nd("B"), PS::t_nd("C"), PS::t_nd("D")],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Tuple4", "Tuple4",
vec![ vec![
ty_tp(mono_q("A")), ty_tp(mono_q("A")),
@ -693,10 +689,10 @@ impl Context {
PS::t_nd("D"), PS::t_nd("D"),
PS::t_nd("E"), PS::t_nd("E"),
], ],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Tuple5", "Tuple5",
vec![ vec![
ty_tp(mono_q("A")), ty_tp(mono_q("A")),
@ -719,10 +715,10 @@ impl Context {
PS::t_nd("E"), PS::t_nd("E"),
PS::t_nd("F"), PS::t_nd("F"),
], ],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Tuple6", "Tuple6",
vec![ vec![
ty_tp(mono_q("A")), ty_tp(mono_q("A")),
@ -747,10 +743,10 @@ impl Context {
PS::t_nd("F"), PS::t_nd("F"),
PS::t_nd("G"), PS::t_nd("G"),
], ],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Tuple7", "Tuple7",
vec![ vec![
ty_tp(mono_q("A")), ty_tp(mono_q("A")),
@ -777,10 +773,10 @@ impl Context {
PS::t_nd("G"), PS::t_nd("G"),
PS::t_nd("H"), PS::t_nd("H"),
], ],
vec![class("Tuple"), Obj], vec![mono("Tuple"), Obj],
vec![poly_trait( vec![poly(
"Eq", "Eq",
vec![ty_tp(poly_class( vec![ty_tp(poly(
"Tuple8", "Tuple8",
vec![ vec![
ty_tp(mono_q("A")), ty_tp(mono_q("A")),
@ -798,83 +794,77 @@ impl Context {
); );
int_mut.register_const("ImmutType", ValueObj::t(Int)); int_mut.register_const("ImmutType", ValueObj::t(Int));
let f_t = param_t("f", func(vec![param_t("old", Int)], None, vec![], Int)); let f_t = param_t("f", func(vec![param_t("old", Int)], None, vec![], Int));
let t = pr_met(class("Int!"), None, vec![f_t], None, vec![], NoneType); let t = pr_met(mono("Int!"), None, vec![f_t], None, vec![], NoneType);
int_mut.register_impl("update!", t, Immutable, Public); int_mut.register_impl("update!", t, Immutable, Public);
let mut nat_mut = Self::mono_class( let mut nat_mut = Self::mono_class(
"Nat!", "Nat!",
vec![Nat, class("Int!"), class("Ratio!"), Obj], vec![Nat, mono("Int!"), mono("Ratio!"), Obj],
vec![trait_("Mutable")], vec![mono("Mutable")],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
nat_mut.register_const("ImmutType", ValueObj::t(Nat)); nat_mut.register_const("ImmutType", ValueObj::t(Nat));
let f_t = param_t("f", func(vec![param_t("old", Nat)], None, vec![], Nat)); let f_t = param_t("f", func(vec![param_t("old", Nat)], None, vec![], Nat));
let t = pr_met(class("Nat!"), None, vec![f_t], None, vec![], NoneType); let t = pr_met(mono("Nat!"), None, vec![f_t], None, vec![], NoneType);
nat_mut.register_impl("update!", t, Immutable, Public); nat_mut.register_impl("update!", t, Immutable, Public);
let mut float_mut = Self::mono_class( let mut float_mut = Self::mono_class(
"Float!", "Float!",
vec![Float, Obj], vec![Float, Obj],
vec![trait_("Mutable")], vec![mono("Mutable")],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
float_mut.register_const("ImmutType", ValueObj::t(Float)); float_mut.register_const("ImmutType", ValueObj::t(Float));
let f_t = param_t("f", func(vec![param_t("old", Float)], None, vec![], Float)); let f_t = param_t("f", func(vec![param_t("old", Float)], None, vec![], Float));
let t = pr_met(class("Float!"), None, vec![f_t], None, vec![], NoneType); let t = pr_met(mono("Float!"), None, vec![f_t], None, vec![], NoneType);
float_mut.register_impl("update!", t, Immutable, Public); float_mut.register_impl("update!", t, Immutable, Public);
let mut ratio_mut = Self::mono_class( let mut ratio_mut = Self::mono_class(
"Ratio!", "Ratio!",
vec![Ratio, Obj], vec![Ratio, Obj],
vec![trait_("Mutable")], vec![mono("Mutable")],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
ratio_mut.register_const("ImmutType", ValueObj::t(Ratio)); ratio_mut.register_const("ImmutType", ValueObj::t(Ratio));
let f_t = param_t( let f_t = param_t(
"f", "f",
func( func(
vec![param_t("old", class("Ratio"))], vec![param_t("old", mono("Ratio"))],
None, None,
vec![], vec![],
class("Ratio"), mono("Ratio"),
), ),
); );
let t = pr_met(class("Ratio!"), None, vec![f_t], None, vec![], NoneType); let t = pr_met(mono("Ratio!"), None, vec![f_t], None, vec![], NoneType);
ratio_mut.register_impl("update!", t, Immutable, Public); ratio_mut.register_impl("update!", t, Immutable, Public);
let mut bool_mut = Self::mono_class( let mut bool_mut = Self::mono_class(
"Bool!", "Bool!",
vec![Bool, class("Nat!"), class("Int!"), class("Ratio!"), Obj], vec![Bool, mono("Nat!"), mono("Int!"), mono("Ratio!"), Obj],
vec![trait_("Mutable")], vec![mono("Mutable")],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
bool_mut.register_const("ImmutType", ValueObj::t(Bool)); bool_mut.register_const("ImmutType", ValueObj::t(Bool));
let f_t = param_t("f", func(vec![param_t("old", Bool)], None, vec![], Bool)); let f_t = param_t("f", func(vec![param_t("old", Bool)], None, vec![], Bool));
let t = pr_met(class("Bool!"), None, vec![f_t], None, vec![], NoneType); let t = pr_met(mono("Bool!"), None, vec![f_t], None, vec![], NoneType);
bool_mut.register_impl("update!", t, Immutable, Public); bool_mut.register_impl("update!", t, Immutable, Public);
let mut str_mut = Self::mono_class( let mut str_mut = Self::mono_class(
"Str!", "Str!",
vec![Str, Obj], vec![Str, Obj],
vec![trait_("Mutable")], vec![mono("Mutable")],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
str_mut.register_const("ImmutType", ValueObj::t(Str)); str_mut.register_const("ImmutType", ValueObj::t(Str));
let f_t = param_t("f", func(vec![param_t("old", Str)], None, vec![], Str)); let f_t = param_t("f", func(vec![param_t("old", Str)], None, vec![], Str));
let t = pr_met(class("Str!"), None, vec![f_t], None, vec![], NoneType); let t = pr_met(mono("Str!"), None, vec![f_t], None, vec![], NoneType);
str_mut.register_impl("update!", t, Immutable, Public); str_mut.register_impl("update!", t, Immutable, Public);
let array_mut_t = poly_class("Array!", vec![ty_tp(mono_q("T")), mono_q_tp("N")]); let array_mut_t = poly("Array!", vec![ty_tp(mono_q("T")), mono_q_tp("N")]);
let mut array_mut = Self::poly_class( let mut array_mut = Self::poly_class(
"Array!", "Array!",
vec![PS::t_nd("T"), PS::named_nd("N", class("Nat!"))], vec![PS::t_nd("T"), PS::named_nd("N", mono("Nat!"))],
vec![ vec![poly("Range", vec![ty_tp(mono_q("T")), mono_q_tp("N")]), Obj],
poly_class("Range", vec![ty_tp(mono_q("T")), mono_q_tp("N")]), vec![mono("Mutizable"), poly("Seq", vec![ty_tp(mono_q("T"))])],
Obj,
],
vec![
trait_("Mutizable"),
poly_trait("Seq", vec![ty_tp(mono_q("T"))]),
],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let t = pr_met( let t = pr_met(
ref_mut(array_mut_t.clone()), ref_mut(array_mut_t.clone()),
Some(ref_mut(poly_class( Some(ref_mut(poly(
"Array!", "Array!",
vec![ty_tp(mono_q("T")), mono_q_tp("N") + value(1)], vec![ty_tp(mono_q("T")), mono_q_tp("N") + value(1)],
))), ))),
@ -885,7 +875,7 @@ impl Context {
); );
let t = quant( let t = quant(
t, t,
set! {static_instance("T", Type), static_instance("N", class("Nat!"))}, set! {static_instance("T", Type), static_instance("N", mono("Nat!"))},
); );
array_mut.register_impl("push!", t, Immutable, Public); array_mut.register_impl("push!", t, Immutable, Public);
let f_t = param_t( let f_t = param_t(
@ -899,31 +889,23 @@ impl Context {
); );
let t = pr_met(array_mut_t.clone(), None, vec![f_t], None, vec![], NoneType); let t = pr_met(array_mut_t.clone(), None, vec![f_t], None, vec![], NoneType);
array_mut.register_impl("update!", t, Immutable, Public); array_mut.register_impl("update!", t, Immutable, Public);
let range_t = poly_class("Range", vec![TyParam::t(mono_q("T"))]); let range_t = poly("Range", vec![TyParam::t(mono_q("T"))]);
let range = Self::poly_class( let range = Self::poly_class(
"Range", "Range",
vec![PS::t_nd("T")], vec![PS::t_nd("T")],
vec![Obj], vec![Obj],
vec![ vec![
poly_trait( poly("Eq", vec![ty_tp(poly("Range", vec![ty_tp(mono_q("T"))]))]),
"Eq", mono("Mutizable"),
vec![ty_tp(poly_class("Range", vec![ty_tp(mono_q("T"))]))], poly("Seq", vec![ty_tp(mono_q("T"))]),
), poly("Output", vec![ty_tp(mono_q("T"))]),
trait_("Mutizable"),
poly_trait("Seq", vec![ty_tp(mono_q("T"))]),
poly_trait("Output", vec![ty_tp(mono_q("T"))]),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
let func = Self::mono_class( let func = Self::mono_class("Function", vec![Obj], vec![mono("Named")], Self::TOP_LEVEL);
"Function",
vec![Obj],
vec![trait_("Named")],
Self::TOP_LEVEL,
);
let qfunc = Self::mono_class( let qfunc = Self::mono_class(
"QuantifiedFunction", "QuantifiedFunction",
vec![class("Function"), Obj], vec![mono("Function"), Obj],
vec![], vec![],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );
@ -1001,21 +983,21 @@ impl Context {
tuple8, tuple8,
Const, Const,
); );
self.register_type(class("Int!"), int_mut, Const); self.register_type(mono("Int!"), int_mut, Const);
self.register_type(class("Nat!"), nat_mut, Const); self.register_type(mono("Nat!"), nat_mut, Const);
self.register_type(class("Float!"), float_mut, Const); self.register_type(mono("Float!"), float_mut, Const);
self.register_type(class("Ratio!"), ratio_mut, Const); self.register_type(mono("Ratio!"), ratio_mut, Const);
self.register_type(class("Bool!"), bool_mut, Const); self.register_type(mono("Bool!"), bool_mut, Const);
self.register_type(class("Str!"), str_mut, Const); self.register_type(mono("Str!"), str_mut, Const);
self.register_type(array_mut_t, array_mut, Const); self.register_type(array_mut_t, array_mut, Const);
self.register_type(range_t, range, Const); self.register_type(range_t, range, Const);
self.register_type(class("Tuple"), tuple_, Const); self.register_type(mono("Tuple"), tuple_, Const);
self.register_type(class("Function"), func, Const); self.register_type(mono("Function"), func, Const);
self.register_type(class("QuantifiedFunction"), qfunc, Const); self.register_type(mono("QuantifiedFunction"), qfunc, Const);
} }
fn init_builtin_funcs(&mut self) { fn init_builtin_funcs(&mut self) {
let t_abs = nd_func(vec![param_t("n", trait_("Num"))], None, Nat); let t_abs = nd_func(vec![param_t("n", mono("Num"))], None, Nat);
let t_assert = func( let t_assert = func(
vec![param_t("condition", Bool)], vec![param_t("condition", Bool)],
None, None,
@ -1054,7 +1036,7 @@ impl Context {
vec![ vec![
param_t("sep", Str), param_t("sep", Str),
param_t("end", Str), param_t("end", Str),
param_t("file", class("Write")), param_t("file", mono("Write")),
param_t("flush", Bool), param_t("flush", Bool),
], ],
NoneType, NoneType,
@ -1096,7 +1078,7 @@ impl Context {
vec![ vec![
param_t("sep", Str), param_t("sep", Str),
param_t("end", Str), param_t("end", Str),
param_t("file", class("Write")), param_t("file", mono("Write")),
param_t("flush", Bool), param_t("flush", Bool),
], ],
NoneType, NoneType,
@ -1123,7 +1105,7 @@ impl Context {
let t_for = quant(t_for, set! {static_instance("T", Type)}); let t_for = quant(t_for, set! {static_instance("T", Type)});
let t_while = nd_proc( let t_while = nd_proc(
vec![ vec![
param_t("cond", class("Bool!")), param_t("cond", mono("Bool!")),
param_t("p", nd_proc(vec![], None, NoneType)), param_t("p", nd_proc(vec![], None, NoneType)),
], ],
None, None,
@ -1150,7 +1132,7 @@ impl Context {
op_t, op_t,
set! { set! {
static_instance("R", Type), static_instance("R", Type),
subtypeof(l.clone(), poly_trait("Add", params.clone())) subtypeof(l.clone(), poly("Add", params.clone()))
}, },
); );
self.register_impl("__add__", op_t, Const, Private); self.register_impl("__add__", op_t, Const, Private);
@ -1159,7 +1141,7 @@ impl Context {
op_t, op_t,
set! { set! {
static_instance("R", Type), static_instance("R", Type),
subtypeof(l.clone(), poly_trait("Sub", params.clone())) subtypeof(l.clone(), poly("Sub", params.clone()))
}, },
); );
self.register_impl("__sub__", op_t, Const, Private); self.register_impl("__sub__", op_t, Const, Private);
@ -1168,7 +1150,7 @@ impl Context {
op_t, op_t,
set! { set! {
static_instance("R", Type), static_instance("R", Type),
subtypeof(l.clone(), poly_trait("Mul", params.clone())) subtypeof(l.clone(), poly("Mul", params.clone()))
}, },
); );
self.register_impl("__mul__", op_t, Const, Private); self.register_impl("__mul__", op_t, Const, Private);
@ -1177,27 +1159,27 @@ impl Context {
op_t, op_t,
set! { set! {
static_instance("R", Type), static_instance("R", Type),
subtypeof(l, poly_trait("Mul", params.clone())) subtypeof(l, poly("Mul", params.clone()))
}, },
); );
self.register_impl("__div__", op_t, Const, Private); self.register_impl("__div__", op_t, Const, Private);
let m = mono_q("M"); let m = mono_q("M");
let op_t = bin_op(m.clone(), m.clone(), m.clone()); let op_t = bin_op(m.clone(), m.clone(), m.clone());
let op_t = quant(op_t, set! {subtypeof(m, poly_trait("Mul", vec![]))}); let op_t = quant(op_t, set! {subtypeof(m, poly("Mul", vec![]))});
// TODO: add bound: M == MulO // TODO: add bound: M == MulO
self.register_impl("__pow__", op_t, Const, Private); self.register_impl("__pow__", op_t, Const, Private);
let d = mono_q("D"); let d = mono_q("D");
let op_t = bin_op(d.clone(), d.clone(), d.clone()); let op_t = bin_op(d.clone(), d.clone(), d.clone());
let op_t = quant(op_t, set! {subtypeof(d, poly_trait("Div", vec![]))}); let op_t = quant(op_t, set! {subtypeof(d, poly("Div", vec![]))});
self.register_impl("__mod__", op_t, Const, Private); self.register_impl("__mod__", op_t, Const, Private);
let e = mono_q("E"); let e = mono_q("E");
let op_t = bin_op(e.clone(), e.clone(), Bool); let op_t = bin_op(e.clone(), e.clone(), Bool);
let op_t = quant(op_t, set! {subtypeof(e, poly_trait("Eq", vec![]))}); let op_t = quant(op_t, set! {subtypeof(e, poly("Eq", vec![]))});
self.register_impl("__eq__", op_t.clone(), Const, Private); self.register_impl("__eq__", op_t.clone(), Const, Private);
self.register_impl("__ne__", op_t, Const, Private); self.register_impl("__ne__", op_t, Const, Private);
let o = mono_q("O"); let o = mono_q("O");
let op_t = bin_op(o.clone(), o.clone(), Bool); let op_t = bin_op(o.clone(), o.clone(), Bool);
let op_t = quant(op_t, set! {subtypeof(o, trait_("Ord"))}); let op_t = quant(op_t, set! {subtypeof(o, mono("Ord"))});
self.register_impl("__lt__", op_t.clone(), Const, Private); self.register_impl("__lt__", op_t.clone(), Const, Private);
self.register_impl("__le__", op_t.clone(), Const, Private); self.register_impl("__le__", op_t.clone(), Const, Private);
self.register_impl("__gt__", op_t.clone(), Const, Private); self.register_impl("__gt__", op_t.clone(), Const, Private);
@ -1206,7 +1188,7 @@ impl Context {
self.register_impl("__or__", bin_op(Bool, Bool, Bool), Const, Private); self.register_impl("__or__", bin_op(Bool, Bool, Bool), Const, Private);
let t = mono_q("T"); let t = mono_q("T");
let op_t = bin_op(t.clone(), t.clone(), range(t.clone())); let op_t = bin_op(t.clone(), t.clone(), range(t.clone()));
let op_t = quant(op_t, set! {subtypeof(t.clone(), trait_("Ord"))}); let op_t = quant(op_t, set! {subtypeof(t.clone(), mono("Ord"))});
self.register_decl("__rng__", op_t.clone(), Private); self.register_decl("__rng__", op_t.clone(), Private);
self.register_decl("__lorng__", op_t.clone(), Private); self.register_decl("__lorng__", op_t.clone(), Private);
self.register_decl("__rorng__", op_t.clone(), Private); self.register_decl("__rorng__", op_t.clone(), Private);
@ -1215,17 +1197,17 @@ impl Context {
let op_t = bin_op(mono_q("T"), mono_q("I"), Bool); let op_t = bin_op(mono_q("T"), mono_q("I"), Bool);
let op_t = quant( let op_t = quant(
op_t, op_t,
set! { static_instance("T", Type), subtypeof(mono_q("I"), poly_trait("In", vec![ty_tp(mono_q("T"))])) }, set! { static_instance("T", Type), subtypeof(mono_q("I"), poly("In", vec![ty_tp(mono_q("T"))])) },
); );
self.register_impl("__in__", op_t, Const, Private); self.register_impl("__in__", op_t, Const, Private);
/* unary */ /* unary */
// TODO: Boolの+/-は警告を出したい // TODO: Boolの+/-は警告を出したい
let op_t = func1(mono_q("T"), mono_proj(mono_q("T"), "MutType!")); let op_t = func1(mono_q("T"), mono_proj(mono_q("T"), "MutType!"));
let op_t = quant(op_t, set! {subtypeof(mono_q("T"), trait_("Mutizable"))}); let op_t = quant(op_t, set! {subtypeof(mono_q("T"), mono("Mutizable"))});
self.register_impl("__mutate__", op_t, Const, Private); self.register_impl("__mutate__", op_t, Const, Private);
let n = mono_q("N"); let n = mono_q("N");
let op_t = func1(n.clone(), n.clone()); let op_t = func1(n.clone(), n.clone());
let op_t = quant(op_t, set! {subtypeof(n, trait_("Num"))}); let op_t = quant(op_t, set! {subtypeof(n, mono("Num"))});
self.register_decl("__pos__", op_t.clone(), Private); self.register_decl("__pos__", op_t.clone(), Private);
self.register_decl("__neg__", op_t, Private); self.register_decl("__neg__", op_t, Private);
} }
@ -1247,8 +1229,8 @@ impl Context {
params, params,
vec![Type::from(&m..=&n)], vec![Type::from(&m..=&n)],
vec![ vec![
poly_trait("Add", vec![TyParam::from(&o..=&p)]), poly("Add", vec![TyParam::from(&o..=&p)]),
poly_trait("Sub", vec![TyParam::from(&o..=&p)]), poly("Sub", vec![TyParam::from(&o..=&p)]),
], ],
Self::TOP_LEVEL, Self::TOP_LEVEL,
); );

6
compiler/erg_compiler/context/initialize/py_mods/io.rs
View file

@ -1,7 +1,7 @@
use erg_common::vis::Visibility; use erg_common::vis::Visibility;
use erg_common::Str; use erg_common::Str;
use erg_type::constructors::{class, pr0_met}; use erg_type::constructors::{mono, pr0_met};
use erg_type::Type; use erg_type::Type;
use Type::*; use Type::*;
@ -16,11 +16,11 @@ impl Context {
let mut string_io = Context::mono_class(Str::ever("StringIO!"), vec![Obj], vec![], 0); let mut string_io = Context::mono_class(Str::ever("StringIO!"), vec![Obj], vec![], 0);
string_io.register_impl( string_io.register_impl(
"getvalue!", "getvalue!",
pr0_met(class("StringIO!"), None, Str), pr0_met(mono("StringIO!"), None, Str),
Immutable, Immutable,
Public, Public,
); );
io.register_type(class("StringIO!"), string_io, Const); io.register_type(mono("StringIO!"), string_io, Const);
io io
} }
} }

6
compiler/erg_compiler/context/initialize/py_mods/random.rs
View file

@ -2,7 +2,7 @@ use erg_common::set;
use erg_common::vis::Visibility; use erg_common::vis::Visibility;
use erg_type::constructors::{ use erg_type::constructors::{
mono_q, nd_proc, param_t, poly_trait, proc, quant, static_instance, trait_, ty_tp, mono, mono_q, nd_proc, param_t, poly, proc, quant, static_instance, ty_tp,
}; };
use erg_type::Type; use erg_type::Type;
use Type::*; use Type::*;
@ -21,7 +21,7 @@ impl Context {
vec![], vec![],
None, None,
vec![ vec![
param_t("a", trait_("Num")), // TODO: NoneType, int, float, str, bytes, bytearray param_t("a", mono("Num")), // TODO: NoneType, int, float, str, bytes, bytearray
param_t("version", Int), param_t("version", Int),
], ],
NoneType, NoneType,
@ -36,7 +36,7 @@ impl Context {
Public, Public,
); );
let t = nd_proc( let t = nd_proc(
vec![param_t("seq", poly_trait("Seq", vec![ty_tp(mono_q("T"))]))], vec![param_t("seq", poly("Seq", vec![ty_tp(mono_q("T"))]))],
None, None,
mono_q("T"), mono_q("T"),
); );

6
compiler/erg_compiler/context/initialize/py_mods/socket.rs
View file

@ -1,7 +1,7 @@
use erg_common::vis::Visibility; use erg_common::vis::Visibility;
use erg_common::Str; use erg_common::Str;
use erg_type::constructors::{class, func, option, param_t}; use erg_type::constructors::{func, mono, option, param_t};
use erg_type::Type; use erg_type::Type;
use Type::*; use Type::*;
@ -25,12 +25,12 @@ impl Context {
param_t("proto", Int), param_t("proto", Int),
param_t("fileno", option(Int)), param_t("fileno", option(Int)),
], ],
class("Socket!"), mono("Socket!"),
), ),
Immutable, Immutable,
Public, Public,
); );
socket.register_type(class("Socket!"), sock, Const); socket.register_type(mono("Socket!"), sock, Const);
socket socket
} }
} }

12
compiler/erg_compiler/context/initialize/py_mods/sys.rs
View file

@ -1,6 +1,6 @@
use erg_common::vis::Visibility; use erg_common::vis::Visibility;
use erg_type::constructors::{array, array_mut, class, func0, func1, proc1}; use erg_type::constructors::{array, array_mut, func0, func1, mono, proc1};
use erg_type::typaram::TyParam; use erg_type::typaram::TyParam;
use erg_type::Type; use erg_type::Type;
use Type::*; use Type::*;
@ -33,17 +33,17 @@ impl Context {
); );
sys.register_impl("platform", Str, Immutable, Public); sys.register_impl("platform", Str, Immutable, Public);
sys.register_impl("prefix", Str, Immutable, Public); sys.register_impl("prefix", Str, Immutable, Public);
sys.register_impl("ps1", class("Str!"), Immutable, Public); sys.register_impl("ps1", mono("Str!"), Immutable, Public);
sys.register_impl("ps2", class("Str!"), Immutable, Public); sys.register_impl("ps2", mono("Str!"), Immutable, Public);
sys.register_impl( sys.register_impl(
"setrecursionlimit!", "setrecursionlimit!",
proc1(Int, NoneType), proc1(Int, NoneType),
Immutable, Immutable,
Public, Public,
); );
sys.register_impl("stderr", class("TextIOWrapper!"), Immutable, Public); sys.register_impl("stderr", mono("TextIOWrapper!"), Immutable, Public);
sys.register_impl("stdin", class("TextIOWrapper!"), Immutable, Public); sys.register_impl("stdin", mono("TextIOWrapper!"), Immutable, Public);
sys.register_impl("stdout", class("TextIOWrapper!"), Immutable, Public); sys.register_impl("stdout", mono("TextIOWrapper!"), Immutable, Public);
sys.register_impl("version", Str, Immutable, Public); sys.register_impl("version", Str, Immutable, Public);
sys sys
} }

20
compiler/erg_compiler/context/inquire.rs
View file

@ -14,9 +14,7 @@ use ast::VarName;
use erg_parser::ast; use erg_parser::ast;
use erg_parser::token::Token; use erg_parser::token::Token;
use erg_type::constructors::{ use erg_type::constructors::{func, mono, mono_proj, poly, ref_, ref_mut, refinement, subr_t};
class, func, mono_proj, poly_class, ref_, ref_mut, refinement, subr_t,
};
use erg_type::free::Constraint; use erg_type::free::Constraint;
use erg_type::typaram::TyParam; use erg_type::typaram::TyParam;
use erg_type::value::ValueObj; use erg_type::value::ValueObj;
@ -119,9 +117,9 @@ impl Context {
pos_arg.loc(), pos_arg.loc(),
self.caused_by(), self.caused_by(),
"match", "match",
&class("LambdaFunc"), &mono("LambdaFunc"),
t, t,
self.get_type_mismatch_hint(&class("LambdaFunc"), t), self.get_type_mismatch_hint(&mono("LambdaFunc"), t),
)); ));
} }
} }
@ -441,10 +439,10 @@ impl Context {
fv.update_constraint(new_constraint); fv.update_constraint(new_constraint);
Ok(Type::FreeVar(fv)) Ok(Type::FreeVar(fv))
} }
Type::PolyTrait { name, params } if params.iter().all(|tp| tp.has_no_unbound_var()) => { Type::Poly { name, params } if params.iter().all(|tp| tp.has_no_unbound_var()) => {
let t_name = name.clone(); let t_name = name.clone();
let t_params = params.clone(); let t_params = params.clone();
let maybe_trait = Type::PolyTrait { name, params }; let maybe_trait = Type::Poly { name, params };
let mut min = Type::Obj; let mut min = Type::Obj;
for pair in self.rec_get_trait_impls(&t_name) { for pair in self.rec_get_trait_impls(&t_name) {
if self.rec_supertype_of(&pair.sup_trait, &maybe_trait) { if self.rec_supertype_of(&pair.sup_trait, &maybe_trait) {
@ -466,7 +464,7 @@ impl Context {
} }
} }
} }
Ok(poly_class(t_name, new_params)) Ok(poly(t_name, new_params))
} else { } else {
Ok(min) Ok(min)
} }
@ -969,7 +967,7 @@ impl Context {
concatenated concatenated
} }
pub(crate) fn rec_get_nominal_super_trait_ctxs<'a>( pub(crate) fn rec_get_nominal_super_classctxs<'a>(
&'a self, &'a self,
t: &Type, t: &Type,
) -> impl Iterator<Item = (&'a Type, &'a Context)> { ) -> impl Iterator<Item = (&'a Type, &'a Context)> {
@ -1026,9 +1024,9 @@ impl Context {
return self.rec_get_nominal_type_ctx(&refine.t); return self.rec_get_nominal_type_ctx(&refine.t);
} }
Type::Quantified(_) => { Type::Quantified(_) => {
return self.rec_get_nominal_type_ctx(&class("QuantifiedFunction")); return self.rec_get_nominal_type_ctx(&mono("QuantifiedFunction"));
} }
Type::PolyClass { name, params: _ } | Type::PolyTrait { name, params: _ } => { Type::Poly { name, params: _ } => {
if let Some((t, ctx)) = self.poly_types.get(name) { if let Some((t, ctx)) = self.poly_types.get(name) {
return Some((t, ctx)); return Some((t, ctx));
} }

33
compiler/erg_compiler/context/instantiate.rs
View file

@ -105,7 +105,7 @@ impl TyVarContext {
) -> Type { ) -> Type {
if let Some(temp_defaults) = ctx.rec_get_const_param_defaults(&name) { if let Some(temp_defaults) = ctx.rec_get_const_param_defaults(&name) {
let (_, ctx) = ctx let (_, ctx) = ctx
.rec_get_nominal_type_ctx(&poly_trait(name.clone(), params.clone())) .rec_get_nominal_type_ctx(&poly(name.clone(), params.clone()))
.unwrap_or_else(|| panic!("{} not found", name)); .unwrap_or_else(|| panic!("{} not found", name));
let defined_params_len = ctx.params.len(); let defined_params_len = ctx.params.len();
let given_params_len = params.len(); let given_params_len = params.len();
@ -130,9 +130,9 @@ impl TyVarContext {
self.push_or_init_typaram(&tp.tvar_name().unwrap(), &tp); self.push_or_init_typaram(&tp.tvar_name().unwrap(), &tp);
inst_defaults.push(tp); inst_defaults.push(tp);
} }
poly_trait(name, [inst_non_defaults, inst_defaults].concat()) poly(name, [inst_non_defaults, inst_defaults].concat())
} else { } else {
poly_trait( poly(
name, name,
params params
.into_iter() .into_iter()
@ -154,18 +154,16 @@ impl TyVarContext {
match bound { match bound {
TyBound::Sandwiched { sub, mid, sup } => { TyBound::Sandwiched { sub, mid, sup } => {
let sub_instance = match sub { let sub_instance = match sub {
Type::PolyTrait { name, params } => { Type::Poly { name, params } => {
self.instantiate_poly(mid.name(), &name, params, ctx) self.instantiate_poly(mid.name(), &name, params, ctx)
} }
Type::PolyClass { .. } => todo!(),
Type::MonoProj { lhs, rhs } => mono_proj(self.instantiate_qvar(*lhs), rhs), Type::MonoProj { lhs, rhs } => mono_proj(self.instantiate_qvar(*lhs), rhs),
sub => sub, sub => sub,
}; };
let sup_instance = match sup { let sup_instance = match sup {
Type::PolyTrait { name, params } => { Type::Poly { name, params } => {
self.instantiate_poly(mid.name(), &name, params, ctx) self.instantiate_poly(mid.name(), &name, params, ctx)
} }
Type::PolyClass { .. } => todo!(),
Type::MonoProj { lhs, rhs } => mono_proj(self.instantiate_qvar(*lhs), rhs), Type::MonoProj { lhs, rhs } => mono_proj(self.instantiate_qvar(*lhs), rhs),
sup => sup, sup => sup,
}; };
@ -178,8 +176,7 @@ impl TyVarContext {
} }
TyBound::Instance { name, t } => { TyBound::Instance { name, t } => {
let t = match t { let t = match t {
Type::PolyClass { .. } => todo!(), Type::Poly { name, params } => {
Type::PolyTrait { name, params } => {
self.instantiate_poly(name.clone(), &name, params, ctx) self.instantiate_poly(name.clone(), &name, params, ctx)
} }
t => t, t => t,
@ -510,10 +507,10 @@ impl Context {
let len = self.instantiate_const_expr(&len.expr); let len = self.instantiate_const_expr(&len.expr);
Ok(array(t, len)) Ok(array(t, len))
} else { } else {
Ok(class("GenericArray")) Ok(mono("GenericArray"))
} }
} }
other if simple.args.is_empty() => Ok(class(Str::rc(other))), other if simple.args.is_empty() => Ok(mono(Str::rc(other))),
other => { other => {
// FIXME: kw args // FIXME: kw args
let params = simple.args.pos_args().map(|arg| match &arg.expr { let params = simple.args.pos_args().map(|arg| match &arg.expr {
@ -523,7 +520,7 @@ impl Context {
} }
}); });
// FIXME: if type is a trait // FIXME: if type is a trait
Ok(poly_class(Str::rc(other), params.collect())) Ok(poly(Str::rc(other), params.collect()))
} }
} }
} }
@ -543,7 +540,7 @@ impl Context {
expr: &ast::ConstExpr, expr: &ast::ConstExpr,
) -> TyCheckResult<Type> { ) -> TyCheckResult<Type> {
match expr { match expr {
ast::ConstExpr::Accessor(ast::ConstAccessor::Local(name)) => Ok(class(name.inspect())), ast::ConstExpr::Accessor(ast::ConstAccessor::Local(name)) => Ok(mono(name.inspect())),
_ => todo!(), _ => todo!(),
} }
} }
@ -813,17 +810,11 @@ impl Context {
let lhs = Self::instantiate_t(*lhs, tv_ctx); let lhs = Self::instantiate_t(*lhs, tv_ctx);
mono_proj(lhs, rhs) mono_proj(lhs, rhs)
} }
PolyClass { name, mut params } => { Poly { name, mut params } => {
for param in params.iter_mut() { for param in params.iter_mut() {
*param = Self::instantiate_tp(mem::take(param), tv_ctx); *param = Self::instantiate_tp(mem::take(param), tv_ctx);
} }
poly_class(name, params) poly(name, params)
}
PolyTrait { name, mut params } => {
for param in params.iter_mut() {
*param = Self::instantiate_tp(mem::take(param), tv_ctx);
}
poly_trait(name, params)
} }
Quantified(_) => { Quantified(_) => {
panic!("a quantified type should not be instantiated, instantiate the inner type") panic!("a quantified type should not be instantiated, instantiate the inner type")

2
compiler/erg_compiler/context/mod.rs
View file

@ -84,7 +84,7 @@ pub enum TyParamIdx {
impl TyParamIdx { impl TyParamIdx {
pub fn search(search_from: &Type, target: &Type) -> Option<Self> { pub fn search(search_from: &Type, target: &Type) -> Option<Self> {
match search_from { match search_from {
Type::PolyClass { params, .. } => { Type::Poly { params, .. } => {
for (i, tp) in params.iter().enumerate() { for (i, tp) in params.iter().enumerate() {
match tp { match tp {
TyParam::Type(t) if t.as_ref() == target => return Some(Self::Nth(i)), TyParam::Type(t) if t.as_ref() == target => return Some(Self::Nth(i)),

8
compiler/erg_compiler/context/test.rs
View file

@ -2,7 +2,7 @@
use erg_common::Str; use erg_common::Str;
use erg_common::{enum_unwrap, set}; use erg_common::{enum_unwrap, set};
use erg_type::constructors::{func1, mono_q, poly_trait, quant, refinement}; use erg_type::constructors::{func1, mono_q, poly, quant, refinement};
use erg_type::typaram::TyParam; use erg_type::typaram::TyParam;
use erg_type::{Predicate, TyBound, Type}; use erg_type::{Predicate, TyBound, Type};
use Type::*; use Type::*;
@ -28,7 +28,7 @@ impl Context {
} }
pub fn test_resolve_trait(&self) -> Result<(), ()> { pub fn test_resolve_trait(&self) -> Result<(), ()> {
let t = poly_trait("Add", vec![TyParam::t(Nat)]); let t = poly("Add", vec![TyParam::t(Nat)]);
match self.resolve_trait(t) { match self.resolve_trait(t) {
Ok(Nat) => Ok(()), Ok(Nat) => Ok(()),
Ok(other) => { Ok(other) => {
@ -46,7 +46,7 @@ impl Context {
pub fn test_resolve_trait_inner1(&self) -> Result<(), ()> { pub fn test_resolve_trait_inner1(&self) -> Result<(), ()> {
let name = Str::ever("Add"); let name = Str::ever("Add");
let params = vec![TyParam::t(Nat)]; let params = vec![TyParam::t(Nat)];
let maybe_trait = poly_trait(name.clone(), params); let maybe_trait = poly(name.clone(), params);
let mut min = Type::Obj; let mut min = Type::Obj;
for pair in self.rec_get_trait_impls(&name) { for pair in self.rec_get_trait_impls(&name) {
if self.rec_supertype_of(&pair.sup_trait, &maybe_trait) { if self.rec_supertype_of(&pair.sup_trait, &maybe_trait) {
@ -62,7 +62,7 @@ impl Context {
pub fn test_instantiation_and_generalization(&self) -> Result<(), ()> { pub fn test_instantiation_and_generalization(&self) -> Result<(), ()> {
let t = mono_q("T"); let t = mono_q("T");
let eq = poly_trait("Eq", vec![TyParam::t(t.clone())]); let eq = poly("Eq", vec![TyParam::t(t.clone())]);
let bound = TyBound::subtype_of(t.clone(), eq.clone()); let bound = TyBound::subtype_of(t.clone(), eq.clone());
let bounds = set! {bound}; let bounds = set! {bound};
let unbound_t = func1(t.clone(), t.clone()); let unbound_t = func1(t.clone(), t.clone());

86
compiler/erg_compiler/context/tyvar.rs
View file

@ -158,19 +158,12 @@ impl Context {
Callable { .. } => todo!(), Callable { .. } => todo!(),
Ref(t) => ref_(self.generalize_t_inner(*t, bounds, lazy_inits)), Ref(t) => ref_(self.generalize_t_inner(*t, bounds, lazy_inits)),
RefMut(t) => ref_mut(self.generalize_t_inner(*t, bounds, lazy_inits)), RefMut(t) => ref_mut(self.generalize_t_inner(*t, bounds, lazy_inits)),
PolyClass { name, mut params } => { Poly { name, mut params } => {
let params = params let params = params
.iter_mut() .iter_mut()
.map(|p| self.generalize_tp(mem::take(p), bounds, lazy_inits)) .map(|p| self.generalize_tp(mem::take(p), bounds, lazy_inits))
.collect::<Vec<_>>(); .collect::<Vec<_>>();
poly_class(name, params) poly(name, params)
}
PolyTrait { name, mut params } => {
let params = params
.iter_mut()
.map(|p| self.generalize_tp(mem::take(p), bounds, lazy_inits))
.collect::<Vec<_>>();
poly_trait(name, params)
} }
// REVIEW: その他何でもそのまま通していいのか? // REVIEW: その他何でもそのまま通していいのか?
other => other, other => other,
@ -313,17 +306,11 @@ impl Context {
let t = fv.unwrap_linked(); let t = fv.unwrap_linked();
self.deref_tyvar(t) self.deref_tyvar(t)
} }
Type::PolyClass { name, mut params } => { Type::Poly { name, mut params } => {
for param in params.iter_mut() { for param in params.iter_mut() {
*param = self.deref_tp(mem::take(param))?; *param = self.deref_tp(mem::take(param))?;
} }
Ok(Type::PolyClass { name, params }) let t = Type::Poly { name, params };
}
Type::PolyTrait { name, mut params } => {
for param in params.iter_mut() {
*param = self.deref_tp(mem::take(param))?;
}
let t = Type::PolyTrait { name, params };
self.resolve_trait(t) self.resolve_trait(t)
} }
Type::Subr(mut subr) => { Type::Subr(mut subr) => {
@ -569,7 +556,7 @@ impl Context {
} else if allow_divergence } else if allow_divergence
&& (self.eq_tp(tp, &TyParam::value(Inf)) && (self.eq_tp(tp, &TyParam::value(Inf))
|| self.eq_tp(tp, &TyParam::value(NegInf))) || self.eq_tp(tp, &TyParam::value(NegInf)))
&& self.rec_subtype_of(&fv_t, &trait_("Num")) && self.rec_subtype_of(&fv_t, &mono("Num"))
{ {
fv.link(tp); fv.link(tp);
Ok(()) Ok(())
@ -844,11 +831,11 @@ impl Context {
(Type::Ref(l), r) | (Type::RefMut(l), r) => self.unify(l, r, lhs_loc, rhs_loc), (Type::Ref(l), r) | (Type::RefMut(l), r) => self.unify(l, r, lhs_loc, rhs_loc),
(l, Type::Ref(r)) | (l, Type::RefMut(r)) => self.unify(l, r, lhs_loc, rhs_loc), (l, Type::Ref(r)) | (l, Type::RefMut(r)) => self.unify(l, r, lhs_loc, rhs_loc),
( (
Type::PolyClass { Type::Poly {
name: ln, name: ln,
params: lps, params: lps,
}, },
Type::PolyClass { Type::Poly {
name: rn, name: rn,
params: rps, params: rps,
}, },
@ -868,32 +855,7 @@ impl Context {
} }
Ok(()) Ok(())
} }
( (Type::Poly { name: _, params: _ }, _r) => {
Type::PolyTrait {
name: ln,
params: lps,
},
Type::PolyTrait {
name: rn,
params: rps,
},
) => {
if ln != rn {
return Err(TyCheckError::unification_error(
line!() as usize,
lhs_t,
rhs_t,
lhs_loc,
rhs_loc,
self.caused_by(),
));
}
for (l, r) in lps.iter().zip(rps.iter()) {
self.unify_tp(l, r, None, false)?;
}
Ok(())
}
(Type::PolyClass { name: _, params: _ }, _r) => {
todo!() todo!()
} }
(l, r) => Err(TyCheckError::unification_error( (l, r) => Err(TyCheckError::unification_error(
@ -931,43 +893,17 @@ impl Context {
(Type::Ref(l), r) | (Type::RefMut(l), r) => self.reunify(l, r, bef_loc, aft_loc), (Type::Ref(l), r) | (Type::RefMut(l), r) => self.reunify(l, r, bef_loc, aft_loc),
(l, Type::Ref(r)) | (l, Type::RefMut(r)) => self.reunify(l, r, bef_loc, aft_loc), (l, Type::Ref(r)) | (l, Type::RefMut(r)) => self.reunify(l, r, bef_loc, aft_loc),
( (
Type::PolyClass { Type::Poly {
name: ln, name: ln,
params: lps, params: lps,
}, },
Type::PolyClass { Type::Poly {
name: rn, name: rn,
params: rps, params: rps,
}, },
) => { ) => {
if ln != rn { if ln != rn {
let before_t = poly_class(ln.clone(), lps.clone()); let before_t = poly(ln.clone(), lps.clone());
return Err(TyCheckError::re_unification_error(
line!() as usize,
&before_t,
after_t,
bef_loc,
aft_loc,
self.caused_by(),
));
}
for (l, r) in lps.iter().zip(rps.iter()) {
self.reunify_tp(l, r)?;
}
Ok(())
}
(
Type::PolyTrait {
name: ln,
params: lps,
},
Type::PolyTrait {
name: rn,
params: rps,
},
) => {
if ln != rn {
let before_t = poly_trait(ln.clone(), lps.clone());
return Err(TyCheckError::re_unification_error( return Err(TyCheckError::re_unification_error(
line!() as usize, line!() as usize,
&before_t, &before_t,

16
compiler/erg_compiler/eval.rs
View file

@ -12,9 +12,7 @@ use OpKind::*;
use erg_parser::ast::*; use erg_parser::ast::*;
use erg_parser::token::{Token, TokenKind}; use erg_parser::token::{Token, TokenKind};
use erg_type::constructors::{ use erg_type::constructors::{enum_t, mono, mono_proj, poly, ref_, ref_mut, refinement, subr_t};
class, enum_t, mono_proj, poly_class, poly_trait, ref_, ref_mut, refinement, subr_t,
};
use erg_type::typaram::{OpKind, TyParam}; use erg_type::typaram::{OpKind, TyParam};
use erg_type::value::ValueObj; use erg_type::value::ValueObj;
use erg_type::{HasType, Predicate, SubrKind, TyBound, Type, ValueArgs}; use erg_type::{HasType, Predicate, SubrKind, TyBound, Type, ValueArgs};
@ -250,7 +248,7 @@ impl Context {
name.loc(), name.loc(),
self.caused_by(), self.caused_by(),
name.inspect(), name.inspect(),
&class("Subroutine"), &mono("Subroutine"),
&obj.t(), &obj.t(),
None, None,
))? ))?
@ -565,17 +563,11 @@ impl Context {
} }
Type::Ref(l) => Ok(ref_(self.eval_t_params(*l, level)?)), Type::Ref(l) => Ok(ref_(self.eval_t_params(*l, level)?)),
Type::RefMut(l) => Ok(ref_mut(self.eval_t_params(*l, level)?)), Type::RefMut(l) => Ok(ref_mut(self.eval_t_params(*l, level)?)),
Type::PolyClass { name, mut params } => { Type::Poly { name, mut params } => {
for p in params.iter_mut() { for p in params.iter_mut() {
*p = self.eval_tp(&mem::take(p))?; *p = self.eval_tp(&mem::take(p))?;
} }
Ok(poly_class(name, params)) Ok(poly(name, params))
}
Type::PolyTrait { name, mut params } => {
for p in params.iter_mut() {
*p = self.eval_tp(&mem::take(p))?;
}
Ok(poly_trait(name, params))
} }
other if other.is_monomorphic() => Ok(other), other if other.is_monomorphic() => Ok(other),
other => todo!("{other}"), other => todo!("{other}"),

10
compiler/erg_compiler/lower.rs
View file

@ -10,7 +10,7 @@ use erg_parser::ast;
use erg_parser::ast::AST; use erg_parser::ast::AST;
use erg_parser::token::{Token, TokenKind}; use erg_parser::token::{Token, TokenKind};
use erg_type::constructors::{array, array_mut, class, free_var, func, poly_class, proc, quant}; use erg_type::constructors::{array, array_mut, free_var, func, mono, poly, proc, quant};
use erg_type::free::Constraint; use erg_type::free::Constraint;
use erg_type::typaram::TyParam; use erg_type::typaram::TyParam;
use erg_type::value::ValueObj; use erg_type::value::ValueObj;
@ -167,7 +167,7 @@ impl ASTLowerer {
match maybe_len { match maybe_len {
Ok(v @ ValueObj::Nat(_)) => { Ok(v @ ValueObj::Nat(_)) => {
if elem.ref_t().is_mut() { if elem.ref_t().is_mut() {
poly_class( poly(
"ArrayWithMutType!", "ArrayWithMutType!",
vec![TyParam::t(elem.t()), TyParam::Value(v)], vec![TyParam::t(elem.t()), TyParam::Value(v)],
) )
@ -175,9 +175,9 @@ impl ASTLowerer {
array(elem.t(), TyParam::Value(v)) array(elem.t(), TyParam::Value(v))
} }
} }
Ok(v @ ValueObj::Mut(_)) if v.class() == class("Nat!") => { Ok(v @ ValueObj::Mut(_)) if v.class() == mono("Nat!") => {
if elem.ref_t().is_mut() { if elem.ref_t().is_mut() {
poly_class( poly(
"ArrayWithMutTypeAndLength!", "ArrayWithMutTypeAndLength!",
vec![TyParam::t(elem.t()), TyParam::Value(v)], vec![TyParam::t(elem.t()), TyParam::Value(v)],
) )
@ -189,7 +189,7 @@ impl ASTLowerer {
// REVIEW: is it ok to ignore the error? // REVIEW: is it ok to ignore the error?
Err(_e) => { Err(_e) => {
if elem.ref_t().is_mut() { if elem.ref_t().is_mut() {
poly_class( poly(
"ArrayWithMutType!", "ArrayWithMutType!",
vec![TyParam::t(elem.t()), TyParam::erased(Type::Nat)], vec![TyParam::t(elem.t()), TyParam::erased(Type::Nat)],
) )

37
compiler/erg_type/constructors.rs
View file

@ -21,25 +21,25 @@ pub fn named_free_var(name: Str, level: usize, constraint: Constraint) -> Type {
} }
pub fn array(elem_t: Type, len: TyParam) -> Type { pub fn array(elem_t: Type, len: TyParam) -> Type {
poly_class("Array", vec![TyParam::t(elem_t), len]) poly("Array", vec![TyParam::t(elem_t), len])
} }
pub fn array_mut(elem_t: Type, len: TyParam) -> Type { pub fn array_mut(elem_t: Type, len: TyParam) -> Type {
poly_class("Array!", vec![TyParam::t(elem_t), len]) poly("Array!", vec![TyParam::t(elem_t), len])
} }
pub fn dict(k_t: Type, v_t: Type) -> Type { pub fn dict(k_t: Type, v_t: Type) -> Type {
poly_class("Dict", vec![TyParam::t(k_t), TyParam::t(v_t)]) poly("Dict", vec![TyParam::t(k_t), TyParam::t(v_t)])
} }
pub fn tuple(args: Vec<Type>) -> Type { pub fn tuple(args: Vec<Type>) -> Type {
let name = format!("Tuple{}", args.len()); let name = format!("Tuple{}", args.len());
poly_class(name, args.into_iter().map(TyParam::t).collect()) poly(name, args.into_iter().map(TyParam::t).collect())
} }
#[inline] #[inline]
pub fn range(t: Type) -> Type { pub fn range(t: Type) -> Type {
poly_class("Range", vec![TyParam::t(t)]) poly("Range", vec![TyParam::t(t)])
} }
pub fn enum_t(s: Set<ValueObj>) -> Type { pub fn enum_t(s: Set<ValueObj>) -> Type {
@ -91,7 +91,7 @@ pub fn int_interval<P: Into<TyParam>, Q: Into<TyParam>>(op: IntervalOp, l: P, r:
} }
pub fn iter(t: Type) -> Type { pub fn iter(t: Type) -> Type {
poly_class("Iter", vec![TyParam::t(t)]) poly("Iter", vec![TyParam::t(t)])
} }
pub fn ref_(t: Type) -> Type { pub fn ref_(t: Type) -> Type {
@ -103,11 +103,11 @@ pub fn ref_mut(t: Type) -> Type {
} }
pub fn option(t: Type) -> Type { pub fn option(t: Type) -> Type {
poly_class("Option", vec![TyParam::t(t)]) poly("Option", vec![TyParam::t(t)])
} }
pub fn option_mut(t: Type) -> Type { pub fn option_mut(t: Type) -> Type {
poly_class("Option!", vec![TyParam::t(t)]) poly("Option!", vec![TyParam::t(t)])
} }
pub fn subr_t( pub fn subr_t(
@ -286,13 +286,8 @@ pub fn callable(param_ts: Vec<Type>, return_t: Type) -> Type {
} }
#[inline] #[inline]
pub fn class<S: Into<Str>>(name: S) -> Type { pub fn mono<S: Into<Str>>(name: S) -> Type {
Type::MonoClass(name.into()) Type::Mono(name.into())
}
#[inline]
pub fn trait_<S: Into<Str>>(name: S) -> Type {
Type::MonoTrait(name.into())
} }
#[inline] #[inline]
@ -301,16 +296,8 @@ pub fn mono_q<S: Into<Str>>(name: S) -> Type {
} }
#[inline] #[inline]
pub fn poly_class<S: Into<Str>>(name: S, params: Vec<TyParam>) -> Type { pub fn poly<S: Into<Str>>(name: S, params: Vec<TyParam>) -> Type {
Type::PolyClass { Type::Poly {
name: name.into(),
params,
}
}
#[inline]
pub fn poly_trait<S: Into<Str>>(name: S, params: Vec<TyParam>) -> Type {
Type::PolyTrait {
name: name.into(), name: name.into(),
params, params,
} }

222
compiler/erg_type/lib.rs
View file

@ -18,7 +18,7 @@ use erg_common::vis::Field;
use erg_common::{enum_unwrap, fmt_option, fmt_set_split_with, set, Str}; use erg_common::{enum_unwrap, fmt_option, fmt_set_split_with, set, Str};
use crate::codeobj::CodeObj; use crate::codeobj::CodeObj;
use crate::constructors::{and, class, int_interval, mono_q}; use crate::constructors::{and, int_interval, mono, mono_q};
use crate::free::{ use crate::free::{
fresh_varname, Constraint, Cyclicity, Free, FreeKind, FreeTyVar, HasLevel, Level, fresh_varname, Constraint, Cyclicity, Free, FreeKind, FreeTyVar, HasLevel, Level,
}; };
@ -1149,8 +1149,7 @@ pub enum Type {
NotImplemented, NotImplemented,
Ellipsis, // これはクラスのほうで型推論用のマーカーではない Ellipsis, // これはクラスのほうで型推論用のマーカーではない
Never, // {} Never, // {}
MonoClass(Str), Mono(Str),
MonoTrait(Str),
/* Polymorphic types */ /* Polymorphic types */
Ref(Box<Type>), Ref(Box<Type>),
RefMut(Box<Type>), RefMut(Box<Type>),
@ -1173,14 +1172,10 @@ pub enum Type {
And(Box<Type>, Box<Type>), And(Box<Type>, Box<Type>),
Not(Box<Type>, Box<Type>), Not(Box<Type>, Box<Type>),
Or(Box<Type>, Box<Type>), Or(Box<Type>, Box<Type>),
PolyClass { Poly {
name: Str, name: Str,
params: Vec<TyParam>, params: Vec<TyParam>,
}, // T(params) },
PolyTrait {
name: Str,
params: Vec<TyParam>,
}, // T(params)
/* Special types (inference-time types) */ /* Special types (inference-time types) */
MonoQVar(Str), // QuantifiedTyの中で使う一般化型変数、利便性のためMonoとは区別する MonoQVar(Str), // QuantifiedTyの中で使う一般化型変数、利便性のためMonoとは区別する
PolyQVar { PolyQVar {
@ -1221,9 +1216,7 @@ impl PartialEq for Type {
| (Self::NotImplemented, Self::NotImplemented) | (Self::NotImplemented, Self::NotImplemented)
| (Self::Ellipsis, Self::Ellipsis) | (Self::Ellipsis, Self::Ellipsis)
| (Self::Never, Self::Never) => true, | (Self::Never, Self::Never) => true,
(Self::MonoClass(l), Self::MonoClass(r)) | (Self::MonoTrait(l), Self::MonoTrait(r)) => { (Self::Mono(l), Self::Mono(r)) => l == r,
l == r
}
(Self::MonoQVar(l), Self::MonoQVar(r)) => l == r, (Self::MonoQVar(l), Self::MonoQVar(r)) => l == r,
(Self::Ref(l), Self::Ref(r)) | (Self::RefMut(l), Self::RefMut(r)) => l == r, (Self::Ref(l), Self::Ref(r)) | (Self::RefMut(l), Self::RefMut(r)) => l == r,
(Self::Subr(l), Self::Subr(r)) => l == r, (Self::Subr(l), Self::Subr(r)) => l == r,
@ -1255,11 +1248,7 @@ impl PartialEq for Type {
| (Self::Not(ll, lr), Self::Not(rl, rr)) | (Self::Not(ll, lr), Self::Not(rl, rr))
| (Self::Or(ll, lr), Self::Or(rl, rr)) => ll == rl && lr == rr, | (Self::Or(ll, lr), Self::Or(rl, rr)) => ll == rl && lr == rr,
( (
Self::PolyClass { Self::Poly {
name: ln,
params: lps,
}
| Self::PolyTrait {
name: ln, name: ln,
params: lps, params: lps,
} }
@ -1267,11 +1256,7 @@ impl PartialEq for Type {
name: ln, name: ln,
params: lps, params: lps,
}, },
Self::PolyClass { Self::Poly {
name: rn,
params: rps,
}
| Self::PolyTrait {
name: rn, name: rn,
params: rps, params: rps,
} }
@ -1316,7 +1301,7 @@ impl LimitedDisplay for Type {
return write!(f, "..."); return write!(f, "...");
} }
match self { match self {
Self::MonoClass(name) | Self::MonoTrait(name) => write!(f, "{name}"), Self::Mono(name) => write!(f, "{name}"),
Self::Ref(t) | Self::RefMut(t) => { Self::Ref(t) | Self::RefMut(t) => {
write!(f, "{}(", self.name())?; write!(f, "{}(", self.name())?;
t.limited_fmt(f, limit - 1)?; t.limited_fmt(f, limit - 1)?;
@ -1364,7 +1349,7 @@ impl LimitedDisplay for Type {
write!(f, " or ")?; write!(f, " or ")?;
rhs.limited_fmt(f, limit - 1) rhs.limited_fmt(f, limit - 1)
} }
Self::PolyClass { name, params } | Self::PolyTrait { name, params } => { Self::Poly { name, params } => {
write!(f, "{name}(")?; write!(f, "{name}(")?;
for (i, tp) in params.iter().enumerate() { for (i, tp) in params.iter().enumerate() {
if i > 0 { if i > 0 {
@ -1453,7 +1438,7 @@ impl From<&str> for Type {
"Inf" => Self::Inf, "Inf" => Self::Inf,
"NegInf" => Self::NegInf, "NegInf" => Self::NegInf,
"_" => Self::Obj, "_" => Self::Obj,
other => Self::MonoClass(Str::rc(other)), other => Self::Mono(Str::rc(other)),
} }
} }
} }
@ -1483,9 +1468,7 @@ impl HasType for Type {
// Self::And(ts) | Self::Or(ts) => , // Self::And(ts) | Self::Or(ts) => ,
Self::Subr(_sub) => todo!(), Self::Subr(_sub) => todo!(),
Self::Callable { param_ts, .. } => param_ts.clone(), Self::Callable { param_ts, .. } => param_ts.clone(),
Self::PolyClass { params, .. } | Self::PolyTrait { params, .. } => { Self::Poly { params, .. } => params.iter().filter_map(get_t_from_tp).collect(),
params.iter().filter_map(get_t_from_tp).collect()
}
_ => vec![], _ => vec![],
} }
} }
@ -1538,7 +1521,7 @@ impl HasLevel for Type {
t.update_level(level); t.update_level(level);
} }
} }
Self::PolyClass { params, .. } | Self::PolyTrait { params, .. } => { Self::Poly { params, .. } => {
for p in params.iter() { for p in params.iter() {
p.update_level(level); p.update_level(level);
} }
@ -1592,7 +1575,7 @@ impl HasLevel for Type {
t.lift(); t.lift();
} }
} }
Self::PolyClass { params, .. } | Self::PolyTrait { params, .. } => { Self::Poly { params, .. } => {
for p in params.iter() { for p in params.iter() {
p.lift(); p.lift();
} }
@ -1643,12 +1626,12 @@ impl Type {
fv.link(&t.mutate()); fv.link(&t.mutate());
Self::FreeVar(fv) Self::FreeVar(fv)
} }
Self::Int => class("Int!"), Self::Int => mono("Int!"),
Self::Nat => class("Nat!"), Self::Nat => mono("Nat!"),
Self::Ratio => class("Ratio!"), Self::Ratio => mono("Ratio!"),
Self::Float => class("Float!"), Self::Float => mono("Float!"),
Self::Bool => class("Bool!"), Self::Bool => mono("Bool!"),
Self::Str => class("Str!"), Self::Str => mono("Str!"),
_ => todo!(), _ => todo!(),
} }
} }
@ -1682,49 +1665,6 @@ impl Type {
} }
} }
pub fn is_class(&self) -> bool {
match self {
Self::FreeVar(fv) if fv.is_linked() => fv.crack().is_class(),
Self::Refinement(refine) => refine.t.is_class(),
Self::Obj
| Self::Int
| Self::Nat
| Self::Ratio
| Self::Float
| Self::Bool
| Self::Str
| Self::NoneType
| Self::Code
| Self::Module
| Self::Frame
| Self::Error
| Self::Inf
| Self::NegInf
| Self::Type
| Self::Class
| Self::Trait
| Self::Patch
| Self::NotImplemented
| Self::Ellipsis
| Self::Never
| Self::Subr(_)
| Self::Callable { .. }
| Self::Record(_)
| Self::Quantified(_) => true,
Self::MonoClass(_) | Self::PolyClass { .. } => true,
_ => false,
}
}
pub fn is_trait(&self) -> bool {
match self {
Self::FreeVar(fv) if fv.is_linked() => fv.crack().is_trait(),
Self::Refinement(refine) => refine.t.is_trait(),
Self::MonoTrait(_) | Self::PolyTrait { .. } => true,
_ => false,
}
}
pub fn is_mut(&self) -> bool { pub fn is_mut(&self) -> bool {
match self { match self {
Self::FreeVar(fv) => { Self::FreeVar(fv) => {
@ -1734,11 +1674,9 @@ impl Type {
fv.unbound_name().unwrap().ends_with('!') fv.unbound_name().unwrap().ends_with('!')
} }
} }
Self::MonoClass(name) Self::Mono(name)
| Self::MonoTrait(name)
| Self::MonoQVar(name) | Self::MonoQVar(name)
| Self::PolyClass { name, .. } | Self::Poly { name, .. }
| Self::PolyTrait { name, .. }
| Self::PolyQVar { name, .. } | Self::PolyQVar { name, .. }
| Self::MonoProj { rhs: name, .. } => name.ends_with('!'), | Self::MonoProj { rhs: name, .. } => name.ends_with('!'),
Self::Refinement(refine) => refine.t.is_mut(), Self::Refinement(refine) => refine.t.is_mut(),
@ -1750,11 +1688,11 @@ impl Type {
match self { match self {
Self::FreeVar(fv) if fv.is_linked() => fv.crack().is_nonelike(), Self::FreeVar(fv) if fv.is_linked() => fv.crack().is_nonelike(),
Self::NoneType => true, Self::NoneType => true,
Self::PolyClass { name, params } if &name[..] == "Option" || &name[..] == "Option!" => { Self::Poly { name, params } if &name[..] == "Option" || &name[..] == "Option!" => {
let inner_t = enum_unwrap!(params.first().unwrap(), TyParam::Type); let inner_t = enum_unwrap!(params.first().unwrap(), TyParam::Type);
inner_t.is_nonelike() inner_t.is_nonelike()
} }
Self::PolyClass { name, params } if &name[..] == "Tuple" => params.is_empty(), Self::Poly { name, params } if &name[..] == "Tuple" => params.is_empty(),
Self::Refinement(refine) => refine.t.is_nonelike(), Self::Refinement(refine) => refine.t.is_nonelike(),
_ => false, _ => false,
} }
@ -1773,7 +1711,7 @@ impl Type {
.map(|(sub, sup)| sub.contains_tvar(name) || sup.contains_tvar(name)) .map(|(sub, sup)| sub.contains_tvar(name) || sup.contains_tvar(name))
.unwrap_or(false) .unwrap_or(false)
} }
Self::PolyClass { params, .. } | Self::PolyTrait { params, .. } => { Self::Poly { params, .. } => {
for param in params.iter() { for param in params.iter() {
match param { match param {
TyParam::Type(t) if t.contains_tvar(name) => { TyParam::Type(t) if t.contains_tvar(name) => {
@ -1870,7 +1808,7 @@ impl Type {
Self::Error => Str::ever("Error"), Self::Error => Str::ever("Error"),
Self::Inf => Str::ever("Inf"), Self::Inf => Str::ever("Inf"),
Self::NegInf => Str::ever("NegInf"), Self::NegInf => Str::ever("NegInf"),
Self::MonoClass(name) | Self::MonoTrait(name) | Self::MonoQVar(name) => name.clone(), Self::Mono(name) | Self::MonoQVar(name) => name.clone(),
Self::And(_, _) => Str::ever("And"), Self::And(_, _) => Str::ever("And"),
Self::Not(_, _) => Str::ever("Not"), Self::Not(_, _) => Str::ever("Not"),
Self::Or(_, _) => Str::ever("Or"), Self::Or(_, _) => Str::ever("Or"),
@ -1894,9 +1832,7 @@ impl Type {
}) => Str::ever("ProcMethod"), }) => Str::ever("ProcMethod"),
Self::Callable { .. } => Str::ever("Callable"), Self::Callable { .. } => Str::ever("Callable"),
Self::Record(_) => Str::ever("Record"), Self::Record(_) => Str::ever("Record"),
Self::PolyClass { name, .. } Self::Poly { name, .. } | Self::PolyQVar { name, .. } => name.clone(),
| Self::PolyTrait { name, .. }
| Self::PolyQVar { name, .. } => name.clone(),
// NOTE: compiler/codegen/convert_to_python_methodでクラス名を使うため、こうすると都合が良い // NOTE: compiler/codegen/convert_to_python_methodでクラス名を使うため、こうすると都合が良い
Self::Refinement(refine) => refine.t.name(), Self::Refinement(refine) => refine.t.name(),
Self::Quantified(_) => Str::ever("Quantified"), Self::Quantified(_) => Str::ever("Quantified"),
@ -1967,9 +1903,7 @@ impl Type {
quant.unbound_callable.has_unbound_var() quant.unbound_callable.has_unbound_var()
|| quant.bounds.iter().any(|tb| tb.has_qvar()) || quant.bounds.iter().any(|tb| tb.has_qvar())
} }
Self::PolyClass { params, .. } | Self::PolyTrait { params, .. } => { Self::Poly { params, .. } => params.iter().any(|tp| tp.has_qvar()),
params.iter().any(|tp| tp.has_qvar())
}
Self::MonoProj { lhs, .. } => lhs.has_qvar(), Self::MonoProj { lhs, .. } => lhs.has_qvar(),
_ => false, _ => false,
} }
@ -2006,9 +1940,9 @@ impl Type {
Self::Quantified(quant) => { Self::Quantified(quant) => {
quant.unbound_callable.is_cachable() || quant.bounds.iter().all(|b| b.is_cachable()) quant.unbound_callable.is_cachable() || quant.bounds.iter().all(|b| b.is_cachable())
} }
Self::PolyClass { params, .. } Self::Poly { params, .. } | Self::PolyQVar { params, .. } => {
| Self::PolyTrait { params, .. } params.iter().all(|p| p.is_cachable())
| Self::PolyQVar { params, .. } => params.iter().all(|p| p.is_cachable()), }
Self::MonoProj { lhs, .. } => lhs.is_cachable(), Self::MonoProj { lhs, .. } => lhs.is_cachable(),
_ => true, _ => true,
} }
@ -2055,9 +1989,9 @@ impl Type {
quant.unbound_callable.has_unbound_var() quant.unbound_callable.has_unbound_var()
|| quant.bounds.iter().any(|b| b.has_unbound_var()) || quant.bounds.iter().any(|b| b.has_unbound_var())
} }
Self::PolyClass { params, .. } Self::Poly { params, .. } | Self::PolyQVar { params, .. } => {
| Self::PolyTrait { params, .. } params.iter().any(|p| p.has_unbound_var())
| Self::PolyQVar { params, .. } => params.iter().any(|p| p.has_unbound_var()), }
Self::MonoProj { lhs, .. } => lhs.has_no_unbound_var(), Self::MonoProj { lhs, .. } => lhs.has_no_unbound_var(),
_ => false, _ => false,
} }
@ -2082,9 +2016,7 @@ impl Type {
+ 1, + 1,
), ),
Self::Callable { param_ts, .. } => Some(param_ts.len() + 1), Self::Callable { param_ts, .. } => Some(param_ts.len() + 1),
Self::PolyClass { params, .. } Self::Poly { params, .. } | Self::PolyQVar { params, .. } => Some(params.len()),
| Self::PolyTrait { params, .. }
| Self::PolyQVar { params, .. } => Some(params.len()),
_ => None, _ => None,
} }
} }
@ -2100,9 +2032,7 @@ impl Type {
} }
Self::Subr(subr) => subr.typarams(), Self::Subr(subr) => subr.typarams(),
Self::Callable { param_ts: _, .. } => todo!(), Self::Callable { param_ts: _, .. } => todo!(),
Self::PolyClass { params, .. } Self::Poly { params, .. } | Self::PolyQVar { params, .. } => params.clone(),
| Self::PolyTrait { params, .. }
| Self::PolyQVar { params, .. } => params.clone(),
_ => vec![], _ => vec![],
} }
} }
@ -2227,7 +2157,7 @@ impl From<&Type> for TypeCode {
Type::Float => Self::Float64, Type::Float => Self::Float64,
Type::Bool => Self::Bool, Type::Bool => Self::Bool,
Type::Str => Self::Str, Type::Str => Self::Str,
Type::MonoClass(name) => match &name[..] { Type::Mono(name) => match &name[..] {
"Int!" => Self::Int32, "Int!" => Self::Int32,
"Nat!" => Self::Nat64, "Nat!" => Self::Nat64,
"Float!" => Self::Float64, "Float!" => Self::Float64,
@ -2235,7 +2165,7 @@ impl From<&Type> for TypeCode {
"Str!" => Self::Str, "Str!" => Self::Str,
_ => Self::Other, _ => Self::Other,
}, },
Type::PolyClass { name, .. } => match &name[..] { Type::Poly { name, .. } => match &name[..] {
"Array" | "Array!" => Self::Array, "Array" | "Array!" => Self::Array,
"Func" => Self::Func, "Func" => Self::Func,
"Proc" => Self::Proc, "Proc" => Self::Proc,
@ -2404,98 +2334,98 @@ impl TypePair {
(Type::Int, Type::Float) => Self::IntFloat, (Type::Int, Type::Float) => Self::IntFloat,
(Type::Int, Type::Str) => Self::IntStr, (Type::Int, Type::Str) => Self::IntStr,
(Type::Int, Type::Bool) => Self::IntBool, (Type::Int, Type::Bool) => Self::IntBool,
(Type::Int, Type::PolyClass { name, .. }) if &name[..] == "Array" => Self::IntArray, (Type::Int, Type::Poly { name, .. }) if &name[..] == "Array" => Self::IntArray,
(Type::Int, Type::PolyClass { name, .. }) if &name[..] == "Func" => Self::IntFunc, (Type::Int, Type::Poly { name, .. }) if &name[..] == "Func" => Self::IntFunc,
(Type::Int, Type::PolyClass { name, .. }) if &name[..] == "Proc" => Self::IntProc, (Type::Int, Type::Poly { name, .. }) if &name[..] == "Proc" => Self::IntProc,
(Type::Nat, Type::Int) => Self::NatInt, (Type::Nat, Type::Int) => Self::NatInt,
(Type::Nat, Type::Nat) => Self::NatNat, (Type::Nat, Type::Nat) => Self::NatNat,
(Type::Nat, Type::Float) => Self::NatFloat, (Type::Nat, Type::Float) => Self::NatFloat,
(Type::Nat, Type::Str) => Self::NatStr, (Type::Nat, Type::Str) => Self::NatStr,
(Type::Nat, Type::Bool) => Self::NatBool, (Type::Nat, Type::Bool) => Self::NatBool,
(Type::Nat, Type::PolyClass { name, .. }) if &name[..] == "Array" => Self::NatArray, (Type::Nat, Type::Poly { name, .. }) if &name[..] == "Array" => Self::NatArray,
(Type::Nat, Type::PolyClass { name, .. }) if &name[..] == "Func" => Self::NatFunc, (Type::Nat, Type::Poly { name, .. }) if &name[..] == "Func" => Self::NatFunc,
(Type::Nat, Type::PolyClass { name, .. }) if &name[..] == "Proc" => Self::NatProc, (Type::Nat, Type::Poly { name, .. }) if &name[..] == "Proc" => Self::NatProc,
(Type::Float, Type::Int) => Self::FloatInt, (Type::Float, Type::Int) => Self::FloatInt,
(Type::Float, Type::Nat) => Self::FloatNat, (Type::Float, Type::Nat) => Self::FloatNat,
(Type::Float, Type::Float) => Self::FloatFloat, (Type::Float, Type::Float) => Self::FloatFloat,
(Type::Float, Type::Str) => Self::FloatStr, (Type::Float, Type::Str) => Self::FloatStr,
(Type::Float, Type::Bool) => Self::FloatBool, (Type::Float, Type::Bool) => Self::FloatBool,
(Type::Float, Type::PolyClass { name, .. }) if &name[..] == "Array" => Self::FloatArray, (Type::Float, Type::Poly { name, .. }) if &name[..] == "Array" => Self::FloatArray,
(Type::Float, Type::PolyClass { name, .. }) if &name[..] == "Func" => Self::FloatFunc, (Type::Float, Type::Poly { name, .. }) if &name[..] == "Func" => Self::FloatFunc,
(Type::Float, Type::PolyClass { name, .. }) if &name[..] == "Proc" => Self::FloatProc, (Type::Float, Type::Poly { name, .. }) if &name[..] == "Proc" => Self::FloatProc,
(Type::Bool, Type::Int) => Self::BoolInt, (Type::Bool, Type::Int) => Self::BoolInt,
(Type::Bool, Type::Nat) => Self::BoolNat, (Type::Bool, Type::Nat) => Self::BoolNat,
(Type::Bool, Type::Float) => Self::BoolFloat, (Type::Bool, Type::Float) => Self::BoolFloat,
(Type::Bool, Type::Str) => Self::BoolStr, (Type::Bool, Type::Str) => Self::BoolStr,
(Type::Bool, Type::Bool) => Self::BoolBool, (Type::Bool, Type::Bool) => Self::BoolBool,
(Type::Bool, Type::PolyClass { name, .. }) if &name[..] == "Array" => Self::BoolArray, (Type::Bool, Type::Poly { name, .. }) if &name[..] == "Array" => Self::BoolArray,
(Type::Bool, Type::PolyClass { name, .. }) if &name[..] == "Func" => Self::BoolFunc, (Type::Bool, Type::Poly { name, .. }) if &name[..] == "Func" => Self::BoolFunc,
(Type::Bool, Type::PolyClass { name, .. }) if &name[..] == "Proc" => Self::BoolProc, (Type::Bool, Type::Poly { name, .. }) if &name[..] == "Proc" => Self::BoolProc,
(Type::Str, Type::Int) => Self::StrInt, (Type::Str, Type::Int) => Self::StrInt,
(Type::Str, Type::Nat) => Self::StrNat, (Type::Str, Type::Nat) => Self::StrNat,
(Type::Str, Type::Float) => Self::StrFloat, (Type::Str, Type::Float) => Self::StrFloat,
(Type::Str, Type::Bool) => Self::StrBool, (Type::Str, Type::Bool) => Self::StrBool,
(Type::Str, Type::Str) => Self::StrStr, (Type::Str, Type::Str) => Self::StrStr,
(Type::Str, Type::PolyClass { name, .. }) if &name[..] == "Array" => Self::StrArray, (Type::Str, Type::Poly { name, .. }) if &name[..] == "Array" => Self::StrArray,
(Type::Str, Type::PolyClass { name, .. }) if &name[..] == "Func" => Self::StrFunc, (Type::Str, Type::Poly { name, .. }) if &name[..] == "Func" => Self::StrFunc,
(Type::Str, Type::PolyClass { name, .. }) if &name[..] == "Proc" => Self::StrProc, (Type::Str, Type::Poly { name, .. }) if &name[..] == "Proc" => Self::StrProc,
// 要素数は検査済みなので、気にする必要はない // 要素数は検査済みなので、気にする必要はない
(Type::PolyClass { name, .. }, Type::Int) if &name[..] == "Array" => Self::ArrayInt, (Type::Poly { name, .. }, Type::Int) if &name[..] == "Array" => Self::ArrayInt,
(Type::PolyClass { name, .. }, Type::Nat) if &name[..] == "Array" => Self::ArrayNat, (Type::Poly { name, .. }, Type::Nat) if &name[..] == "Array" => Self::ArrayNat,
(Type::PolyClass { name, .. }, Type::Float) if &name[..] == "Array" => Self::ArrayFloat, (Type::Poly { name, .. }, Type::Float) if &name[..] == "Array" => Self::ArrayFloat,
(Type::PolyClass { name, .. }, Type::Str) if &name[..] == "Array" => Self::ArrayStr, (Type::Poly { name, .. }, Type::Str) if &name[..] == "Array" => Self::ArrayStr,
(Type::PolyClass { name, .. }, Type::Bool) if &name[..] == "Array" => Self::ArrayBool, (Type::Poly { name, .. }, Type::Bool) if &name[..] == "Array" => Self::ArrayBool,
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Array" && &rn[..] == "Array" => if &ln[..] == "Array" && &rn[..] == "Array" =>
{ {
Self::ArrayArray Self::ArrayArray
} }
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Array" && &rn[..] == "Func" => if &ln[..] == "Array" && &rn[..] == "Func" =>
{ {
Self::ArrayFunc Self::ArrayFunc
} }
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Array" && &rn[..] == "Proc" => if &ln[..] == "Array" && &rn[..] == "Proc" =>
{ {
Self::ArrayProc Self::ArrayProc
} }
(Type::PolyClass { name, .. }, Type::Int) if &name[..] == "Func" => Self::FuncInt, (Type::Poly { name, .. }, Type::Int) if &name[..] == "Func" => Self::FuncInt,
(Type::PolyClass { name, .. }, Type::Nat) if &name[..] == "Func" => Self::FuncNat, (Type::Poly { name, .. }, Type::Nat) if &name[..] == "Func" => Self::FuncNat,
(Type::PolyClass { name, .. }, Type::Float) if &name[..] == "Func" => Self::FuncFloat, (Type::Poly { name, .. }, Type::Float) if &name[..] == "Func" => Self::FuncFloat,
(Type::PolyClass { name, .. }, Type::Str) if &name[..] == "Func" => Self::FuncStr, (Type::Poly { name, .. }, Type::Str) if &name[..] == "Func" => Self::FuncStr,
(Type::PolyClass { name, .. }, Type::Bool) if &name[..] == "Func" => Self::FuncBool, (Type::Poly { name, .. }, Type::Bool) if &name[..] == "Func" => Self::FuncBool,
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Func" && &rn[..] == "Array" => if &ln[..] == "Func" && &rn[..] == "Array" =>
{ {
Self::FuncArray Self::FuncArray
} }
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Func" && &rn[..] == "Func" => if &ln[..] == "Func" && &rn[..] == "Func" =>
{ {
Self::FuncFunc Self::FuncFunc
} }
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Func" && &rn[..] == "Proc" => if &ln[..] == "Func" && &rn[..] == "Proc" =>
{ {
Self::FuncProc Self::FuncProc
} }
(Type::PolyClass { name, .. }, Type::Int) if &name[..] == "Proc" => Self::ProcInt, (Type::Poly { name, .. }, Type::Int) if &name[..] == "Proc" => Self::ProcInt,
(Type::PolyClass { name, .. }, Type::Nat) if &name[..] == "Proc" => Self::ProcNat, (Type::Poly { name, .. }, Type::Nat) if &name[..] == "Proc" => Self::ProcNat,
(Type::PolyClass { name, .. }, Type::Float) if &name[..] == "Proc" => Self::ProcFloat, (Type::Poly { name, .. }, Type::Float) if &name[..] == "Proc" => Self::ProcFloat,
(Type::PolyClass { name, .. }, Type::Str) if &name[..] == "Proc" => Self::ProcStr, (Type::Poly { name, .. }, Type::Str) if &name[..] == "Proc" => Self::ProcStr,
(Type::PolyClass { name, .. }, Type::Bool) if &name[..] == "Proc" => Self::ProcBool, (Type::Poly { name, .. }, Type::Bool) if &name[..] == "Proc" => Self::ProcBool,
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Proc" && &rn[..] == "Array" => if &ln[..] == "Proc" && &rn[..] == "Array" =>
{ {
Self::ProcArray Self::ProcArray
} }
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Proc" && &rn[..] == "Func" => if &ln[..] == "Proc" && &rn[..] == "Func" =>
{ {
Self::ProcFunc Self::ProcFunc
} }
(Type::PolyClass { name: ln, .. }, Type::PolyClass { name: rn, .. }) (Type::Poly { name: ln, .. }, Type::Poly { name: rn, .. })
if &ln[..] == "Proc" && &rn[..] == "Proc" => if &ln[..] == "Proc" && &rn[..] == "Proc" =>
{ {
Self::ProcProc Self::ProcProc

14
compiler/erg_type/value.rs
View file

@ -17,7 +17,7 @@ use erg_common::{fmt_iter, impl_display_from_debug, switch_lang};
use erg_common::{RcArray, Str}; use erg_common::{RcArray, Str};
use crate::codeobj::CodeObj; use crate::codeobj::CodeObj;
use crate::constructors::{array, class, poly_class, refinement, tuple}; use crate::constructors::{array, mono, poly, refinement, tuple};
use crate::free::fresh_varname; use crate::free::fresh_varname;
use crate::typaram::TyParam; use crate::typaram::TyParam;
use crate::{ConstSubr, HasType, Predicate, Type}; use crate::{ConstSubr, HasType, Predicate, Type};
@ -384,12 +384,12 @@ impl ValueObj {
Self::Inf => Type::Inf, Self::Inf => Type::Inf,
Self::NegInf => Type::NegInf, Self::NegInf => Type::NegInf,
Self::Mut(m) => match &*m.borrow() { Self::Mut(m) => match &*m.borrow() {
Self::Int(_) => class("Int!"), Self::Int(_) => mono("Int!"),
Self::Nat(_) => class("Nat!"), Self::Nat(_) => mono("Nat!"),
Self::Float(_) => class("Float!"), Self::Float(_) => mono("Float!"),
Self::Str(_) => class("Str!"), Self::Str(_) => mono("Str!"),
Self::Bool(_) => class("Bool!"), Self::Bool(_) => mono("Bool!"),
Self::Array(arr) => poly_class( Self::Array(arr) => poly(
"Array!", "Array!",
vec![ vec![
TyParam::t(arr.iter().next().unwrap().class()), TyParam::t(arr.iter().next().unwrap().class()),