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

refactor!: rename Array -> List

Browse source
This commit is contained in:
Shunsuke Shibayama 2024-04-04 23:24:07 +09:00
parent 41bf14629b
commit c6eb78a44d
248 changed files with 1948 additions and 1985 deletions
Download patch file Download diff file Expand all files Collapse all files

34
crates/erg_compiler/context/compare.rs
View file

@ -192,7 +192,7 @@ impl Context {
..
}),
) if &n[..] == "GenericProc" => (Absolutely, true),
(Mono(l), Poly { name: r, .. }) if &l[..] == "GenericArray" && &r[..] == "Array" => {
(Mono(l), Poly { name: r, .. }) if &l[..] == "GenericList" && &r[..] == "List" => {
(Absolutely, true)
}
(Mono(l), Poly { name: r, .. }) if &l[..] == "GenericDict" && &r[..] == "Dict" => {
@ -494,8 +494,8 @@ impl Context {
} else if let Some(lfvt) = lfv.get_type() {
// e.g. lfv: ?L(: Int) is unreachable
// but
// ?L(: Array(Type, 3)) :> Array(Int, 3)
// => Array(Type, 3) :> Array(Typeof(Int), 3)
// ?L(: List(Type, 3)) :> List(Int, 3)
// => List(Type, 3) :> List(Typeof(Int), 3)
// => true
let rhs_meta = self.meta_type(rhs);
self.supertype_of(&lfvt, &rhs_meta)
@ -568,7 +568,7 @@ impl Context {
self.convert_tp_into_value(params[0].clone()).is_ok()
}
(ty @ (Type | ClassType | TraitType), Poly { name, params })
if &name[..] == "Array" || &name[..] == "UnsizedArray" || &name[..] == "Set" =>
if &name[..] == "List" || &name[..] == "UnsizedList" || &name[..] == "Set" =>
{
let Ok(elem_t) = self.convert_tp_into_type(params[0].clone()) else {
return false;
@ -666,8 +666,8 @@ impl Context {
// Int :> {I: Str| ...} == false
// Bool :> {1} == true
// Bool :> {2} == false
// [2, 3]: {A: Array(Nat) | A.prod() == 6}
// Array({1, 2}, _) :> {[3, 4]} == false
// [2, 3]: {A: List(Nat) | A.prod() == 6}
// List({1, 2}, _) :> {[3, 4]} == false
(l, Refinement(r)) => {
// Type / {S: Set(Str) | S == {"a", "b"}}
// TODO: GeneralEq
@ -698,7 +698,7 @@ impl Context {
// {N: Nat | ...} :> Int) == false
// ({I: Int | I >= 0} :> Int) == false
// {U(: Type)} :> { .x = {Int} }(== {{ .x = Int }}) == true
// {[1]} == Array({1}, 1) :> Array({1}, _) == true
// {[1]} == List({1}, 1) :> List({1}, _) == true
(Refinement(l), r) => {
if let Some(r) = r.to_singleton() {
return self.structural_supertype_of(lhs, &Type::Refinement(r));
@ -804,7 +804,7 @@ impl Context {
return false;
}
// [Int; 2] :> [Int; 3]
if &ln[..] == "Array" || &ln[..] == "Set" {
if &ln[..] == "List" || &ln[..] == "Set" {
let Ok(lt) = self.convert_tp_into_type(lparams[0].clone()) else {
return false;
};
@ -941,7 +941,7 @@ impl Context {
self.supertype_of(&self.get_tp_t(sup_p).unwrap_or(Obj), t)
}
},
(TyParam::Array(sup), TyParam::Array(sub))
(TyParam::List(sup), TyParam::List(sub))
| (TyParam::Tuple(sup), TyParam::Tuple(sub)) => {
if sup.len() > sub.len() || (variance.is_invariant() && sup.len() != sub.len()) {
return false;
@ -991,7 +991,7 @@ impl Context {
}
true
}
(TyParam::UnsizedArray(sup), TyParam::UnsizedArray(sub)) => {
(TyParam::UnsizedList(sup), TyParam::UnsizedList(sub)) => {
self.supertype_of_tp(sup, sub, variance)
}
(TyParam::Type(sup), TyParam::Type(sub)) => match variance {
@ -1308,8 +1308,8 @@ impl Context {
/// union(Nat, Int) == Int
/// union(Int, Str) == Int or Str
/// union(?T(<: Str), ?U(<: Int)) == ?T or ?U
/// union(Array(Int, 2), Array(Str, 2)) == Array(Int or Str, 2)
/// union(Array(Int, 2), Array(Str, 3)) == Array(Int, 2) or Array(Int, 3)
/// union(List(Int, 2), List(Str, 2)) == List(Int or Str, 2)
/// union(List(Int, 2), List(Str, 3)) == List(Int, 2) or List(Int, 3)
/// union({ .a = Int }, { .a = Str }) == { .a = Int or Str }
/// union({ .a = Int }, { .a = Int; .b = Int }) == { .a = Int } or { .a = Int; .b = Int } # not to lost `b` information
/// union((A and B) or C) == (A or C) and (B or C)
@ -1387,7 +1387,7 @@ impl Context {
t
}
(t, Type::Never) | (Type::Never, t) => t.clone(),
// Array({1, 2}, 2), Array({3, 4}, 2) ==> Array({1, 2, 3, 4}, 2)
// List({1, 2}, 2), List({3, 4}, 2) ==> List({1, 2, 3, 4}, 2)
(
Type::Poly {
name: ln,
@ -1430,7 +1430,7 @@ impl Context {
Some(TyParam::t(self.union(l, r.typ())))
}
(TyParam::Type(l), TyParam::Type(r)) => Some(TyParam::t(self.union(l, r))),
(TyParam::Array(l), TyParam::Array(r)) => {
(TyParam::List(l), TyParam::List(r)) => {
let mut tps = vec![];
for (l, r) in l.iter().zip(r.iter()) {
if let Some(tp) = self.union_tp(l, r) {
@ -1439,7 +1439,7 @@ impl Context {
return None;
}
}
Some(TyParam::Array(tps))
Some(TyParam::List(tps))
}
(fv @ TyParam::FreeVar(f), other) | (other, fv @ TyParam::FreeVar(f))
if f.is_unbound() =>
@ -2195,7 +2195,7 @@ impl Context {
}
}
/// {[]} == {A: Array(Never, _) | A == []} => Array(Never, 0)
/// {[]} == {A: List(Never, _) | A == []} => List(Never, 0)
pub(crate) fn refinement_to_poly(&self, refine: &RefinementType) -> Option<Type> {
if refine.t.is_monomorphic() {
return None;
@ -2207,7 +2207,7 @@ impl Context {
return None;
}
match &refine.t.qual_name()[..] {
"Array" => self.get_tp_t(rhs).ok().map(|t| t.derefine()),
"List" => self.get_tp_t(rhs).ok().map(|t| t.derefine()),
_ => None,
}
}

135
crates/erg_compiler/context/eval.rs
View file

@ -20,9 +20,9 @@ use erg_parser::desugar::Desugarer;
use erg_parser::token::{Token, TokenKind};
use crate::ty::constructors::{
array_t, bounded, closed_range, dict_t, func, guard, mono, mono_q, named_free_var, poly, proj,
bounded, closed_range, dict_t, func, guard, list_t, mono, mono_q, named_free_var, poly, proj,
proj_call, ref_, ref_mut, refinement, set_t, subr_t, subtypeof, tp_enum, try_v_enum, tuple_t,
unknown_len_array_t, v_enum,
unknown_len_list_t, v_enum,
};
use crate::ty::free::HasLevel;
use crate::ty::typaram::{OpKind, TyParam};
@ -154,13 +154,13 @@ impl<'c> Substituter<'c> {
/// e.g.
/// ```erg
/// qt: Array(T, N), st: Array(Int, 3)
/// qt: List(T, N), st: List(Int, 3)
/// qt: T or NoneType, st: NoneType or Int (T == Int)
/// ```
/// invalid (no effect):
/// ```erg
/// qt: Iterable(T), st: Array(Int, 3)
/// qt: Array(T, N), st: Array!(Int, 3) # TODO
/// qt: Iterable(T), st: List(Int, 3)
/// qt: List(T, N), st: List!(Int, 3) # TODO
/// ```
pub(crate) fn substitute_typarams(
ctx: &'c Context,
@ -282,9 +282,9 @@ impl<'c> Substituter<'c> {
if !qt.is_undoable_linked_var() && qt.is_generalized() && qt.is_free_var() {
qt.undoable_link(&st, &self.undoable_linked);
} else if qt.is_undoable_linked_var() && qt != st {
// e.g. Array(T, N) <: Add(Array(T, M))
// Array((Int), (3)) <: Add(Array((Int), (4))): OK
// Array((Int), (3)) <: Add(Array((Str), (4))): NG
// e.g. List(T, N) <: Add(List(T, M))
// List((Int), (3)) <: Add(List((Int), (4))): OK
// List((Int), (3)) <: Add(List((Str), (4))): NG
if let Some(union) = self.ctx.unify(&qt, &st) {
qt.undoable_link(&union, &self.undoable_linked);
} else {
@ -331,7 +331,7 @@ impl<'c> Substituter<'c> {
}
// NOTE: Rarely, double overwriting occurs.
// Whether this could be a problem is under consideration.
// e.g. `T` of Array(T, N) <: Add(T, M)
// e.g. `T` of List(T, N) <: Add(T, M)
TyParam::FreeVar(ref fv) if fv.is_generalized() => {
qtp.undoable_link(&stp, &self.undoable_linked);
/*if let Err(errs) = self.sub_unify_tp(&stp, &qtp, None, &(), false) {
@ -785,23 +785,23 @@ impl Context {
}
}
pub(crate) fn eval_const_normal_array(&self, arr: &NormalArray) -> EvalResult<ValueObj> {
pub(crate) fn eval_const_normal_list(&self, lis: &NormalList) -> EvalResult<ValueObj> {
let mut elems = vec![];
for elem in arr.elems.pos_args().iter() {
for elem in lis.elems.pos_args().iter() {
let elem = self.eval_const_expr(&elem.expr)?;
elems.push(elem);
}
Ok(ValueObj::Array(ArcArray::from(elems)))
Ok(ValueObj::List(ArcArray::from(elems)))
}
fn eval_const_array(&self, arr: &Array) -> EvalResult<ValueObj> {
match arr {
Array::Normal(arr) => self.eval_const_normal_array(arr),
Array::WithLength(arr) => {
let elem = self.eval_const_expr(&arr.elem.expr)?;
match arr.len.as_ref() {
fn eval_const_list(&self, lis: &List) -> EvalResult<ValueObj> {
match lis {
List::Normal(lis) => self.eval_const_normal_list(lis),
List::WithLength(lis) => {
let elem = self.eval_const_expr(&lis.elem.expr)?;
match lis.len.as_ref() {
Expr::Accessor(Accessor::Ident(ident)) if ident.is_discarded() => {
Ok(ValueObj::UnsizedArray(Box::new(elem)))
Ok(ValueObj::UnsizedList(Box::new(elem)))
}
other => {
let len = self.eval_const_expr(other)?;
@ -820,14 +820,14 @@ impl Context {
)
})?;
let arr = vec![elem; len];
Ok(ValueObj::Array(ArcArray::from(arr)))
Ok(ValueObj::List(ArcArray::from(arr)))
}
}
}
_ => Err(EvalErrors::from(EvalError::not_const_expr(
self.cfg.input.clone(),
line!() as usize,
arr.loc(),
lis.loc(),
self.caused_by(),
))),
}
@ -836,8 +836,8 @@ impl Context {
fn eval_const_set(&self, set: &AstSet) -> EvalResult<ValueObj> {
let mut elems = vec![];
match set {
AstSet::Normal(arr) => {
for elem in arr.elems.pos_args().iter() {
AstSet::Normal(lis) => {
for elem in lis.elems.pos_args().iter() {
let elem = self.eval_const_expr(&elem.expr)?;
elems.push(elem);
}
@ -875,8 +875,8 @@ impl Context {
fn eval_const_tuple(&self, tuple: &Tuple) -> EvalResult<ValueObj> {
let mut elems = vec![];
match tuple {
Tuple::Normal(arr) => {
for elem in arr.elems.pos_args().iter() {
Tuple::Normal(lis) => {
for elem in lis.elems.pos_args().iter() {
let elem = self.eval_const_expr(&elem.expr)?;
elems.push(elem);
}
@ -1109,7 +1109,7 @@ impl Context {
Expr::BinOp(bin) => self.eval_const_bin(bin),
Expr::UnaryOp(unary) => self.eval_const_unary(unary),
Expr::Call(call) => self.eval_const_call(call),
Expr::Array(arr) => self.eval_const_array(arr),
Expr::List(lis) => self.eval_const_list(lis),
Expr::Set(set) => self.eval_const_set(set),
Expr::Dict(dict) => self.eval_const_dict(dict),
Expr::Tuple(tuple) => self.eval_const_tuple(tuple),
@ -1139,7 +1139,7 @@ impl Context {
Expr::BinOp(bin) => self.eval_const_bin(bin),
Expr::UnaryOp(unary) => self.eval_const_unary(unary),
Expr::Call(call) => self.eval_const_call(call),
Expr::Array(arr) => self.eval_const_array(arr),
Expr::List(lis) => self.eval_const_list(lis),
Expr::Set(set) => self.eval_const_set(set),
Expr::Dict(dict) => self.eval_const_dict(dict),
Expr::Tuple(tuple) => self.eval_const_tuple(tuple),
@ -1412,8 +1412,8 @@ impl Context {
(TyParam::Dict(l), TyParam::Dict(r)) if op == OpKind::Add => {
Ok(TyParam::Dict(l.concat(r)))
}
(TyParam::Array(l), TyParam::Array(r)) if op == OpKind::Add => {
Ok(TyParam::Array([l, r].concat()))
(TyParam::List(l), TyParam::List(r)) if op == OpKind::Add => {
Ok(TyParam::List([l, r].concat()))
}
(TyParam::FreeVar(fv), r) if fv.is_linked() => {
let t = fv.crack().clone();
@ -1563,16 +1563,16 @@ impl Context {
TyParam::App { name, args } => self.eval_app(name, args),
TyParam::BinOp { op, lhs, rhs } => self.eval_bin_tp(op, *lhs, *rhs),
TyParam::UnaryOp { op, val } => self.eval_unary_tp(op, *val),
TyParam::Array(tps) => {
TyParam::List(tps) => {
let mut new_tps = Vec::with_capacity(tps.len());
for tp in tps {
new_tps.push(self.eval_tp(tp)?);
}
Ok(TyParam::Array(new_tps))
Ok(TyParam::List(new_tps))
}
TyParam::UnsizedArray(elem) => {
TyParam::UnsizedList(elem) => {
let elem = self.eval_tp(*elem)?;
Ok(TyParam::UnsizedArray(Box::new(elem)))
Ok(TyParam::UnsizedList(Box::new(elem)))
}
TyParam::Tuple(tps) => {
let mut new_tps = Vec::with_capacity(tps.len());
@ -2055,17 +2055,17 @@ impl Context {
}
Ok(tuple_t(ts))
}
TyParam::Array(tps) => {
TyParam::List(tps) => {
let mut union = Type::Never;
let len = tps.len();
for tp in tps {
union = self.union(&union, &self.convert_tp_into_type(tp)?);
}
Ok(array_t(union, TyParam::value(len)))
Ok(list_t(union, TyParam::value(len)))
}
TyParam::UnsizedArray(elem) => {
TyParam::UnsizedList(elem) => {
let elem = self.convert_tp_into_type(*elem)?;
Ok(unknown_len_array_t(elem))
Ok(unknown_len_list_t(elem))
}
TyParam::Set(tps) => {
let mut union = Type::Never;
@ -2095,7 +2095,7 @@ impl Context {
let t = fv.crack().clone();
self.convert_tp_into_type(t)
}
// TyParam(Ts: Array(Type)) -> Type(Ts: Array(Type))
// TyParam(Ts: List(Type)) -> Type(Ts: List(Type))
// TyParam(?S(: Str)) -> Err(...),
// TyParam(?D(: GenericDict)) -> Ok(?D(: GenericDict)),
// FIXME: GenericDict
@ -2136,17 +2136,17 @@ impl Context {
self.convert_tp_into_value(tp)
}
TyParam::Value(v) => Ok(v),
TyParam::Array(arr) => {
TyParam::List(lis) => {
let mut new = vec![];
for elem in arr {
for elem in lis {
let elem = self.convert_tp_into_value(elem)?;
new.push(elem);
}
Ok(ValueObj::Array(new.into()))
Ok(ValueObj::List(new.into()))
}
TyParam::UnsizedArray(elem) => {
TyParam::UnsizedList(elem) => {
let elem = self.convert_tp_into_value(*elem)?;
Ok(ValueObj::UnsizedArray(Box::new(elem)))
Ok(ValueObj::UnsizedList(Box::new(elem)))
}
TyParam::Tuple(tys) => {
let mut new = vec![];
@ -2244,17 +2244,17 @@ impl Context {
}
Ok(tuple_t(new_ts))
}
ValueObj::Array(arr) => {
let len = TyParam::value(arr.len());
ValueObj::List(lis) => {
let len = TyParam::value(lis.len());
let mut union = Type::Never;
for v in arr.iter().cloned() {
for v in lis.iter().cloned() {
union = self.union(&union, &self.convert_value_into_type(v)?);
}
Ok(array_t(union, len))
Ok(list_t(union, len))
}
ValueObj::UnsizedArray(elem) => {
ValueObj::UnsizedList(elem) => {
let elem = self.convert_value_into_type(*elem)?;
Ok(unknown_len_array_t(elem))
Ok(unknown_len_list_t(elem))
}
ValueObj::Set(set) => try_v_enum(set).map_err(ValueObj::Set),
ValueObj::Dict(dic) => {
@ -2279,23 +2279,23 @@ impl Context {
pub(crate) fn convert_value_into_tp(value: ValueObj) -> Result<TyParam, TyParam> {
match value {
ValueObj::Type(t) => Ok(TyParam::t(t.into_typ())),
ValueObj::Array(arr) => {
let mut new_arr = vec![];
for v in arr.iter().cloned() {
ValueObj::List(lis) => {
let mut new_lis = vec![];
for v in lis.iter().cloned() {
let tp = match Self::convert_value_into_tp(v) {
Ok(tp) => tp,
Err(tp) => tp,
};
new_arr.push(tp);
new_lis.push(tp);
}
Ok(TyParam::Array(new_arr))
Ok(TyParam::List(new_lis))
}
ValueObj::UnsizedArray(elem) => {
ValueObj::UnsizedList(elem) => {
let tp = match Self::convert_value_into_tp(*elem) {
Ok(tp) => tp,
Err(tp) => tp,
};
Ok(TyParam::UnsizedArray(Box::new(tp)))
Ok(TyParam::UnsizedList(Box::new(tp)))
}
ValueObj::Tuple(vs) => {
let mut new_ts = vec![];
@ -2404,14 +2404,14 @@ impl Context {
}
}
pub(crate) fn convert_type_to_array(&self, ty: Type) -> Result<Vec<ValueObj>, Type> {
pub(crate) fn convert_type_to_list(&self, ty: Type) -> Result<Vec<ValueObj>, Type> {
match ty {
Type::FreeVar(fv) if fv.is_linked() => {
let t = fv.crack().clone();
self.convert_type_to_array(t)
self.convert_type_to_list(t)
}
Type::Refinement(refine) => self.convert_type_to_array(*refine.t),
Type::Poly { name, params } if &name[..] == "Array" || &name[..] == "Array!" => {
Type::Refinement(refine) => self.convert_type_to_list(*refine.t),
Type::Poly { name, params } if &name[..] == "List" || &name[..] == "List!" => {
let Ok(t) = self.convert_tp_into_type(params[0].clone()) else {
log!(err "cannot convert to type: {}", params[0]);
return Err(poly(name, params));
@ -2429,14 +2429,11 @@ impl Context {
}
}
pub(crate) fn convert_value_into_array(
&self,
val: ValueObj,
) -> Result<Vec<ValueObj>, ValueObj> {
pub(crate) fn convert_value_into_list(&self, val: ValueObj) -> Result<Vec<ValueObj>, ValueObj> {
match val {
ValueObj::Array(arr) => Ok(arr.to_vec()),
ValueObj::List(lis) => Ok(lis.to_vec()),
ValueObj::Type(t) => self
.convert_type_to_array(t.into_typ())
.convert_type_to_list(t.into_typ())
.map_err(ValueObj::builtin_type),
_ => Err(val),
}
@ -2972,13 +2969,13 @@ impl Context {
line!(),
))
}),
TyParam::Array(tps) => {
TyParam::List(tps) => {
let tp_t = if let Some(fst) = tps.first() {
self.get_tp_t(fst)?
} else {
Never
};
let t = array_t(tp_t, TyParam::value(tps.len()));
let t = list_t(tp_t, TyParam::value(tps.len()));
Ok(t)
}
TyParam::Tuple(tps) => {
@ -3113,7 +3110,7 @@ impl Context {
(TyParam::Type(l), TyParam::Type(r)) => l == r,
(TyParam::Value(l), TyParam::Value(r)) => l == r,
(TyParam::Erased(l), TyParam::Erased(r)) => l == r,
(TyParam::Array(l), TyParam::Array(r)) => l == r,
(TyParam::List(l), TyParam::List(r)) => l == r,
(TyParam::Tuple(l), TyParam::Tuple(r)) => l == r,
(TyParam::Set(l), TyParam::Set(r)) => l == r, // FIXME:
(TyParam::Dict(l), TyParam::Dict(r)) => l == r,

30
crates/erg_compiler/context/generalize.rs
View file

@ -59,7 +59,7 @@ impl Generalizer {
fv.generalize();
TyParam::FreeVar(fv)
}
TyParam::Array(tps) => TyParam::Array(
TyParam::List(tps) => TyParam::List(
tps.into_iter()
.map(|tp| self.generalize_tp(tp, uninit))
.collect(),
@ -496,12 +496,12 @@ impl<'c, 'q, 'l, L: Locational> Dereferencer<'c, 'q, 'l, L> {
val: Box::new(val),
})
}
TyParam::Array(tps) => {
TyParam::List(tps) => {
let mut new_tps = vec![];
for tp in tps {
new_tps.push(self.deref_tp(tp)?);
}
Ok(TyParam::Array(new_tps))
Ok(TyParam::List(new_tps))
}
TyParam::Tuple(tps) => {
let mut new_tps = vec![];
@ -1374,24 +1374,24 @@ impl Context {
}
Ok(())
}
hir::Expr::Array(array) => match array {
hir::Array::Normal(arr) => {
for elem in arr.elems.pos_args.iter_mut() {
hir::Expr::List(list) => match list {
hir::List::Normal(lis) => {
for elem in lis.elems.pos_args.iter_mut() {
self.resolve_expr_t(&mut elem.expr, qnames)?;
}
let t = mem::take(&mut arr.t);
let mut dereferencer = Dereferencer::simple(self, qnames, arr);
arr.t = dereferencer.deref_tyvar(t)?;
let t = mem::take(&mut lis.t);
let mut dereferencer = Dereferencer::simple(self, qnames, lis);
lis.t = dereferencer.deref_tyvar(t)?;
Ok(())
}
hir::Array::WithLength(arr) => {
self.resolve_expr_t(&mut arr.elem, qnames)?;
if let Some(len) = &mut arr.len {
hir::List::WithLength(lis) => {
self.resolve_expr_t(&mut lis.elem, qnames)?;
if let Some(len) = &mut lis.len {
self.resolve_expr_t(len, qnames)?;
}
let t = mem::take(&mut arr.t);
let mut dereferencer = Dereferencer::simple(self, qnames, arr);
arr.t = dereferencer.deref_tyvar(t)?;
let t = mem::take(&mut lis.t);
let mut dereferencer = Dereferencer::simple(self, qnames, lis);
lis.t = dereferencer.deref_tyvar(t)?;
Ok(())
}
other => feature_error!(

6
crates/erg_compiler/context/hint.rs
View file

@ -44,7 +44,7 @@ impl Context {
expected: &Type,
found: &Type,
) -> Option<String> {
if &callee_t.qual_name()[..] == "Array" && attr == Some("__getitem__") && nth == 1 {
if &callee_t.qual_name()[..] == "List" && attr == Some("__getitem__") && nth == 1 {
let len = &callee_t.typarams().get(1).cloned()?;
let (_, _, pred) = found.clone().deconstruct_refinement().ok()?;
if let Predicate::Equal { rhs: accessed, .. } = pred {
@ -58,10 +58,10 @@ impl Context {
accessed.clone()
};
return Some(switch_lang! {
"japanese" => format!("配列の長さは{len}ですが、{accessed}番目の要素にアクセスしようとしています"),
"japanese" => format!("リストの長さは{len}ですが、{accessed}番目の要素にアクセスしようとしています"),
"simplified_chinese" => format!("数组长度为{len}但尝试访问第{accessed}个元素"),
"traditional_chinese" => format!("陣列長度為{len}但嘗試訪問第{accessed}個元素"),
"english" => format!("Array length is {len} but tried to access the {accessed}th element"),
"english" => format!("List length is {len} but tried to access the {accessed}th element"),
});
}
}

489
crates/erg_compiler/context/initialize/classes.rs
View file

@ -489,7 +489,7 @@ impl Context {
BYTES,
or(
mono(BYTES),
array_t(Type::from(value(0)..=value(255)), TyParam::erased(Nat)),
list_t(Type::from(value(0)..=value(255)), TyParam::erased(Nat)),
),
)],
vec![kw(
@ -954,7 +954,7 @@ impl Context {
None,
vec![kw(KW_MAXSPLIT, Nat)],
None,
unknown_len_array_t(Str),
unknown_len_list_t(Str),
),
Immutable,
Visibility::BUILTIN_PUBLIC,
@ -968,7 +968,7 @@ impl Context {
None,
vec![kw(KW_KEEPENDS, Bool)],
None,
unknown_len_array_t(Str),
unknown_len_list_t(Str),
),
Immutable,
Visibility::BUILTIN_PUBLIC,
@ -1356,14 +1356,14 @@ impl Context {
type_.register_superclass(Obj, &obj);
type_.register_builtin_erg_impl(
FUNC_MRO,
fn0_met(Type, array_t(Type, TyParam::erased(Nat))),
fn0_met(Type, list_t(Type, TyParam::erased(Nat))),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
// TODO: PolyType
type_.register_builtin_erg_impl(
FUNDAMENTAL_ARGS,
array_t(Type, TyParam::erased(Nat)),
list_t(Type, TyParam::erased(Nat)),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
@ -1424,31 +1424,31 @@ impl Context {
);
code.register_builtin_erg_impl(
FUNC_CO_VARNAMES,
array_t(Str, TyParam::erased(Nat)),
list_t(Str, TyParam::erased(Nat)),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
code.register_builtin_erg_impl(
FUNC_CO_CONSTS,
array_t(Obj, TyParam::erased(Nat)),
list_t(Obj, TyParam::erased(Nat)),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
code.register_builtin_erg_impl(
FUNC_CO_NAMES,
array_t(Str, TyParam::erased(Nat)),
list_t(Str, TyParam::erased(Nat)),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
code.register_builtin_erg_impl(
FUNC_CO_FREEVARS,
array_t(Str, TyParam::erased(Nat)),
list_t(Str, TyParam::erased(Nat)),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
code.register_builtin_erg_impl(
FUNC_CO_CELLVARS,
array_t(Str, TyParam::erased(Nat)),
list_t(Str, TyParam::erased(Nat)),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
@ -1566,100 +1566,100 @@ impl Context {
if ERG_MODE {
py_module.register_superclass(g_module_t.clone(), &generic_module);
}
/* GenericArray */
let mut generic_array = Self::builtin_mono_class(GENERIC_ARRAY, 1);
generic_array.register_superclass(Obj, &obj);
/* GenericList */
let mut generic_list = Self::builtin_mono_class(GENERIC_LIST, 1);
generic_list.register_superclass(Obj, &obj);
let mut arr_eq = Self::builtin_methods(Some(mono(EQ)), 2);
arr_eq.register_builtin_erg_impl(
OP_EQ,
fn1_met(mono(GENERIC_ARRAY), mono(GENERIC_ARRAY), Bool),
fn1_met(mono(GENERIC_LIST), mono(GENERIC_LIST), Bool),
Const,
Visibility::BUILTIN_PUBLIC,
);
generic_array.register_trait_methods(mono(GENERIC_ARRAY), arr_eq);
generic_list.register_trait_methods(mono(GENERIC_LIST), arr_eq);
let t_call = func1(
poly(ITERABLE, vec![ty_tp(T.clone())]),
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
)
.quantify();
generic_array.register_builtin_erg_impl(
generic_list.register_builtin_erg_impl(
FUNDAMENTAL_CALL,
t_call,
Immutable,
Visibility::BUILTIN_PUBLIC,
);
let mut array_hash = Self::builtin_methods(Some(mono(HASH)), 1);
array_hash.register_builtin_erg_impl(
let mut list_hash = Self::builtin_methods(Some(mono(HASH)), 1);
list_hash.register_builtin_erg_impl(
OP_HASH,
fn0_met(mono(GENERIC_ARRAY), Int),
fn0_met(mono(GENERIC_LIST), Int),
Const,
Visibility::BUILTIN_PUBLIC,
);
generic_array.register_trait_methods(mono(GENERIC_ARRAY), array_hash);
let unsized_array_t = poly(UNSIZED_ARRAY, vec![ty_tp(T.clone())]);
let mut unsized_array =
Self::builtin_poly_class(UNSIZED_ARRAY, vec![ParamSpec::t_nd(TY_T)], 1);
unsized_array.register_superclass(Obj, &obj);
unsized_array.register_builtin_decl(KW_ELEM, T.clone(), vis.clone(), Some(KW_ELEM));
/* Array */
let mut array_ =
Self::builtin_poly_class(ARRAY, vec![PS::t_nd(TY_T), PS::default(TY_N, Nat)], 10);
array_.register_superclass(mono(GENERIC_ARRAY), &generic_array);
array_
generic_list.register_trait_methods(mono(GENERIC_LIST), list_hash);
let unsized_list_t = poly(UNSIZED_LIST, vec![ty_tp(T.clone())]);
let mut unsized_list =
Self::builtin_poly_class(UNSIZED_LIST, vec![ParamSpec::t_nd(TY_T)], 1);
unsized_list.register_superclass(Obj, &obj);
unsized_list.register_builtin_decl(KW_ELEM, T.clone(), vis.clone(), Some(KW_ELEM));
/* List */
let mut list_ =
Self::builtin_poly_class(LIST, vec![PS::t_nd(TY_T), PS::default(TY_N, Nat)], 10);
list_.register_superclass(mono(GENERIC_LIST), &generic_list);
list_
.register_trait(self, poly(OUTPUT, vec![ty_tp(T.clone())]))
.unwrap();
let arr_t = array_t(T.clone(), N.clone());
let lis_t = list_t(T.clone(), N.clone());
let t = no_var_fn_met(
arr_t.clone(),
vec![kw(KW_RHS, array_t(T.clone(), M.clone()))],
lis_t.clone(),
vec![kw(KW_RHS, list_t(T.clone(), M.clone()))],
vec![],
array_t(T.clone(), N.clone() + M.clone()),
list_t(T.clone(), N.clone() + M.clone()),
)
.quantify();
array_.register_py_builtin(FUNC_CONCAT, t.clone(), Some(OP_ADD), 9);
list_.register_py_builtin(FUNC_CONCAT, t.clone(), Some(OP_ADD), 9);
let t_count =
no_var_fn_met(arr_t.clone(), vec![kw(KW_X, T.clone())], vec![], Nat).quantify();
array_.register_py_builtin(FUNC_COUNT, t_count, Some(FUNC_COUNT), 17);
no_var_fn_met(lis_t.clone(), vec![kw(KW_X, T.clone())], vec![], Nat).quantify();
list_.register_py_builtin(FUNC_COUNT, t_count, Some(FUNC_COUNT), 17);
let t_get = no_var_fn_met(
arr_t.clone(),
lis_t.clone(),
vec![pos(Nat)],
vec![ParamTy::kw_default(KW_DEFAULT.into(), U.clone(), NoneType)],
or(T.clone(), U.clone()),
)
.quantify();
array_.register_builtin_erg_impl(FUNC_GET, t_get, Immutable, Visibility::BUILTIN_PUBLIC);
// Array(T, N)|<: Add(Array(T, M))|.
// Output = Array(T, N + M)
// __add__: (self: Array(T, N), other: Array(T, M)) -> Array(T, N + M) = Array.concat
let mut array_add = Self::builtin_methods(
Some(poly(ADD, vec![ty_tp(array_t(T.clone(), M.clone()))])),
list_.register_builtin_erg_impl(FUNC_GET, t_get, Immutable, Visibility::BUILTIN_PUBLIC);
// List(T, N)|<: Add(List(T, M))|.
// Output = List(T, N + M)
// __add__: (self: List(T, N), other: List(T, M)) -> List(T, N + M) = List.concat
let mut list_add = Self::builtin_methods(
Some(poly(ADD, vec![ty_tp(list_t(T.clone(), M.clone()))])),
2,
);
array_add.register_builtin_erg_impl(OP_ADD, t, Immutable, Visibility::BUILTIN_PUBLIC);
let out_t = array_t(T.clone(), N.clone() + M.clone());
array_add.register_builtin_const(
list_add.register_builtin_erg_impl(OP_ADD, t, Immutable, Visibility::BUILTIN_PUBLIC);
let out_t = list_t(T.clone(), N.clone() + M.clone());
list_add.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(out_t),
);
array_.register_trait_methods(arr_t.clone(), array_add);
list_.register_trait_methods(lis_t.clone(), list_add);
let t = no_var_fn_met(
arr_t.clone(),
lis_t.clone(),
vec![kw(KW_ELEM, T.clone())],
vec![],
array_t(T.clone(), N.clone() + value(1usize)),
list_t(T.clone(), N.clone() + value(1usize)),
)
.quantify();
array_.register_builtin_erg_impl(FUNC_PUSH, t, Immutable, Visibility::BUILTIN_PUBLIC);
list_.register_builtin_erg_impl(FUNC_PUSH, t, Immutable, Visibility::BUILTIN_PUBLIC);
let repeat_t = no_var_fn_met(
arr_t.clone(),
lis_t.clone(),
vec![pos(singleton(Nat, M.clone()))],
vec![],
array_t(T.clone(), N.clone() * M.clone()),
list_t(T.clone(), N.clone() * M.clone()),
)
.quantify();
array_.register_builtin_erg_impl(
list_.register_builtin_erg_impl(
FUNC_REPEAT,
repeat_t,
Immutable,
@ -1667,15 +1667,15 @@ impl Context {
);
// [T; N].MutType! = [T; !N] (neither [T!; N] nor [T; N]!)
let mut_type =
ValueObj::builtin_class(poly(MUT_ARRAY, vec![TyParam::t(T.clone()), N.clone()]));
let mut array_mutizable = Self::builtin_methods(Some(mono(MUTIZABLE)), 2);
array_mutizable.register_builtin_const(
ValueObj::builtin_class(poly(MUT_LIST, vec![TyParam::t(T.clone()), N.clone()]));
let mut list_mutizable = Self::builtin_methods(Some(mono(MUTIZABLE)), 2);
list_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
mut_type,
);
array_.register_trait_methods(arr_t.clone(), array_mutizable);
list_.register_trait_methods(lis_t.clone(), list_mutizable);
let var = FRESH_GEN.fresh_varname();
let input = refinement(
var.clone(),
@ -1684,259 +1684,254 @@ impl Context {
);
// __getitem__: |T, N|(self: [T; N], _: {I: Nat | I <= N}) -> T
// and (self: [T; N], _: Range(Int)) -> [T; _]
let array_getitem_t = (fn1_kw_met(
array_t(T.clone(), N.clone()),
anon(input.clone()),
T.clone(),
) & fn1_kw_met(
array_t(T.clone(), N.clone()),
anon(poly(RANGE, vec![ty_tp(Int)])),
unknown_len_array_t(T.clone()),
))
.quantify();
let list_getitem_t =
(fn1_kw_met(list_t(T.clone(), N.clone()), anon(input.clone()), T.clone())
& fn1_kw_met(
list_t(T.clone(), N.clone()),
anon(poly(RANGE, vec![ty_tp(Int)])),
unknown_len_list_t(T.clone()),
))
.quantify();
let get_item = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNDAMENTAL_GETITEM,
__array_getitem__,
array_getitem_t,
__list_getitem__,
list_getitem_t,
None,
)));
array_.register_builtin_const(
list_.register_builtin_const(
FUNDAMENTAL_GETITEM,
Visibility::BUILTIN_PUBLIC,
None,
get_item,
);
let array_insert_t = no_var_fn_met(
array_t(T.clone(), N.clone()),
let list_insert_t = no_var_fn_met(
list_t(T.clone(), N.clone()),
vec![pos(Nat), kw(KW_ELEM, T.clone())],
vec![],
array_t(T.clone(), N.clone() + value(1usize)),
list_t(T.clone(), N.clone() + value(1usize)),
)
.quantify();
let array_insert = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
let list_insert = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_INSERT,
array_insert_at,
array_insert_t.clone(),
list_insert_at,
list_insert_t.clone(),
None,
)));
array_._register_builtin_const(
list_._register_builtin_const(
FUNC_INSERT,
Visibility::BUILTIN_PUBLIC,
Some(array_insert_t),
array_insert,
Some(list_insert_t),
list_insert,
Some(FUNC_INSERT_AT.into()),
);
let array_remove_at_t = no_var_fn_met(
array_t(T.clone(), N.clone()),
let list_remove_at_t = no_var_fn_met(
list_t(T.clone(), N.clone()),
vec![pos(Nat)],
vec![],
array_t(T.clone(), N.clone() - value(1usize)),
list_t(T.clone(), N.clone() - value(1usize)),
)
.quantify();
let array_remove_at = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
let list_remove_at = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_REMOVE_AT,
array_remove_at,
array_remove_at_t.clone(),
list_remove_at,
list_remove_at_t.clone(),
None,
)));
array_.register_builtin_const(
list_.register_builtin_const(
FUNC_REMOVE_AT,
Visibility::BUILTIN_PUBLIC,
Some(array_remove_at_t),
array_remove_at,
Some(list_remove_at_t),
list_remove_at,
);
let array_remove_all_t = no_var_fn_met(
array_t(T.clone(), N.clone()),
let list_remove_all_t = no_var_fn_met(
list_t(T.clone(), N.clone()),
vec![kw(KW_ELEM, T.clone())],
vec![],
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
)
.quantify();
let array_remove_all = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
let list_remove_all = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_REMOVE_ALL,
array_remove_all,
array_remove_all_t.clone(),
list_remove_all,
list_remove_all_t.clone(),
None,
)));
array_.register_builtin_const(
list_.register_builtin_const(
FUNC_REMOVE_ALL,
Visibility::BUILTIN_PUBLIC,
Some(array_remove_all_t),
array_remove_all,
Some(list_remove_all_t),
list_remove_all,
);
array_
list_
.register_trait(self, poly(INDEXABLE, vec![ty_tp(input), ty_tp(T.clone())]))
.unwrap();
array_
list_
.register_trait(
self,
poly(
HAS_SHAPE,
vec![ty_tp(arr_t.clone()).proj_call(FUNC_SHAPE.into(), vec![])],
vec![ty_tp(lis_t.clone()).proj_call(FUNC_SHAPE.into(), vec![])],
),
)
.unwrap();
array_
list_
.register_trait(
self,
poly(
HAS_SCALAR_TYPE,
vec![ty_tp(arr_t.clone()).proj_call(FUNC_SCALAR_TYPE.into(), vec![])],
vec![ty_tp(lis_t.clone()).proj_call(FUNC_SCALAR_TYPE.into(), vec![])],
),
)
.unwrap();
let mut array_sized = Self::builtin_methods(Some(mono(SIZED)), 2);
array_sized.register_builtin_erg_impl(
let mut list_sized = Self::builtin_methods(Some(mono(SIZED)), 2);
list_sized.register_builtin_erg_impl(
FUNDAMENTAL_LEN,
fn0_met(arr_t.clone(), Nat).quantify(),
fn0_met(lis_t.clone(), Nat).quantify(),
Const,
Visibility::BUILTIN_PUBLIC,
);
array_.register_trait_methods(arr_t.clone(), array_sized);
list_.register_trait_methods(lis_t.clone(), list_sized);
// union: (self: [Type; _]) -> Type
let array_union_t = fn0_met(array_t(Type, TyParam::erased(Nat)), Type).quantify();
let list_union_t = fn0_met(list_t(Type, TyParam::erased(Nat)), Type).quantify();
let union = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_UNION,
array_union,
array_union_t,
list_union,
list_union_t,
None,
)));
array_.register_builtin_const(FUNC_UNION, Visibility::BUILTIN_PUBLIC, None, union);
list_.register_builtin_const(FUNC_UNION, Visibility::BUILTIN_PUBLIC, None, union);
// shape: (self: [Type; _]) -> [Nat; _]
let array_shape_t = fn0_met(
array_t(Type, TyParam::erased(Nat)),
unknown_len_array_t(Nat),
)
.quantify();
let list_shape_t =
fn0_met(list_t(Type, TyParam::erased(Nat)), unknown_len_list_t(Nat)).quantify();
let shape = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_SHAPE,
array_shape,
array_shape_t,
list_shape,
list_shape_t,
None,
)));
array_.register_builtin_const(FUNC_SHAPE, Visibility::BUILTIN_PUBLIC, None, shape);
let array_scalar_type_t = fn0_met(Type, Type).quantify();
let array_scalar_type = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
list_.register_builtin_const(FUNC_SHAPE, Visibility::BUILTIN_PUBLIC, None, shape);
let list_scalar_type_t = fn0_met(Type, Type).quantify();
let list_scalar_type = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_SCALAR_TYPE,
array_scalar_type,
array_scalar_type_t,
list_scalar_type,
list_scalar_type_t,
None,
)));
array_.register_builtin_const(
list_.register_builtin_const(
FUNC_SCALAR_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
array_scalar_type,
list_scalar_type,
);
let mut array_eq = Self::builtin_methods(Some(mono(EQ)), 2);
array_eq.register_builtin_erg_impl(
let mut list_eq = Self::builtin_methods(Some(mono(EQ)), 2);
list_eq.register_builtin_erg_impl(
OP_EQ,
fn1_met(arr_t.clone(), arr_t.clone(), Bool).quantify(),
fn1_met(lis_t.clone(), lis_t.clone(), Bool).quantify(),
Const,
Visibility::BUILTIN_PUBLIC,
);
array_.register_trait_methods(arr_t.clone(), array_eq);
array_
list_.register_trait_methods(lis_t.clone(), list_eq);
list_
.register_trait(self, poly(SEQUENCE, vec![ty_tp(T.clone())]))
.unwrap();
array_.unregister_trait(&poly(INDEXABLE, vec![ty_tp(Nat), ty_tp(T.clone())]));
let mut array_show = Self::builtin_methods(Some(mono(SHOW)), 1);
array_show.register_builtin_py_impl(
list_.unregister_trait(&poly(INDEXABLE, vec![ty_tp(Nat), ty_tp(T.clone())]));
let mut list_show = Self::builtin_methods(Some(mono(SHOW)), 1);
list_show.register_builtin_py_impl(
FUNDAMENTAL_STR,
fn0_met(arr_t.clone(), Str).quantify(),
fn0_met(lis_t.clone(), Str).quantify(),
Immutable,
Visibility::BUILTIN_PUBLIC,
Some(FUNDAMENTAL_STR),
);
array_.register_trait_methods(arr_t.clone(), array_show);
let mut array_iterable =
list_.register_trait_methods(lis_t.clone(), list_show);
let mut list_iterable =
Self::builtin_methods(Some(poly(ITERABLE, vec![ty_tp(T.clone())])), 2);
let array_iter = poly(ARRAY_ITERATOR, vec![ty_tp(T.clone())]);
let t = fn0_met(array_t(T.clone(), TyParam::erased(Nat)), array_iter.clone()).quantify();
array_iterable.register_builtin_py_impl(
let list_iter = poly(LIST_ITERATOR, vec![ty_tp(T.clone())]);
let t = fn0_met(list_t(T.clone(), TyParam::erased(Nat)), list_iter.clone()).quantify();
list_iterable.register_builtin_py_impl(
FUNC_ITER,
t,
Immutable,
Visibility::BUILTIN_PUBLIC,
Some(FUNDAMENTAL_ITER),
);
array_iterable.register_builtin_const(
list_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(array_iter),
ValueObj::builtin_class(list_iter),
);
array_.register_trait_methods(arr_t.clone(), array_iterable);
let mut array_collection =
list_.register_trait_methods(lis_t.clone(), list_iterable);
let mut list_collection =
Self::builtin_methods(Some(poly(COLLECTION, vec![ty_tp(T.clone())])), 4);
array_collection.register_builtin_erg_impl(
list_collection.register_builtin_erg_impl(
FUNDAMENTAL_CONTAINS,
fn1_met(arr_t.clone(), T.clone(), Bool).quantify(),
fn1_met(lis_t.clone(), T.clone(), Bool).quantify(),
Const,
Visibility::BUILTIN_PUBLIC,
);
array_.register_trait_methods(arr_t.clone(), array_collection);
array_
list_.register_trait_methods(lis_t.clone(), list_collection);
list_
.register_trait(self, poly(COLLECTION, vec![ty_tp(T.clone())]))
.unwrap();
let t = fn1_met(
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
func1(T.clone(), Bool),
tuple_t(vec![
array_t(T.clone(), TyParam::erased(Nat)),
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
]),
);
array_.register_py_builtin(FUNC_PARTITION, t.quantify(), Some(FUNC_PARTITION), 37);
list_.register_py_builtin(FUNC_PARTITION, t.quantify(), Some(FUNC_PARTITION), 37);
let t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
vec![],
vec![kw(
KW_SAME_BUCKET,
or(func2(T.clone(), T.clone(), Bool), NoneType),
)],
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
);
array_.register_py_builtin(FUNC_DEDUP, t.quantify(), Some(FUNC_DEDUP), 28);
list_.register_py_builtin(FUNC_DEDUP, t.quantify(), Some(FUNC_DEDUP), 28);
let sum_t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
vec![],
vec![kw(KW_START, T.clone())],
T.clone(),
);
let sum = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_SUM,
array_sum,
list_sum,
sum_t.quantify(),
None,
)));
array_.register_builtin_const(FUNC_SUM, Visibility::BUILTIN_PUBLIC, None, sum);
list_.register_builtin_const(FUNC_SUM, Visibility::BUILTIN_PUBLIC, None, sum);
let prod_t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
vec![],
vec![kw(KW_START, T.clone())],
T.clone(),
);
let prod = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_PROD,
array_prod,
list_prod,
prod_t.quantify(),
None,
)));
array_.register_builtin_const(FUNC_PROD, Visibility::BUILTIN_PUBLIC, None, prod);
list_.register_builtin_const(FUNC_PROD, Visibility::BUILTIN_PUBLIC, None, prod);
let reversed_t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
vec![],
vec![],
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
);
let reversed = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_REVERSED,
array_reversed,
list_reversed,
reversed_t.quantify(),
None,
)));
array_.register_builtin_const(FUNC_REVERSED, Visibility::BUILTIN_PUBLIC, None, reversed);
list_.register_builtin_const(FUNC_REVERSED, Visibility::BUILTIN_PUBLIC, None, reversed);
/* Slice */
let mut slice = Self::builtin_mono_class(SLICE, 3);
slice.register_superclass(Obj, &obj);
@ -2284,7 +2279,7 @@ impl Context {
/* GenericTuple */
let mut generic_tuple = Self::builtin_mono_class(GENERIC_TUPLE, 1);
generic_tuple.register_superclass(Obj, &obj);
// tuple doesn't have a constructor, use `Array` instead
// tuple doesn't have a constructor, use `List` instead
let mut tuple_eq = Self::builtin_methods(Some(mono(EQ)), 2);
tuple_eq.register_builtin_erg_impl(
OP_EQ,
@ -2302,14 +2297,11 @@ impl Context {
);
generic_tuple.register_trait_methods(mono(GENERIC_TUPLE), tuple_hash);
generic_tuple.register_trait(self, mono(EQ_HASH)).unwrap();
let Ts = mono_q_tp(TY_TS, instanceof(array_t(Type, N.clone())));
// Ts <: GenericArray
let Ts = mono_q_tp(TY_TS, instanceof(list_t(Type, N.clone())));
// Ts <: GenericList
let _tuple_t = poly(TUPLE, vec![Ts.clone()]);
let mut tuple_ = Self::builtin_poly_class(
TUPLE,
vec![PS::named_nd(TY_TS, array_t(Type, N.clone()))],
2,
);
let mut tuple_ =
Self::builtin_poly_class(TUPLE, vec![PS::named_nd(TY_TS, list_t(Type, N.clone()))], 2);
tuple_.register_superclass(mono(GENERIC_TUPLE), &generic_tuple);
tuple_
.register_trait(self, poly(OUTPUT, vec![Ts.clone()]))
@ -2498,12 +2490,12 @@ impl Context {
str_iterator
.register_trait(self, poly(OUTPUT, vec![ty_tp(Str)]))
.unwrap();
let mut array_iterator = Self::builtin_poly_class(ARRAY_ITERATOR, vec![PS::t_nd(TY_T)], 1);
array_iterator.register_superclass(Obj, &obj);
array_iterator
let mut list_iterator = Self::builtin_poly_class(LIST_ITERATOR, vec![PS::t_nd(TY_T)], 1);
list_iterator.register_superclass(Obj, &obj);
list_iterator
.register_trait(self, poly(ITERABLE, vec![ty_tp(T.clone())]))
.unwrap();
array_iterator
list_iterator
.register_trait(self, poly(OUTPUT, vec![ty_tp(T.clone())]))
.unwrap();
let mut set_iterator = Self::builtin_poly_class(SET_ITERATOR, vec![PS::t_nd(TY_T)], 1);
@ -3004,16 +2996,16 @@ impl Context {
file_mut
.register_trait(self, mono(CONTEXT_MANAGER))
.unwrap();
/* Array! */
let array_mut_t = poly(MUT_ARRAY, vec![ty_tp(T.clone()), N.clone()]);
let mut array_mut_ =
Self::builtin_poly_class(MUT_ARRAY, vec![PS::t_nd(TY_T), PS::default(TY_N, Nat)], 2);
array_mut_.register_superclass(arr_t.clone(), &array_);
/* List! */
let list_mut_t = poly(MUT_LIST, vec![ty_tp(T.clone()), N.clone()]);
let mut list_mut_ =
Self::builtin_poly_class(MUT_LIST, vec![PS::t_nd(TY_T), PS::default(TY_N, Nat)], 2);
list_mut_.register_superclass(lis_t.clone(), &list_);
let t = pr_met(
ref_mut(
array_mut_t.clone(),
list_mut_t.clone(),
Some(poly(
MUT_ARRAY,
MUT_LIST,
vec![ty_tp(T.clone()), N.clone() + value(1usize)],
)),
),
@ -3023,18 +3015,15 @@ impl Context {
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_PUSH, t, Some(FUNC_APPEND), 15);
let t_copy = fn0_met(ref_(array_mut_t.clone()), array_mut_t.clone()).quantify();
let mut array_mut_copy = Self::builtin_methods(Some(mono(COPY)), 2);
array_mut_copy.register_py_builtin(FUNC_COPY, t_copy, Some(FUNC_COPY), 116);
array_mut_.register_trait_methods(array_mut_t.clone(), array_mut_copy);
list_mut_.register_py_builtin(PROC_PUSH, t, Some(FUNC_APPEND), 15);
let t_copy = fn0_met(ref_(list_mut_t.clone()), list_mut_t.clone()).quantify();
let mut list_mut_copy = Self::builtin_methods(Some(mono(COPY)), 2);
list_mut_copy.register_py_builtin(FUNC_COPY, t_copy, Some(FUNC_COPY), 116);
list_mut_.register_trait_methods(list_mut_t.clone(), list_mut_copy);
let t_extend = pr_met(
ref_mut(
array_mut_t.clone(),
Some(poly(
MUT_ARRAY,
vec![ty_tp(T.clone()), TyParam::erased(Nat)],
)),
list_mut_t.clone(),
Some(poly(MUT_LIST, vec![ty_tp(T.clone()), TyParam::erased(Nat)])),
),
vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
None,
@ -3042,12 +3031,12 @@ impl Context {
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_EXTEND, t_extend, Some(FUNC_EXTEND), 24);
list_mut_.register_py_builtin(PROC_EXTEND, t_extend, Some(FUNC_EXTEND), 24);
let t_insert = pr_met(
ref_mut(
array_mut_t.clone(),
list_mut_t.clone(),
Some(poly(
MUT_ARRAY,
MUT_LIST,
vec![ty_tp(T.clone()), N.clone() + value(1usize)],
)),
),
@ -3057,12 +3046,12 @@ impl Context {
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_INSERT, t_insert, Some(FUNC_INSERT), 33);
list_mut_.register_py_builtin(PROC_INSERT, t_insert, Some(FUNC_INSERT), 33);
let t_remove = pr_met(
ref_mut(
array_mut_t.clone(),
list_mut_t.clone(),
Some(poly(
MUT_ARRAY,
MUT_LIST,
vec![ty_tp(T.clone()), N.clone() - value(1usize)],
)),
),
@ -3072,12 +3061,12 @@ impl Context {
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_REMOVE, t_remove, Some(FUNC_REMOVE), 42);
list_mut_.register_py_builtin(PROC_REMOVE, t_remove, Some(FUNC_REMOVE), 42);
let t_pop = pr_met(
ref_mut(
array_mut_t.clone(),
list_mut_t.clone(),
Some(poly(
MUT_ARRAY,
MUT_LIST,
vec![ty_tp(T.clone()), N.clone() - value(1usize)],
)),
),
@ -3087,18 +3076,18 @@ impl Context {
T.clone(),
)
.quantify();
array_mut_.register_py_builtin(PROC_POP, t_pop, Some(FUNC_POP), 52);
list_mut_.register_py_builtin(PROC_POP, t_pop, Some(FUNC_POP), 52);
let t_clear = pr0_met(
ref_mut(
array_mut_t.clone(),
Some(poly(MUT_ARRAY, vec![ty_tp(T.clone()), value(0usize)])),
list_mut_t.clone(),
Some(poly(MUT_LIST, vec![ty_tp(T.clone()), value(0usize)])),
),
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_CLEAR, t_clear, Some(FUNC_CLEAR), 61);
list_mut_.register_py_builtin(PROC_CLEAR, t_clear, Some(FUNC_CLEAR), 61);
let t_sort = pr_met(
ref_mut(array_mut_t.clone(), None),
ref_mut(list_mut_t.clone(), None),
vec![],
None,
vec![kw(
@ -3108,77 +3097,77 @@ impl Context {
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_SORT, t_sort, Some(FUNC_SORT), 78);
let t_reverse = pr0_met(ref_mut(array_mut_t.clone(), None), NoneType).quantify();
array_mut_.register_py_builtin(PROC_REVERSE, t_reverse, Some(FUNC_REVERSE), 87);
list_mut_.register_py_builtin(PROC_SORT, t_sort, Some(FUNC_SORT), 78);
let t_reverse = pr0_met(ref_mut(list_mut_t.clone(), None), NoneType).quantify();
list_mut_.register_py_builtin(PROC_REVERSE, t_reverse, Some(FUNC_REVERSE), 87);
let t = pr_met(
array_mut_t.clone(),
list_mut_t.clone(),
vec![kw(KW_FUNC, nd_func(vec![anon(T.clone())], None, T.clone()))],
None,
vec![],
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_STRICT_MAP, t, None, 96);
list_mut_.register_py_builtin(PROC_STRICT_MAP, t, None, 96);
let t_update_nth = pr_met(
ref_mut(array_mut_t.clone(), None),
ref_mut(list_mut_t.clone(), None),
vec![kw(KW_IDX, Nat), kw(KW_FUNC, func1(T.clone(), T.clone()))],
None,
vec![],
NoneType,
)
.quantify();
array_mut_.register_py_builtin(PROC_UPDATE_NTH, t_update_nth, Some(FUNC_UPDATE_NTH), 105);
list_mut_.register_py_builtin(PROC_UPDATE_NTH, t_update_nth, Some(FUNC_UPDATE_NTH), 105);
let f_t = kw(
KW_FUNC,
no_var_func(vec![kw(KW_OLD, arr_t.clone())], vec![], arr_t.clone()),
no_var_func(vec![kw(KW_OLD, lis_t.clone())], vec![], lis_t.clone()),
);
let t = pr_met(
ref_mut(array_mut_t.clone(), None),
ref_mut(list_mut_t.clone(), None),
vec![f_t],
None,
vec![],
NoneType,
)
.quantify();
let mut array_mut_mutable = Self::builtin_methods(Some(mono(MUTABLE)), 2);
array_mut_mutable.register_builtin_py_impl(
let mut list_mut_mutable = Self::builtin_methods(Some(mono(MUTABLE)), 2);
list_mut_mutable.register_builtin_py_impl(
PROC_UPDATE,
t,
Immutable,
Visibility::BUILTIN_PUBLIC,
Some(FUNC_UPDATE),
);
array_mut_.register_trait_methods(array_mut_t.clone(), array_mut_mutable);
list_mut_.register_trait_methods(list_mut_t.clone(), list_mut_mutable);
/* ByteArray! */
let bytearray_mut_t = mono(BYTEARRAY);
let mut bytearray_mut = Self::builtin_mono_class(BYTEARRAY, 2);
let bytelist_mut_t = mono(BYTEARRAY);
let mut bytelist_mut = Self::builtin_mono_class(BYTEARRAY, 2);
let t_append = pr_met(
ref_mut(bytearray_mut_t.clone(), None),
ref_mut(bytelist_mut_t.clone(), None),
vec![kw(KW_ELEM, int_interval(IntervalOp::Closed, 0, 255))],
None,
vec![],
NoneType,
);
bytearray_mut.register_builtin_py_impl(
bytelist_mut.register_builtin_py_impl(
PROC_PUSH,
t_append,
Immutable,
Visibility::BUILTIN_PUBLIC,
Some(FUNC_APPEND),
);
let t_copy = fn0_met(ref_(bytearray_mut_t.clone()), bytearray_mut_t.clone());
let mut bytearray_mut_copy = Self::builtin_methods(Some(mono(COPY)), 2);
bytearray_mut_copy.register_builtin_py_impl(
let t_copy = fn0_met(ref_(bytelist_mut_t.clone()), bytelist_mut_t.clone());
let mut bytelist_mut_copy = Self::builtin_methods(Some(mono(COPY)), 2);
bytelist_mut_copy.register_builtin_py_impl(
FUNC_COPY,
t_copy,
Immutable,
Visibility::BUILTIN_PUBLIC,
Some(FUNC_COPY),
);
bytearray_mut.register_trait_methods(bytearray_mut_t.clone(), bytearray_mut_copy);
bytelist_mut.register_trait_methods(bytelist_mut_t.clone(), bytelist_mut_copy);
let t_extend = pr_met(
ref_mut(bytearray_mut_t.clone(), None),
ref_mut(bytelist_mut_t.clone(), None),
vec![kw(
KW_ITERABLE,
poly(
@ -3190,7 +3179,7 @@ impl Context {
vec![],
NoneType,
);
bytearray_mut.register_builtin_py_impl(
bytelist_mut.register_builtin_py_impl(
PROC_EXTEND,
t_extend,
Immutable,
@ -3198,7 +3187,7 @@ impl Context {
Some(FUNC_EXTEND),
);
let t_insert = pr_met(
ref_mut(bytearray_mut_t.clone(), None),
ref_mut(bytelist_mut_t.clone(), None),
vec![
kw(KW_INDEX, Nat),
kw(KW_ELEM, int_interval(IntervalOp::Closed, 0, 255)),
@ -3207,7 +3196,7 @@ impl Context {
vec![],
NoneType,
);
bytearray_mut.register_builtin_py_impl(
bytelist_mut.register_builtin_py_impl(
PROC_INSERT,
t_insert,
Immutable,
@ -3215,18 +3204,18 @@ impl Context {
Some(FUNC_INSERT),
);
let t_pop = pr0_met(
ref_mut(bytearray_mut_t.clone(), None),
ref_mut(bytelist_mut_t.clone(), None),
int_interval(IntervalOp::Closed, 0, 255),
);
bytearray_mut.register_builtin_py_impl(
bytelist_mut.register_builtin_py_impl(
PROC_POP,
t_pop,
Immutable,
Visibility::BUILTIN_PUBLIC,
Some(FUNC_POP),
);
let t_reverse = pr0_met(ref_mut(bytearray_mut_t.clone(), None), NoneType);
bytearray_mut.register_builtin_py_impl(
let t_reverse = pr0_met(ref_mut(bytelist_mut_t.clone(), None), NoneType);
bytelist_mut.register_builtin_py_impl(
PROC_REVERSE,
t_reverse,
Immutable,
@ -3445,7 +3434,7 @@ impl Context {
base_exception.register_superclass(Obj, &obj);
base_exception.register_builtin_erg_impl(
ATTR_ARGS,
unknown_len_array_t(Str),
unknown_len_list_t(Str),
Immutable,
Visibility::BUILTIN_PUBLIC,
);
@ -3695,20 +3684,20 @@ impl Context {
Some(MODULE_TYPE),
);
self.register_builtin_type(
mono(GENERIC_ARRAY),
generic_array,
mono(GENERIC_LIST),
generic_list,
vis.clone(),
Const,
Some(ARRAY),
Some(LIST),
);
self.register_builtin_type(
unsized_array_t,
unsized_array,
unsized_list_t,
unsized_list,
vis.clone(),
Const,
Some(UNSIZED_ARRAY),
Some(UNSIZED_LIST),
);
self.register_builtin_type(arr_t, array_, vis.clone(), Const, Some(ARRAY));
self.register_builtin_type(lis_t, list_, vis.clone(), Const, Some(LIST));
self.register_builtin_type(mono(SLICE), slice, vis.clone(), Const, Some(FUNC_SLICE));
self.register_builtin_type(
mono(GENERIC_SET),
@ -3753,11 +3742,11 @@ impl Context {
Some(FUNC_STR_ITERATOR),
);
self.register_builtin_type(
poly(ARRAY_ITERATOR, vec![ty_tp(T.clone())]),
array_iterator,
poly(LIST_ITERATOR, vec![ty_tp(T.clone())]),
list_iterator,
Visibility::BUILTIN_PRIVATE,
Const,
Some(FUNC_ARRAY_ITERATOR),
Some(FUNC_LIST_ITERATOR),
);
self.register_builtin_type(
poly(SET_ITERATOR, vec![ty_tp(T.clone())]),
@ -3851,10 +3840,10 @@ impl Context {
Some(MEMORYVIEW),
);
self.register_builtin_type(mono(MUT_FILE), file_mut, vis.clone(), Const, Some(FILE));
self.register_builtin_type(array_mut_t, array_mut_, vis.clone(), Const, Some(ARRAY));
self.register_builtin_type(list_mut_t, list_mut_, vis.clone(), Const, Some(LIST));
self.register_builtin_type(
bytearray_mut_t,
bytearray_mut,
bytelist_mut_t,
bytelist_mut,
vis.clone(),
Const,
Some(BYTEARRAY),

206
crates/erg_compiler/context/initialize/const_func.rs
View file

@ -186,14 +186,14 @@ pub(crate) fn structural_func(mut args: ValueArgs, ctx: &Context) -> EvalValueRe
Ok(ValueObj::gen_t(GenTypeObj::structural(t, base)).into())
}
pub(crate) fn __array_getitem__(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
pub(crate) fn __list_getitem__(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let slf = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let slf = match ctx.convert_value_into_array(slf) {
let slf = match ctx.convert_value_into_list(slf) {
Ok(slf) => slf,
Err(val) => {
return Err(type_mismatch("Array", val, "Self"));
return Err(type_mismatch("List", val, "Self"));
}
};
let index = args
@ -369,7 +369,7 @@ pub(crate) fn dict_keys(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<T
// let keys = poly(DICT_KEYS, vec![ty_tp(union)]);
Ok(ValueObj::builtin_type(union).into())
} else {
Ok(ValueObj::Array(slf.into_keys().collect::<Vec<_>>().into()).into())
Ok(ValueObj::List(slf.into_keys().collect::<Vec<_>>().into()).into())
}
}
@ -396,7 +396,7 @@ pub(crate) fn dict_values(mut args: ValueArgs, ctx: &Context) -> EvalValueResult
// let values = poly(DICT_VALUES, vec![ty_tp(union)]);
Ok(ValueObj::builtin_type(union).into())
} else {
Ok(ValueObj::Array(slf.into_values().collect::<Vec<_>>().into()).into())
Ok(ValueObj::List(slf.into_values().collect::<Vec<_>>().into()).into())
}
}
@ -423,7 +423,7 @@ pub(crate) fn dict_items(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<
// let items = poly(DICT_ITEMS, vec![ty_tp(union)]);
Ok(ValueObj::builtin_type(union).into())
} else {
Ok(ValueObj::Array(
Ok(ValueObj::List(
slf.into_iter()
.map(|(k, v)| ValueObj::Tuple(vec![k, v].into()))
.collect::<Vec<_>>()
@ -468,12 +468,12 @@ pub(crate) fn dict_diff(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<
}
/// `[Int, Str].union() == Int or Str`
pub(crate) fn array_union(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
pub(crate) fn list_union(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let slf = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let ValueObj::Array(slf) = slf else {
return Err(type_mismatch("Array", slf, "Self"));
let ValueObj::List(slf) = slf else {
return Err(type_mismatch("List", slf, "Self"));
};
let slf = slf
.iter()
@ -485,15 +485,15 @@ pub(crate) fn array_union(mut args: ValueArgs, ctx: &Context) -> EvalValueResult
Ok(ValueObj::builtin_type(union).into())
}
fn _arr_shape(arr: ValueObj, ctx: &Context) -> Result<Vec<TyParam>, String> {
fn _lis_shape(arr: ValueObj, ctx: &Context) -> Result<Vec<TyParam>, String> {
let mut shape = vec![];
let mut arr = arr;
loop {
match arr {
ValueObj::Array(a) => {
ValueObj::List(a) => {
shape.push(ValueObj::from(a.len()).into());
match a.first() {
Some(arr_ @ (ValueObj::Array(_) | ValueObj::Type(_))) => {
Some(arr_ @ (ValueObj::List(_) | ValueObj::Type(_))) => {
arr = arr_.clone();
}
_ => {
@ -501,7 +501,7 @@ fn _arr_shape(arr: ValueObj, ctx: &Context) -> Result<Vec<TyParam>, String> {
}
}
}
ValueObj::Type(ref t) if &t.typ().qual_name()[..] == "Array" => {
ValueObj::Type(ref t) if &t.typ().qual_name()[..] == "List" => {
let mut tps = t.typ().typarams();
let elem = match ctx.convert_tp_into_type(tps.remove(0)) {
Ok(elem) => elem,
@ -522,23 +522,23 @@ fn _arr_shape(arr: ValueObj, ctx: &Context) -> Result<Vec<TyParam>, String> {
}
/// ```erg
/// Array(Int, 2).shape() == [2,]
/// Array(Array(Int, 2), N).shape() == [N, 2]
/// List(Int, 2).shape() == [2,]
/// List(List(Int, 2), N).shape() == [N, 2]
/// [1, 2].shape() == [2,]
/// [[1, 2], [3, 4], [5, 6]].shape() == [3, 2]
/// ```
pub(crate) fn array_shape(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
pub(crate) fn list_shape(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let val = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let res = _arr_shape(arr, ctx).unwrap();
let arr = TyParam::Array(res);
Ok(arr)
let res = _lis_shape(val, ctx).unwrap();
let lis = TyParam::List(res);
Ok(lis)
}
fn _array_scalar_type(mut typ: Type, ctx: &Context) -> Result<Type, String> {
fn _list_scalar_type(mut typ: Type, ctx: &Context) -> Result<Type, String> {
loop {
if matches!(&typ.qual_name()[..], "Array" | "Array!" | "UnsizedArray") {
if matches!(&typ.qual_name()[..], "List" | "List!" | "UnsizedList") {
let tp = typ.typarams().remove(0);
match ctx.convert_tp_into_type(tp) {
Ok(typ_) => {
@ -554,21 +554,21 @@ fn _array_scalar_type(mut typ: Type, ctx: &Context) -> Result<Type, String> {
}
}
pub(crate) fn array_scalar_type(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
pub(crate) fn list_scalar_type(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let slf = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let Ok(slf) = ctx.convert_value_into_type(slf.clone()) else {
return Err(type_mismatch("Type", slf, "Self"));
};
let res = _array_scalar_type(slf, ctx).unwrap();
let res = _list_scalar_type(slf, ctx).unwrap();
Ok(TyParam::t(res))
}
fn _scalar_type(mut value: ValueObj, _ctx: &Context) -> Result<Type, String> {
loop {
match value {
ValueObj::Array(a) => match a.first() {
ValueObj::List(a) => match a.first() {
Some(elem) => {
value = elem.clone();
}
@ -592,7 +592,7 @@ fn _scalar_type(mut value: ValueObj, _ctx: &Context) -> Result<Type, String> {
return Ok(Type::Never);
}
},
ValueObj::UnsizedArray(a) => {
ValueObj::UnsizedList(a) => {
value = *a.clone();
}
other => {
@ -608,17 +608,17 @@ fn _scalar_type(mut value: ValueObj, _ctx: &Context) -> Result<Type, String> {
/// ```
#[allow(unused)]
pub(crate) fn scalar_type(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
let val = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let res = _scalar_type(arr, ctx).unwrap();
let arr = TyParam::t(res);
Ok(arr)
let res = _scalar_type(val, ctx).unwrap();
let lis = TyParam::t(res);
Ok(lis)
}
fn _array_sum(arr: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
fn _list_sum(arr: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
match arr {
ValueObj::Array(a) => {
ValueObj::List(a) => {
let mut sum = 0f64;
for v in a.iter() {
match v {
@ -657,18 +657,18 @@ fn _array_sum(arr: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
/// ```erg
/// [1, 2].sum() == [3,]
/// ```
pub(crate) fn array_sum(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
pub(crate) fn list_sum(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let val = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let res = _array_sum(arr, ctx).unwrap();
let arr = TyParam::Value(res);
Ok(arr)
let res = _list_sum(val, ctx).unwrap();
let lis = TyParam::Value(res);
Ok(lis)
}
fn _array_prod(arr: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
match arr {
ValueObj::Array(a) => {
fn _list_prod(lis: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
match lis {
ValueObj::List(a) => {
let mut prod = 1f64;
for v in a.iter() {
match v {
@ -700,63 +700,63 @@ fn _array_prod(arr: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
Ok(ValueObj::Float(prod))
}
}
_ => Err(format!("Cannot prod {arr}")),
_ => Err(format!("Cannot prod {lis}")),
}
}
/// ```erg
/// [1, 2].prod() == [2,]
/// ```
pub(crate) fn array_prod(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
pub(crate) fn list_prod(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let val = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let res = _array_prod(arr, ctx).unwrap();
let arr = TyParam::Value(res);
Ok(arr)
let res = _list_prod(val, ctx).unwrap();
let lis = TyParam::Value(res);
Ok(lis)
}
fn _array_reversed(arr: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
match arr {
ValueObj::Array(a) => {
fn _list_reversed(lis: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
match lis {
ValueObj::List(a) => {
let mut vec = a.to_vec();
vec.reverse();
Ok(ValueObj::Array(vec.into()))
Ok(ValueObj::List(vec.into()))
}
_ => Err(format!("Cannot reverse {arr}")),
_ => Err(format!("Cannot reverse {lis}")),
}
}
pub(crate) fn array_reversed(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
pub(crate) fn list_reversed(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let val = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let res = _array_reversed(arr, ctx).unwrap();
let arr = TyParam::Value(res);
Ok(arr)
let res = _list_reversed(val, ctx).unwrap();
let lis = TyParam::Value(res);
Ok(lis)
}
fn _array_insert_at(
arr: ValueObj,
fn _list_insert_at(
lis: ValueObj,
index: usize,
value: ValueObj,
_ctx: &Context,
) -> Result<ValueObj, String> {
match arr {
ValueObj::Array(a) => {
match lis {
ValueObj::List(a) => {
let mut a = a.to_vec();
if index > a.len() {
return Err(format!("Index out of range: {index}"));
}
a.insert(index, value);
Ok(ValueObj::Array(a.into()))
Ok(ValueObj::List(a.into()))
}
_ => Err(format!("Cannot insert into {arr}")),
_ => Err(format!("Cannot insert into {lis}")),
}
}
pub(crate) fn array_insert_at(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
pub(crate) fn list_insert_at(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let lis = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let index = args
@ -768,27 +768,27 @@ pub(crate) fn array_insert_at(mut args: ValueArgs, ctx: &Context) -> EvalValueRe
let Ok(index) = usize::try_from(&index) else {
return Err(type_mismatch("Nat", index, "Index"));
};
let res = _array_insert_at(arr, index, value, ctx).unwrap();
let arr = TyParam::Value(res);
Ok(arr)
let res = _list_insert_at(lis, index, value, ctx).unwrap();
let lis = TyParam::Value(res);
Ok(lis)
}
fn _array_remove_at(arr: ValueObj, index: usize, _ctx: &Context) -> Result<ValueObj, String> {
match arr {
ValueObj::Array(a) => {
fn _list_remove_at(lis: ValueObj, index: usize, _ctx: &Context) -> Result<ValueObj, String> {
match lis {
ValueObj::List(a) => {
let mut a = a.to_vec();
if index >= a.len() {
return Err(format!("Index out of range: {index}"));
}
a.remove(index);
Ok(ValueObj::Array(a.into()))
Ok(ValueObj::List(a.into()))
}
_ => Err(format!("Cannot remove from {arr}")),
_ => Err(format!("Cannot remove from {lis}")),
}
}
pub(crate) fn array_remove_at(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
pub(crate) fn list_remove_at(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let val = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let index = args
@ -797,32 +797,32 @@ pub(crate) fn array_remove_at(mut args: ValueArgs, ctx: &Context) -> EvalValueRe
let Ok(index) = usize::try_from(&index) else {
return Err(type_mismatch("Nat", index, "Index"));
};
let res = _array_remove_at(arr, index, ctx).unwrap();
let arr = TyParam::Value(res);
Ok(arr)
let res = _list_remove_at(val, index, ctx).unwrap();
let lis = TyParam::Value(res);
Ok(lis)
}
fn _array_remove_all(arr: ValueObj, value: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
match arr {
ValueObj::Array(a) => {
fn _list_remove_all(lis: ValueObj, value: ValueObj, _ctx: &Context) -> Result<ValueObj, String> {
match lis {
ValueObj::List(a) => {
let mut a = a.to_vec();
a.retain(|v| v != &value);
Ok(ValueObj::Array(a.into()))
Ok(ValueObj::List(a.into()))
}
_ => Err(format!("Cannot remove from {arr}")),
_ => Err(format!("Cannot remove from {lis}")),
}
}
pub(crate) fn array_remove_all(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let arr = args
pub(crate) fn list_remove_all(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let val = args
.remove_left_or_key("Self")
.ok_or_else(|| not_passed("Self"))?;
let value = args
.remove_left_or_key("Value")
.ok_or_else(|| not_passed("Value"))?;
let res = _array_remove_all(arr, value, ctx).unwrap();
let arr = TyParam::Value(res);
Ok(arr)
let res = _list_remove_all(val, value, ctx).unwrap();
let lis = TyParam::Value(res);
Ok(lis)
}
pub(crate) fn __range_getitem__(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
@ -1058,7 +1058,7 @@ pub(crate) fn str_join(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
return Err(type_mismatch("Str", slf, "self"));
};
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
ValueObj::Dict(d) => d.into_keys().collect(),
@ -1136,7 +1136,7 @@ pub(crate) fn all_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1162,7 +1162,7 @@ pub(crate) fn any_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1191,7 +1191,7 @@ pub(crate) fn filter_func(mut args: ValueArgs, ctx: &Context) -> EvalValueResult
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1223,7 +1223,7 @@ pub(crate) fn filter_func(mut args: ValueArgs, ctx: &Context) -> EvalValueResult
}
}
}
Ok(TyParam::Value(ValueObj::Array(filtered.into())))
Ok(TyParam::Value(ValueObj::List(filtered.into())))
}
pub(crate) fn len_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
@ -1231,7 +1231,7 @@ pub(crate) fn len_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let len = match container {
ValueObj::Array(a) => a.len(),
ValueObj::List(a) => a.len(),
ValueObj::Tuple(t) => t.len(),
ValueObj::Set(s) => s.len(),
ValueObj::Dict(d) => d.len(),
@ -1252,7 +1252,7 @@ pub(crate) fn map_func(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<Ty
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1277,7 +1277,7 @@ pub(crate) fn map_func(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<Ty
}
}
}
Ok(TyParam::Array(mapped))
Ok(TyParam::List(mapped))
}
pub(crate) fn max_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
@ -1285,7 +1285,7 @@ pub(crate) fn max_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1320,7 +1320,7 @@ pub(crate) fn min_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1365,7 +1365,7 @@ pub(crate) fn reversed_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueRes
.remove_left_or_key("reversible")
.ok_or_else(|| not_passed("reversible"))?;
let arr = match reversible {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
_ => {
return Err(type_mismatch("Reversible", reversible, "reversible"));
@ -1375,7 +1375,7 @@ pub(crate) fn reversed_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueRes
for v in arr.into_iter().rev() {
reversed.push(v);
}
Ok(TyParam::Value(ValueObj::Array(reversed.into())))
Ok(TyParam::Value(ValueObj::List(reversed.into())))
}
pub(crate) fn str_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
@ -1390,7 +1390,7 @@ pub(crate) fn sum_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
ValueObj::Dict(d) => d.into_keys().collect(),
@ -1502,7 +1502,7 @@ pub(crate) fn zip_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
.remove_left_or_key("iterable2")
.ok_or_else(|| not_passed("iterable2"))?;
let iterable1 = match iterable1 {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1510,7 +1510,7 @@ pub(crate) fn zip_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
}
};
let iterable2 = match iterable2 {
ValueObj::Array(a) => a.to_vec(),
ValueObj::List(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
_ => {
@ -1521,7 +1521,7 @@ pub(crate) fn zip_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
for (v1, v2) in iterable1.into_iter().zip(iterable2.into_iter()) {
zipped.push(ValueObj::Tuple(vec![v1, v2].into()));
}
Ok(TyParam::Value(ValueObj::Array(zipped.into())))
Ok(TyParam::Value(ValueObj::List(zipped.into())))
}
/// ```erg

20
crates/erg_compiler/context/initialize/funcs.rs
View file

@ -53,12 +53,6 @@ impl Context {
None,
)));
let t_ascii = nd_func(vec![kw(KW_OBJECT, Obj)], None, Str);
let t_array = no_var_func(
vec![],
vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
array_t(T.clone(), TyParam::erased(Nat)),
)
.quantify();
let t_assert = no_var_func(vec![kw(KW_TEST, Bool)], vec![kw(KW_MSG, Str)], NoneType);
let t_bin = nd_func(vec![kw(KW_N, Int)], None, Str);
let t_bytes = func0(mono(BYTES))
@ -182,7 +176,7 @@ impl Context {
let t_isinstance = nd_func(
vec![
kw(KW_OBJECT, Obj),
kw(KW_CLASSINFO, ClassType | unknown_len_array_t(ClassType)), // TODO: => ClassInfo
kw(KW_CLASSINFO, ClassType | unknown_len_list_t(ClassType)), // TODO: => ClassInfo
],
None,
Bool,
@ -190,7 +184,7 @@ impl Context {
let t_issubclass = nd_func(
vec![
kw(KW_SUBCLASS, ClassType),
kw(KW_CLASSINFO, ClassType | unknown_len_array_t(ClassType)), // TODO: => ClassInfo
kw(KW_CLASSINFO, ClassType | unknown_len_list_t(ClassType)), // TODO: => ClassInfo
],
None,
Bool,
@ -216,6 +210,12 @@ impl Context {
t_len.clone(),
None,
)));
let t_list = no_var_func(
vec![],
vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
list_t(T.clone(), TyParam::erased(Nat)),
)
.quantify();
let t_log = func(
vec![],
Some(kw(KW_OBJECTS, ref_(Obj))),
@ -341,7 +341,7 @@ impl Context {
let t_sorted = nd_func(
vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
None,
array_t(T.clone(), TyParam::erased(Nat)),
list_t(T.clone(), TyParam::erased(Nat)),
)
.quantify();
let t_staticmethod = nd_func(vec![kw(KW_FUNC, F.clone())], None, F.clone()).quantify();
@ -411,7 +411,7 @@ impl Context {
Some(FUNC_ANY),
Some(33),
);
self.register_py_builtin(FUNC_ARRAY, t_array, Some(FUNC_LIST), 215);
self.register_py_builtin(FUNC_LIST, t_list, Some(FUNC_LIST), 215);
self.register_py_builtin(FUNC_ASCII, t_ascii, Some(FUNC_ASCII), 53);
// Leave as `Const`, as it may negatively affect assert casting.
let name = if PYTHON_MODE { FUNC_ASSERT } else { "assert__" };

17
crates/erg_compiler/context/initialize/mod.rs
View file

@ -258,10 +258,10 @@ const GENERIC_MODULE: &str = "GenericModule";
const PATH: &str = "Path";
const MODULE: &str = "Module";
const PY_MODULE: &str = "PyModule";
const GENERIC_ARRAY: &str = "GenericArray";
const UNSIZED_ARRAY: &str = "UnsizedArray";
const ARRAY: &str = "Array";
const MUT_ARRAY: &str = "Array!";
const GENERIC_LIST: &str = "GenericList";
const UNSIZED_LIST: &str = "UnsizedList";
const LIST: &str = "List";
const MUT_LIST: &str = "List!";
const FUNC_UPDATE_NTH: &str = "update_nth";
const PROC_UPDATE_NTH: &str = "update_nth!";
const FUNC_PARTITION: &str = "partition";
@ -273,7 +273,7 @@ const FUNC_REPEAT: &str = "repeat";
const PROC_PUSH: &str = "push!";
const FUNC_MERGE: &str = "merge";
const PROC_MERGE: &str = "merge!";
const ARRAY_ITERATOR: &str = "ArrayIterator";
const LIST_ITERATOR: &str = "ListIterator";
const GENERIC_SET: &str = "GenericSet";
const SET: &str = "Set";
const MUT_SET: &str = "Set!";
@ -375,7 +375,7 @@ const FUNC_DICT: &str = "dict";
const FUNC_TUPLE: &str = "tuple";
const UNION: &str = "Union";
const FUNC_STR_ITERATOR: &str = "str_iterator";
const FUNC_ARRAY_ITERATOR: &str = "array_iterator";
const FUNC_LIST_ITERATOR: &str = "list_iterator";
const FUNC_SET_ITERATOR: &str = "set_iterator";
const FUNC_TUPLE_ITERATOR: &str = "tuple_iterator";
const FUNC_ENUMERATE: &str = "enumerate";
@ -391,7 +391,7 @@ const FUNC_NTH: &str = "nth";
const FUNC_SKIP: &str = "skip";
const FUNC_POSITION: &str = "position";
const FUNC_CHAIN: &str = "chain";
const FUNC_INTO_ARRAY: &str = "into_array";
const FUNC_TO_LIST: &str = "to_list";
const FILE: &str = "File";
const CALLABLE: &str = "Callable";
const GENERATOR: &str = "Generator";
@ -478,7 +478,6 @@ const USER_WARNING: &str = "UserWarning";
const FUNC_RANGE: &str = "range";
const FUNC_ALL: &str = "all";
const FUNC_ANY: &str = "any";
const FUNC_ARRAY: &str = "array";
const FUNC_ASCII: &str = "ascii";
const FUNC_ASSERT: &str = "assert";
const FUNC_BIN: &str = "bin";
@ -1071,7 +1070,7 @@ impl Context {
};
let qual_name = t.qual_name();
let name = VarName::from_str(t.local_name());
// e.g Array!: |T, N|(_: {T}, _:= {N}) -> {Array!(T, N)}
// e.g. List!: |T, N|(_: {T}, _:= {N}) -> {List!(T, N)}
let nd_params = ctx
.params_spec
.iter()

2
crates/erg_compiler/context/initialize/procs.rs
View file

@ -30,7 +30,7 @@ impl Context {
let t_dir = no_var_proc(
vec![],
vec![kw("object", ref_(Obj))],
array_t(Str, TyParam::erased(Nat)),
list_t(Str, TyParam::erased(Nat)),
);
let t_print = proc(
vec![],

14
crates/erg_compiler/context/initialize/traits.rs
View file

@ -80,7 +80,7 @@ impl Context {
);
readable.register_builtin_decl(
PROC_READLINES,
pr0_met(ref_mut(Slf, None), unknown_len_array_t(Str)),
pr0_met(ref_mut(Slf, None), unknown_len_list_t(Str)),
Visibility::BUILTIN_PUBLIC,
Some(FUNC_READLINES),
);
@ -263,7 +263,7 @@ impl Context {
);
let ret_t = poly(
TUPLE,
vec![TyParam::Array(vec![ty_tp(Nat), ty_tp(T.clone())])],
vec![TyParam::List(vec![ty_tp(Nat), ty_tp(T.clone())])],
);
let t_enumerate = fn0_met(Slf.clone(), poly(ITERATOR, vec![ty_tp(ret_t)])).quantify();
iterable.register_builtin_decl(
@ -362,10 +362,10 @@ impl Context {
Visibility::BUILTIN_PUBLIC,
Some("Function::iterable_chain"),
);
let t_into_array = fn0_met(Slf.clone(), unknown_len_array_t(T.clone())).quantify();
let t_to_list = fn0_met(Slf.clone(), unknown_len_list_t(T.clone())).quantify();
iterable.register_builtin_decl(
FUNC_INTO_ARRAY,
t_into_array,
FUNC_TO_LIST,
t_to_list,
Visibility::BUILTIN_PUBLIC,
Some("Function::list"),
);
@ -514,8 +514,8 @@ impl Context {
Visibility::BUILTIN_PUBLIC,
);
/* HasShape */
let S = mono_q_tp(TY_S, instanceof(unknown_len_array_t(Nat)));
let params = vec![PS::named_nd("S", unknown_len_array_t(Nat))];
let S = mono_q_tp(TY_S, instanceof(unknown_len_list_t(Nat)));
let params = vec![PS::named_nd("S", unknown_len_list_t(Nat))];
let has_shape = Self::builtin_poly_trait(HAS_SHAPE, params.clone(), 2);
/* HasScalarType */
let Ty = mono_q_tp(TY_T, instanceof(Type));

8
crates/erg_compiler/context/inquire.rs
View file

@ -3690,7 +3690,7 @@ impl Context {
/// ```
pub fn meta_type(&self, typ: &Type) -> Type {
match typ {
Type::Poly { name, params } if &name[..] == "Array" || &name[..] == "Set" => poly(
Type::Poly { name, params } if &name[..] == "List" || &name[..] == "Set" => poly(
name.clone(),
params
.iter()
@ -3743,7 +3743,7 @@ impl Context {
/// ```erg
/// recover_typarams(Int, Nat) == Nat
/// recover_typarams(Array!(Int, _), Array(Nat, 2)) == Array!(Nat, 2)
/// recover_typarams(List!(Int, _), List(Nat, 2)) == List!(Nat, 2)
/// recover_typarams(Str or NoneType, {"a", "b"}) == {"a", "b"}
/// ```
/// ```erg
@ -3773,7 +3773,7 @@ impl Context {
)));
}
}
// Array(Nat, 2) !<: Array!(Int, _)
// List(Nat, 2) !<: List!(Int, _)
let base_def_t = self
.get_nominal_type_ctx(base)
.map(|ctx| &ctx.typ)
@ -3783,7 +3783,7 @@ impl Context {
.map(|ctx| &ctx.typ)
.unwrap_or(&Type::Obj);
if self.related(base_def_t, assert_def_t) {
// FIXME: Vec(_), Array(Int, 2) -> Vec(2)
// FIXME: Vec(_), List(Int, 2) -> Vec(2)
let casted = poly(base.qual_name(), guard.to.typarams());
Ok(casted)
} else {

18
crates/erg_compiler/context/instantiate.rs
View file

@ -30,7 +30,7 @@ use crate::hir;
/// For example, cloning each type variable of quantified type `?T -> ?T` would result in `?1 -> ?2`.
/// To avoid this, an environment to store type variables is needed, which is `TyVarCache`.
/// 量化型をインスタンス化するための文脈
/// e.g. Array -> [("T": ?T(: Type)), ("N": ?N(: Nat))]
/// e.g. List -> [("T": ?T(: Type)), ("N": ?N(: Nat))]
/// FIXME: current implementation is wrong
/// It will not work unless the type variable is used with the same name as the definition.
#[derive(Debug, Clone)]
@ -468,16 +468,16 @@ impl Context {
.collect::<TyCheckResult<_>>()?;
Ok(TyParam::Dict(dict))
}
TyParam::Array(arr) => {
let arr = arr
TyParam::List(lis) => {
let lis = lis
.into_iter()
.map(|v| self.instantiate_tp(v, tmp_tv_cache, loc))
.collect::<TyCheckResult<_>>()?;
Ok(TyParam::Array(arr))
Ok(TyParam::List(lis))
}
TyParam::UnsizedArray(elem) => {
TyParam::UnsizedList(elem) => {
let elem = self.instantiate_tp(*elem, tmp_tv_cache, loc)?;
Ok(TyParam::UnsizedArray(Box::new(elem)))
Ok(TyParam::UnsizedList(Box::new(elem)))
}
TyParam::Set(set) => {
let set = set
@ -706,12 +706,12 @@ impl Context {
Ok(ValueObj::Subr(ConstSubr::User(user)))
}
},
ValueObj::Array(arr) => {
ValueObj::List(lis) => {
let mut new = vec![];
for v in arr.iter().cloned() {
for v in lis.iter().cloned() {
new.push(self.instantiate_value(v, tmp_tv_cache, loc)?);
}
Ok(ValueObj::Array(new.into()))
Ok(ValueObj::List(new.into()))
}
ValueObj::Tuple(tup) => {
let mut new = vec![];

54
crates/erg_compiler/context/instantiate_spec.rs
View file

@ -10,7 +10,7 @@ use ast::{
NonDefaultParamSignature, ParamTySpec, PreDeclTypeSpec, TypeBoundSpec, TypeBoundSpecs, TypeSpec,
};
use erg_parser::ast::{
self, ConstApp, ConstArgs, ConstArray, ConstExpr, ConstSet, Identifier, VarName,
self, ConstApp, ConstArgs, ConstExpr, ConstList, ConstSet, Identifier, VarName,
VisModifierSpec, VisRestriction,
};
use erg_parser::token::TokenKind;
@ -443,13 +443,13 @@ impl Context {
ast::ParamPattern::Ref(_) => ref_(gen_free_t()),
ast::ParamPattern::RefMut(_) => ref_mut(gen_free_t(), None),
// ast::ParamPattern::VarName(name) if &name.inspect()[..] == "_" => Type::Obj,
// TODO: Array<Lit>
// TODO: List<Lit>
_ => gen_free_t(),
}
};
if let Some(decl_pt) = opt_decl_t {
if kind.is_var_params() {
let spec_t = unknown_len_array_t(spec_t.clone());
let spec_t = unknown_len_list_t(spec_t.clone());
self.sub_unify(
decl_pt.typ(),
&spec_t,
@ -710,9 +710,9 @@ impl Context {
not_found_is_qvar: bool,
) -> Failable<Type> {
match name.inspect().trim_start_matches([':', '.']) {
"Array" => {
"List" => {
let ctx = &self
.get_nominal_type_ctx(&array_t(Type::Obj, TyParam::Failure))
.get_nominal_type_ctx(&list_t(Type::Obj, TyParam::Failure))
.unwrap()
.ctx;
// TODO: kw
@ -737,9 +737,9 @@ impl Context {
} else {
TyParam::erased(Nat)
};
Ok(array_t(t, len))
Ok(list_t(t, len))
} else {
Ok(mono("GenericArray"))
Ok(mono("GenericList"))
}
}
"Ref" => {
@ -1250,7 +1250,7 @@ impl Context {
}
/// erased_index:
/// e.g. `instantiate_const_expr(Array(Str, _), Some((self, 1))) => Array(Str, _: Nat)`
/// e.g. `instantiate_const_expr(List(Str, _), Some((self, 1))) => List(Str, _: Nat)`
pub(crate) fn instantiate_const_expr(
&self,
expr: &ast::ConstExpr,
@ -1269,40 +1269,40 @@ impl Context {
ast::ConstExpr::App(app) => {
self.instantiate_app(app, erased_idx, tmp_tv_cache, not_found_is_qvar)
}
ast::ConstExpr::Array(ConstArray::Normal(array)) => {
let mut tp_arr = vec![];
for (i, elem) in array.elems.pos_args().enumerate() {
ast::ConstExpr::List(ConstList::Normal(list)) => {
let mut tp_lis = vec![];
for (i, elem) in list.elems.pos_args().enumerate() {
let el = self.instantiate_const_expr(
&elem.expr,
Some((self, i)),
tmp_tv_cache,
not_found_is_qvar,
)?;
tp_arr.push(el);
tp_lis.push(el);
}
Ok(TyParam::Array(tp_arr))
Ok(TyParam::List(tp_lis))
}
ast::ConstExpr::Array(ConstArray::WithLength(arr)) => {
ast::ConstExpr::List(ConstList::WithLength(lis)) => {
let elem = self.instantiate_const_expr(
&arr.elem,
&lis.elem,
erased_idx,
tmp_tv_cache,
not_found_is_qvar,
)?;
let length = self.instantiate_const_expr(
&arr.length,
&lis.length,
erased_idx,
tmp_tv_cache,
not_found_is_qvar,
)?;
if length.is_erased() {
if let Ok(elem_t) = self.instantiate_tp_as_type(elem, arr) {
return Ok(TyParam::t(unknown_len_array_t(elem_t)));
if let Ok(elem_t) = self.instantiate_tp_as_type(elem, lis) {
return Ok(TyParam::t(unknown_len_list_t(elem_t)));
}
}
type_feature_error!(
self,
arr.loc(),
lis.loc(),
&format!("instantiating const expression {expr}")
)
}
@ -1636,14 +1636,14 @@ impl Context {
TyParam::Value(value) => self.convert_value_into_type(value).or_else(|value| {
type_feature_error!(self, loc.loc(), &format!("instantiate `{value}` as type"))
}),
TyParam::Array(arr) => {
let len = TyParam::value(arr.len());
TyParam::List(lis) => {
let len = TyParam::value(lis.len());
let mut union = Type::Never;
for tp in arr {
for tp in lis {
let t = self.instantiate_tp_as_type(tp, loc)?;
union = self.union(&union, &t);
}
Ok(array_t(union, len))
Ok(list_t(union, len))
}
TyParam::Set(set) => {
let t = set
@ -1962,20 +1962,20 @@ impl Context {
mode,
not_found_is_qvar,
)?)),
TypeSpec::Array(arr) => {
TypeSpec::List(lis) => {
let elem_t = self.instantiate_typespec_full(
&arr.ty,
&lis.ty,
opt_decl_t,
tmp_tv_cache,
mode,
not_found_is_qvar,
)?;
let mut len =
self.instantiate_const_expr(&arr.len, None, tmp_tv_cache, not_found_is_qvar)?;
self.instantiate_const_expr(&lis.len, None, tmp_tv_cache, not_found_is_qvar)?;
if let TyParam::Erased(t) = &mut len {
*t.as_mut() = Type::Nat;
}
Ok(array_t(elem_t, len))
Ok(list_t(elem_t, len))
}
TypeSpec::SetWithLen(set) => {
let elem_t = self.instantiate_typespec_full(

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

@ -645,7 +645,7 @@ pub struct Context {
pub(crate) mono_types: Dict<VarName, TypeContext>,
// Implementation Contexts for Polymorphic Types
// Vec<TyParam> are specialization parameters
// e.g. {"Array": [(Array(Nat), ctx), (Array(Int), ctx), (Array(Str), ctx), (Array(Obj), ctx), (Array('T), ctx)], ...}
// e.g. {"List": [(List(Nat), ctx), (List(Int), ctx), (List(Str), ctx), (List(Obj), ctx), (List('T), ctx)], ...}
pub(crate) poly_types: Dict<VarName, TypeContext>,
// patches can be accessed like normal records
// but when used as a fallback to a type, values are traversed instead of accessing by keys

10
crates/erg_compiler/context/register.rs
View file

@ -21,7 +21,7 @@ use erg_parser::ast::{self, ClassAttr, RecordAttrOrIdent, TypeSpecWithOp};
use crate::ty::constructors::{
free_var, func, func0, func1, module, proc, py_module, ref_, ref_mut, str_dict_t, tp_enum,
unknown_len_array_t, v_enum,
unknown_len_list_t, v_enum,
};
use crate::ty::free::{Constraint, HasLevel};
use crate::ty::typaram::TyParam;
@ -397,7 +397,7 @@ impl Context {
Err((ty, errs)) => (ty, errs),
};
let spec_t = match kind {
ParamKind::VarParams => unknown_len_array_t(spec_t),
ParamKind::VarParams => unknown_len_list_t(spec_t),
ParamKind::KwVarParams => str_dict_t(spec_t),
_ => spec_t,
};
@ -577,7 +577,7 @@ impl Context {
}
if let Some(var_params) = &mut params.var_params {
if let Some(pt) = &subr_t.var_params {
let pt = pt.clone().map_type(unknown_len_array_t);
let pt = pt.clone().map_type(unknown_len_list_t);
if let Err(es) =
self.assign_param(var_params, Some(&pt), tmp_tv_cache, ParamKind::VarParams)
{
@ -2764,9 +2764,9 @@ impl Context {
}
res
}
ast::Expr::Array(ast::Array::Normal(arr)) => {
ast::Expr::List(ast::List::Normal(lis)) => {
let mut res = false;
for val in arr.elems.pos_args().iter() {
for val in lis.elems.pos_args().iter() {
if self.inc_ref_expr(&val.expr, namespace, tmp_tv_cache) {
res = true;
}

10
crates/erg_compiler/context/unify.rs
View file

@ -525,7 +525,7 @@ impl<'c, 'l, 'u, L: Locational> Unifier<'c, 'l, 'u, L> {
self.sub_unify(sub, &r)?;
Ok(())
}
(TyParam::Array(sub), TyParam::Array(sup))
(TyParam::List(sub), TyParam::List(sup))
| (TyParam::Tuple(sub), TyParam::Tuple(sup)) => {
for (l, r) in sub.iter().zip(sup.iter()) {
self.sub_unify_tp(l, r, _variance, allow_divergence)?;
@ -1208,8 +1208,8 @@ impl<'c, 'l, 'u, L: Locational> Unifier<'c, 'l, 'u, L> {
};
self.sub_unify(&sub, &new_sup)?;
// ?T(:> Int, <: Int) ==> ?T == Int
// ?T(:> Array(Int, 3), <: Array(?T, ?N)) ==> ?T == Array(Int, 3)
// ?T(:> Array(Int, 3), <: Indexable(?K, ?V)) ==> ?T(:> Array(Int, 3), <: Indexable(0..2, Int))
// ?T(:> List(Int, 3), <: List(?T, ?N)) ==> ?T == List(Int, 3)
// ?T(:> List(Int, 3), <: Indexable(?K, ?V)) ==> ?T(:> List(Int, 3), <: Indexable(0..2, Int))
if !sub.is_refinement()
&& new_sup.qual_name() == sub.qual_name()
&& !new_sup.is_unbound_var()
@ -1384,7 +1384,7 @@ impl<'c, 'l, 'u, L: Locational> Unifier<'c, 'l, 'u, L> {
},
) => {
// e.g. Set(?T) <: Eq(Set(?T))
// Array(Str) <: Iterable(Str)
// List(Str) <: Iterable(Str)
// Zip(T, U) <: Iterable(Tuple([T, U]))
if ln != rn {
self.nominal_sub_unify(maybe_sub, maybe_sup, rps)?;
@ -1542,7 +1542,7 @@ impl<'c, 'l, 'u, L: Locational> Unifier<'c, 'l, 'u, L> {
(Subr(_) | Record(_), Type) => {}
(Guard(_), Bool) | (Bool, Guard(_)) => {}
// REVIEW: correct?
(Poly { name, .. }, Type) if &name[..] == "Array" || &name[..] == "Tuple" => {}
(Poly { name, .. }, Type) if &name[..] == "List" || &name[..] == "Tuple" => {}
(Poly { .. }, _) => {
if maybe_sub.has_no_qvar() && maybe_sup.has_no_qvar() {
return Ok(());