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

feat: add const reversed/sum/Str::replace

Browse source
This commit is contained in:
Shunsuke Shibayama 2024-01-30 11:01:45 +09:00
parent 7ed39e3281
commit 276583d8ef
7 changed files with 261 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -67,6 +67,7 @@ impl Context {
complex.register_builtin_const(
EPSILON,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::Float(2.220446049250313e-16),
);
complex.register_builtin_py_impl(
@ -185,6 +186,7 @@ impl Context {
float_add.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float.register_trait(Float, float_add);
@ -198,6 +200,7 @@ impl Context {
float_sub.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float.register_trait(Float, float_sub);
@ -211,11 +214,13 @@ impl Context {
float_mul.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float_mul.register_builtin_const(
POW_OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float.register_trait(Float, float_mul);
@ -229,11 +234,13 @@ impl Context {
float_div.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float_div.register_builtin_const(
MOD_OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float.register_trait(Float, float_div);
@ -248,6 +255,7 @@ impl Context {
float_floordiv.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float.register_trait(Float, float_floordiv);
@ -255,6 +263,7 @@ impl Context {
float_pos.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float_pos.register_builtin_erg_impl(
@ -268,6 +277,7 @@ impl Context {
float_neg.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
float_neg.register_builtin_erg_impl(
@ -281,6 +291,7 @@ impl Context {
float_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(mono(MUT_FLOAT)),
);
float.register_trait(Float, float_mutizable);
@ -339,6 +350,7 @@ impl Context {
ratio_add.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
ratio.register_trait(Ratio, ratio_add);
@ -352,6 +364,7 @@ impl Context {
ratio_sub.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
ratio.register_trait(Ratio, ratio_sub);
@ -365,11 +378,13 @@ impl Context {
ratio_mul.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
ratio_mul.register_builtin_const(
POW_OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
ratio.register_trait(Ratio, ratio_mul);
@ -383,11 +398,13 @@ impl Context {
ratio_div.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
ratio_div.register_builtin_const(
MOD_OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
ratio.register_trait(Ratio, ratio_div);
@ -402,6 +419,7 @@ impl Context {
ratio_floordiv.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
ratio.register_trait(Ratio, ratio_floordiv);
@ -409,6 +427,7 @@ impl Context {
ratio_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(mono(MUT_RATIO)),
);
ratio.register_trait(Ratio, ratio_mutizable);
@ -508,6 +527,7 @@ impl Context {
int_add.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
int.register_trait(Int, int_add);
@ -516,6 +536,7 @@ impl Context {
int_sub.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
int.register_trait(Int, int_sub);
@ -524,11 +545,13 @@ impl Context {
int_mul.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
int_mul.register_builtin_const(
POW_OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Nat),
);
int.register_trait(Int, int_mul);
@ -542,6 +565,7 @@ impl Context {
int_floordiv.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
int.register_trait(Int, int_floordiv);
@ -549,6 +573,7 @@ impl Context {
int_pos.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
int_pos.register_builtin_erg_impl(
@ -562,6 +587,7 @@ impl Context {
int_neg.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
int_neg.register_builtin_erg_impl(
@ -575,6 +601,7 @@ impl Context {
int_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(mono(MUT_INT)),
);
int.register_trait(Int, int_mutizable);
@ -639,6 +666,7 @@ impl Context {
nat_add.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Nat),
);
nat.register_trait(Nat, nat_add);
@ -653,6 +681,7 @@ impl Context {
nat_sub.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
nat.register_trait(Nat, nat_sub);
@ -661,6 +690,7 @@ impl Context {
nat_mul.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Nat),
);
nat.register_trait(Nat, nat_mul);
@ -674,6 +704,7 @@ impl Context {
nat_floordiv.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Nat),
);
nat.register_trait(Nat, nat_floordiv);
@ -681,6 +712,7 @@ impl Context {
nat_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(mono(MUT_NAT)),
);
nat.register_trait(Nat, nat_mutizable);
@ -732,6 +764,7 @@ impl Context {
bool_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(mono(MUT_BOOL)),
);
bool_.register_trait(Bool, bool_mutizable);
@ -750,18 +783,25 @@ impl Context {
str_.register_superclass(Obj, &obj);
str_.register_marker_trait(self, mono(ORD)).unwrap();
str_.register_marker_trait(self, mono(PATH_LIKE)).unwrap();
str_.register_builtin_erg_impl(
let t_s_replace = fn_met(
Str,
vec![kw(KW_PAT, Str), kw(KW_INTO, Str)],
None,
vec![],
None,
Str,
);
let s_replace = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_REPLACE,
str_replace,
t_s_replace.clone(),
None,
)));
str_.register_builtin_const(
FUNC_REPLACE,
fn_met(
Str,
vec![kw(KW_PAT, Str), kw(KW_INTO, Str)],
None,
vec![],
None,
Str,
),
Immutable,
Visibility::BUILTIN_PUBLIC,
Some(t_s_replace),
s_replace,
);
str_.register_py_builtin(
FUNC_ENCODE,
@ -1097,6 +1137,7 @@ impl Context {
str_add.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Str),
);
str_.register_trait(Str, str_add);
@ -1110,6 +1151,7 @@ impl Context {
str_mul.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Str),
);
str_.register_trait(Str, str_mul);
@ -1117,6 +1159,7 @@ impl Context {
str_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(mono(MUT_STR)),
);
str_.register_trait(Str, str_mutizable);
@ -1139,6 +1182,7 @@ impl Context {
str_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(mono(STR_ITERATOR)),
);
str_.register_trait(Str, str_iterable);
@ -1463,6 +1507,7 @@ impl Context {
array_add.register_builtin_const(
OUTPUT,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(out_t),
);
array_.register_trait(arr_t.clone(), array_add);
@ -1481,6 +1526,7 @@ impl Context {
array_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
mut_type,
);
array_.register_trait(arr_t.clone(), array_mutizable);
@ -1508,7 +1554,12 @@ impl Context {
array_getitem_t,
None,
)));
array_.register_builtin_const(FUNDAMENTAL_GETITEM, Visibility::BUILTIN_PUBLIC, get_item);
array_.register_builtin_const(
FUNDAMENTAL_GETITEM,
Visibility::BUILTIN_PUBLIC,
None,
get_item,
);
array_
.register_marker_trait(self, poly(INDEXABLE, vec![ty_tp(input), ty_tp(T.clone())]))
.unwrap();
@ -1537,7 +1588,7 @@ impl Context {
array_union_t,
None,
)));
array_.register_builtin_const(FUNC_UNION, Visibility::BUILTIN_PUBLIC, union);
array_.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)),
@ -1550,7 +1601,7 @@ impl Context {
array_shape_t,
None,
)));
array_.register_builtin_const(FUNC_SHAPE, Visibility::BUILTIN_PUBLIC, shape);
array_.register_builtin_const(FUNC_SHAPE, Visibility::BUILTIN_PUBLIC, None, shape);
let mut array_eq = Self::builtin_methods(Some(mono(EQ)), 2);
array_eq.register_builtin_erg_impl(
OP_EQ,
@ -1586,6 +1637,7 @@ impl Context {
array_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(array_iter),
);
array_.register_trait(arr_t.clone(), array_iterable);
@ -1623,7 +1675,7 @@ impl Context {
sum_t.quantify(),
None,
)));
array_.register_builtin_const(FUNC_SUM, Visibility::BUILTIN_PUBLIC, sum);
array_.register_builtin_const(FUNC_SUM, Visibility::BUILTIN_PUBLIC, None, sum);
let prod_t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
vec![],
@ -1636,7 +1688,7 @@ impl Context {
prod_t.quantify(),
None,
)));
array_.register_builtin_const(FUNC_PROD, Visibility::BUILTIN_PUBLIC, prod);
array_.register_builtin_const(FUNC_PROD, Visibility::BUILTIN_PUBLIC, None, prod);
let reversed_t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
vec![],
@ -1649,7 +1701,7 @@ impl Context {
reversed_t.quantify(),
None,
)));
array_.register_builtin_const(FUNC_REVERSED, Visibility::BUILTIN_PUBLIC, reversed);
array_.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);
@ -1698,6 +1750,7 @@ impl Context {
set_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
mut_type,
);
set_.register_trait(set_t.clone(), set_mutizable);
@ -1715,6 +1768,7 @@ impl Context {
set_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(set_iter),
);
set_.register_trait(set_t.clone(), set_iterable);
@ -1790,6 +1844,7 @@ impl Context {
dict_mutizable.register_builtin_const(
MUTABLE_MUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(poly(MUT_DICT, vec![D.clone()])),
);
dict_.register_trait(dict_t.clone(), dict_mutizable);
@ -1803,7 +1858,12 @@ impl Context {
dict_getitem_t,
None,
)));
dict_.register_builtin_const(FUNDAMENTAL_GETITEM, Visibility::BUILTIN_PUBLIC, get_item);
dict_.register_builtin_const(
FUNDAMENTAL_GETITEM,
Visibility::BUILTIN_PUBLIC,
None,
get_item,
);
dict_
.register_marker_trait(
self,
@ -1818,7 +1878,7 @@ impl Context {
dict_keys_t,
None,
)));
dict_.register_builtin_const(KEYS, Visibility::BUILTIN_PUBLIC, keys);
dict_.register_builtin_const(KEYS, Visibility::BUILTIN_PUBLIC, None, keys);
let mut dict_iterable = Self::builtin_methods(
Some(poly(
ITERABLE,
@ -1838,6 +1898,7 @@ impl Context {
dict_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(dict_keys_iterator),
);
dict_.register_trait(dict_t.clone(), dict_iterable);
@ -1861,7 +1922,7 @@ impl Context {
dict_values_t,
None,
)));
dict_.register_builtin_const(VALUES, Visibility::BUILTIN_PUBLIC, values);
dict_.register_builtin_const(VALUES, Visibility::BUILTIN_PUBLIC, None, values);
let dict_items_t = fn0_met(
dict_t.clone(),
poly(DICT_ITEMS, vec![ty_tp(proj_call(D.clone(), ITEMS, vec![]))]),
@ -1873,7 +1934,7 @@ impl Context {
dict_items_t,
None,
)));
dict_.register_builtin_const(ITEMS, Visibility::BUILTIN_PUBLIC, items);
dict_.register_builtin_const(ITEMS, Visibility::BUILTIN_PUBLIC, None, items);
let as_record_t =
fn0_met(dict_t.clone(), proj_call(D.clone(), FUNC_AS_RECORD, vec![])).quantify();
let as_record = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
@ -1882,7 +1943,7 @@ impl Context {
as_record_t,
None,
)));
dict_.register_builtin_const(FUNC_AS_RECORD, Visibility::BUILTIN_PUBLIC, as_record);
dict_.register_builtin_const(FUNC_AS_RECORD, Visibility::BUILTIN_PUBLIC, None, as_record);
let Def = type_q("Default");
let get_t = no_var_fn_met(
dict_t.clone(),
@ -1914,7 +1975,7 @@ impl Context {
dict_concat_t,
None,
)));
dict_.register_builtin_const(FUNC_CONCAT, Visibility::BUILTIN_PUBLIC, concat);
dict_.register_builtin_const(FUNC_CONCAT, Visibility::BUILTIN_PUBLIC, None, concat);
let dict_diff_t = fn1_met(
dict_t.clone(),
other_dict_t.clone(),
@ -1930,7 +1991,7 @@ impl Context {
dict_diff_t,
None,
)));
dict_.register_builtin_const(FUNC_DIFF, Visibility::BUILTIN_PUBLIC, diff);
dict_.register_builtin_const(FUNC_DIFF, Visibility::BUILTIN_PUBLIC, None, diff);
/* Bytes */
let mut bytes = Self::builtin_mono_class(BYTES, 2);
bytes.register_superclass(Obj, &obj);
@ -2060,6 +2121,7 @@ impl Context {
tuple_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(tuple_iterator),
);
tuple_.register_trait(_tuple_t.clone(), tuple_iterable);
@ -2126,6 +2188,7 @@ impl Context {
generic_named_tuple.register_builtin_const(
FUNDAMENTAL_GETITEM,
Visibility::BUILTIN_PUBLIC,
None,
get_item,
);
let mut named_tuple_iterable = Self::builtin_methods(
@ -2150,6 +2213,7 @@ impl Context {
named_tuple_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(named_tuple_iterator),
);
generic_named_tuple.register_trait(mono(GENERIC_NAMED_TUPLE), named_tuple_iterable);
@ -2161,7 +2225,12 @@ impl Context {
named_tuple_union_t,
None,
)));
generic_named_tuple.register_builtin_const(FUNC_UNION, Visibility::BUILTIN_PUBLIC, union);
generic_named_tuple.register_builtin_const(
FUNC_UNION,
Visibility::BUILTIN_PUBLIC,
None,
union,
);
/* Or (true or type) */
let or_t = poly(OR, vec![ty_tp(L), ty_tp(R)]);
let mut or = Self::builtin_poly_class(OR, vec![PS::t_nd(TY_L), PS::t_nd(TY_R)], 2);
@ -2314,6 +2383,7 @@ impl Context {
obj_mut_mutable.register_builtin_const(
IMMUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Obj),
);
let f_t = kw(KW_FUNC, no_var_func(vec![kw(KW_OLD, Int)], vec![], Int));
@ -2338,6 +2408,7 @@ impl Context {
float_mut_mutable.register_builtin_const(
IMMUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Float),
);
let f_t = kw(KW_FUNC, no_var_func(vec![kw(KW_OLD, Float)], vec![], Float));
@ -2363,6 +2434,7 @@ impl Context {
ratio_mut_mutable.register_builtin_const(
IMMUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Ratio),
);
let f_t = kw(KW_FUNC, no_var_func(vec![kw(KW_OLD, Ratio)], vec![], Ratio));
@ -2404,6 +2476,7 @@ impl Context {
int_mut_mutable.register_builtin_const(
IMMUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Int),
);
let f_t = kw(KW_FUNC, no_var_func(vec![kw(KW_OLD, Int)], vec![], Int));
@ -2430,6 +2503,7 @@ impl Context {
nat_mut_mutable.register_builtin_const(
IMMUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Nat),
);
let f_t = kw(KW_FUNC, no_var_func(vec![kw(KW_OLD, Nat)], vec![], Nat));
@ -2456,6 +2530,7 @@ impl Context {
bool_mut_mutable.register_builtin_const(
IMMUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Bool),
);
let f_t = kw(KW_FUNC, no_var_func(vec![kw(KW_OLD, Bool)], vec![], Bool));
@ -2489,6 +2564,7 @@ impl Context {
str_mut_mutable.register_builtin_const(
IMMUT_TYPE,
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Str),
);
let f_t = kw(KW_FUNC, no_var_func(vec![kw(KW_OLD, Str)], vec![], Str));
@ -2990,6 +3066,7 @@ impl Context {
range_iterable.register_builtin_const(
ITERATOR,
vis.clone(),
None,
ValueObj::builtin_class(range_iter),
);
range.register_trait(range_t.clone(), range_iterable);
@ -3000,7 +3077,12 @@ impl Context {
range_getitem_t,
None,
)));
range.register_builtin_const(FUNDAMENTAL_GETITEM, Visibility::BUILTIN_PUBLIC, get_item);
range.register_builtin_const(
FUNDAMENTAL_GETITEM,
Visibility::BUILTIN_PUBLIC,
None,
get_item,
);
let mut g_callable = Self::builtin_mono_class(GENERIC_CALLABLE, 2);
g_callable.register_superclass(Obj, &obj);
let t_return = fn1_met(mono(GENERIC_CALLABLE), Obj, Never).quantify();
@ -3353,8 +3435,8 @@ impl Context {
Some(QUANTIFIED_FUNC_META_TYPE),
);
} else {
self.register_builtin_const(MUT_INT, vis.clone(), ValueObj::builtin_class(Int));
self.register_builtin_const(MUT_STR, vis, ValueObj::builtin_class(Str));
self.register_builtin_const(MUT_INT, vis.clone(), None, ValueObj::builtin_class(Int));
self.register_builtin_const(MUT_STR, vis, None, ValueObj::builtin_class(Str));
}
}
}

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

@ -800,6 +800,28 @@ pub(crate) fn as_record(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<T
Ok(ValueObj::builtin_type(Type::Record(dict)).into())
}
pub(crate) fn str_replace(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
let slf = args
.remove_left_or_key("self")
.ok_or_else(|| not_passed("self"))?;
let old = args
.remove_left_or_key("old")
.ok_or_else(|| not_passed("old"))?;
let new = args
.remove_left_or_key("new")
.ok_or_else(|| not_passed("new"))?;
let Some(slf) = slf.as_str() else {
return Err(type_mismatch("Str", slf, "self"));
};
let Some(old) = old.as_str() else {
return Err(type_mismatch("Str", old, "old"));
};
let Some(new) = new.as_str() else {
return Err(type_mismatch("Str", new, "new"));
};
Ok(ValueObj::Str(slf.replace(&old[..], new).into()).into())
}
pub(crate) fn abs_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
let num = args
.remove_left_or_key("num")
@ -1044,6 +1066,24 @@ pub(crate) fn not_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
}
}
pub(crate) fn reversed_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
let reversible = args
.remove_left_or_key("reversible")
.ok_or_else(|| not_passed("reversible"))?;
let arr = match reversible {
ValueObj::Array(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
_ => {
return Err(type_mismatch("Reversible", reversible, "reversible"));
}
};
let mut reversed = vec![];
for v in arr.into_iter().rev() {
reversed.push(v);
}
Ok(TyParam::Value(ValueObj::Array(reversed.into())))
}
pub(crate) fn str_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
let val = args
.remove_left_or_key("val")
@ -1051,6 +1091,31 @@ pub(crate) fn str_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<T
Ok(ValueObj::Str(val.to_string().into()).into())
}
pub(crate) fn sum_func(mut args: ValueArgs, _ctx: &Context) -> EvalValueResult<TyParam> {
let iterable = args
.remove_left_or_key("iterable")
.ok_or_else(|| not_passed("iterable"))?;
let arr = match iterable {
ValueObj::Array(a) => a.to_vec(),
ValueObj::Tuple(t) => t.to_vec(),
ValueObj::Set(s) => s.into_iter().collect(),
ValueObj::Dict(d) => d.into_keys().collect(),
ValueObj::Record(r) => r.into_values().collect(),
_ => {
return Err(type_mismatch("Iterable(Add)", iterable, "iterable"));
}
};
let mut sum = ValueObj::Nat(0);
for v in arr.into_iter() {
if v.is_num() {
sum = sum.try_add(v).unwrap();
} else {
return Err(type_mismatch("Add", v, "iterable.next()"));
}
}
Ok(sum.into())
}
pub(crate) fn resolve_path_func(mut args: ValueArgs, ctx: &Context) -> EvalValueResult<TyParam> {
let path = args
.remove_left_or_key("Path")

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

@ -302,6 +302,12 @@ impl Context {
poly(REVERSED, vec![ty_tp(T.clone())]),
)
.quantify();
let reversed = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_REVERSED,
reversed_func,
t_reversed.clone(),
None,
)));
let t_round = nd_func(vec![kw(KW_NUMBER, Float)], None, Int);
let t_set = no_var_func(
vec![],
@ -336,6 +342,12 @@ impl Context {
A,
)
.quantify();
let sum = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_SUM,
sum_func,
t_sum.clone(),
None,
)));
let t_unreachable = d_func(vec![kw(KW_MSG, Obj)], Never);
let t_zip = nd_func(
vec![
@ -574,12 +586,13 @@ impl Context {
Some(FUNC_RANGE),
);
self.register_builtin_py_impl(FUNC_REPR, t_repr, Immutable, vis.clone(), Some(FUNC_REPR));
self.register_builtin_py_impl(
self.register_py_builtin_const(
FUNC_REVERSED,
t_reversed,
Immutable,
vis.clone(),
Some(t_reversed),
reversed,
Some(FUNC_REVERSED),
None,
);
self.register_builtin_py_impl(
FUNC_ROUND,
@ -618,7 +631,14 @@ impl Context {
Some(FUNC_STR__),
None,
);
self.register_builtin_py_impl(FUNC_SUM, t_sum, Immutable, vis.clone(), Some(FUNC_SUM));
self.register_py_builtin_const(
FUNC_SUM,
vis.clone(),
Some(t_sum),
sum,
Some(FUNC_SUM),
None,
);
self.register_py_builtin_const(
FUNC_ZIP,
vis.clone(),
@ -729,7 +749,7 @@ impl Context {
ClassType,
);
let class = ConstSubr::Builtin(BuiltinConstSubr::new(CLASS, class_func, class_t, None));
self.register_builtin_const(CLASS, vis.clone(), ValueObj::Subr(class));
self.register_builtin_const(CLASS, vis.clone(), None, ValueObj::Subr(class));
let inherit_t = no_var_func(
vec![kw(KW_SUPER, ClassType)],
vec![kw(KW_IMPL, Type), kw(KW_ADDITIONAL, Type)],
@ -741,14 +761,14 @@ impl Context {
inherit_t,
None,
));
self.register_builtin_const(INHERIT, vis.clone(), ValueObj::Subr(inherit));
self.register_builtin_const(INHERIT, vis.clone(), None, ValueObj::Subr(inherit));
let trait_t = no_var_func(
vec![kw(KW_REQUIREMENT, Type)],
vec![kw(KW_IMPL, Type)],
TraitType,
);
let trait_ = ConstSubr::Builtin(BuiltinConstSubr::new(TRAIT, trait_func, trait_t, None));
self.register_builtin_const(TRAIT, vis.clone(), ValueObj::Subr(trait_));
self.register_builtin_const(TRAIT, vis.clone(), None, ValueObj::Subr(trait_));
let subsume_t = no_var_func(
vec![kw(KW_SUPER, TraitType)],
vec![kw(KW_IMPL, Type), kw(KW_ADDITIONAL, Type)],
@ -760,14 +780,14 @@ impl Context {
subsume_t,
None,
));
self.register_builtin_const(SUBSUME, vis.clone(), ValueObj::Subr(subsume));
self.register_builtin_const(SUBSUME, vis.clone(), None, ValueObj::Subr(subsume));
let structural = ConstSubr::Builtin(BuiltinConstSubr::new(
STRUCTURAL,
structural_func,
func1(Type, Type),
None,
));
self.register_builtin_const(STRUCTURAL, vis.clone(), ValueObj::Subr(structural));
self.register_builtin_const(STRUCTURAL, vis.clone(), None, ValueObj::Subr(structural));
// decorators
let inheritable_t = func1(ClassType, ClassType);
let inheritable = ConstSubr::Builtin(BuiltinConstSubr::new(
@ -776,7 +796,7 @@ impl Context {
inheritable_t,
None,
));
self.register_builtin_const(INHERITABLE, vis.clone(), ValueObj::Subr(inheritable));
self.register_builtin_const(INHERITABLE, vis.clone(), None, ValueObj::Subr(inheritable));
let F = mono_q(TY_F, instanceof(mono(GENERIC_CALLABLE)));
let override_t = func1(F.clone(), F).quantify();
let override_ = ConstSubr::Builtin(BuiltinConstSubr::new(
@ -785,7 +805,7 @@ impl Context {
override_t,
None,
));
self.register_builtin_const(OVERRIDE, vis.clone(), ValueObj::Subr(override_));
self.register_builtin_const(OVERRIDE, vis.clone(), None, ValueObj::Subr(override_));
// TODO: register Del function object
let t_del = nd_func(vec![kw(KW_OBJ, Obj)], None, NoneType);
self.register_builtin_erg_impl(DEL, t_del, Immutable, vis.clone());
@ -795,7 +815,7 @@ impl Context {
TraitType,
);
let patch = ConstSubr::Builtin(BuiltinConstSubr::new(PATCH, patch_func, patch_t, None));
self.register_builtin_const(PATCH, vis.clone(), ValueObj::Subr(patch));
self.register_builtin_const(PATCH, vis.clone(), None, ValueObj::Subr(patch));
let t_resolve_path = nd_func(vec![kw(KW_PATH, Str)], None, Str);
let resolve_path = ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_RESOLVE_PATH,
@ -803,7 +823,12 @@ impl Context {
t_resolve_path,
None,
));
self.register_builtin_const(FUNC_RESOLVE_PATH, vis.clone(), ValueObj::Subr(resolve_path));
self.register_builtin_const(
FUNC_RESOLVE_PATH,
vis.clone(),
None,
ValueObj::Subr(resolve_path),
);
let t_resolve_decl_path = nd_func(vec![kw(KW_PATH, Str)], None, Str);
let resolve_decl_path = ConstSubr::Builtin(BuiltinConstSubr::new(
FUNC_RESOLVE_DECL_PATH,
@ -814,14 +839,15 @@ impl Context {
self.register_builtin_const(
FUNC_RESOLVE_DECL_PATH,
vis.clone(),
None,
ValueObj::Subr(resolve_decl_path),
);
let t_succ = nd_func(vec![kw(KW_N, Nat)], None, Nat);
let succ = ConstSubr::Builtin(BuiltinConstSubr::new(FUNC_SUCC, succ_func, t_succ, None));
self.register_builtin_const(FUNC_SUCC, vis.clone(), ValueObj::Subr(succ));
self.register_builtin_const(FUNC_SUCC, vis.clone(), None, ValueObj::Subr(succ));
let t_pred = nd_func(vec![kw(KW_N, Nat)], None, Nat);
let pred = ConstSubr::Builtin(BuiltinConstSubr::new(FUNC_PRED, pred_func, t_pred, None));
self.register_builtin_const(FUNC_PRED, vis.clone(), ValueObj::Subr(pred));
self.register_builtin_const(FUNC_PRED, vis.clone(), None, ValueObj::Subr(pred));
}
pub(super) fn init_builtin_py_specific_funcs(&mut self) {

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

@ -739,7 +739,13 @@ impl Context {
self.register_builtin_impl(name, t, muty, vis, py_name, abs_loc);
}
fn register_builtin_const(&mut self, name: &str, vis: Visibility, obj: ValueObj) {
fn register_builtin_const(
&mut self,
name: &str,
vis: Visibility,
t: Option<Type>,
obj: ValueObj,
) {
if self.rec_get_const_obj(name).is_some() {
panic!("already registered: {} {name}", self.name);
} else {
@ -754,9 +760,10 @@ impl Context {
}
}
}
let t = t.unwrap_or_else(|| v_enum(set! {obj.clone()}));
// TODO: not all value objects are comparable
let vi = VarInfo::new(
v_enum(set! {obj.clone()}),
t,
Const,
vis,
Builtin,

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

@ -40,6 +40,7 @@ impl Context {
interval_add.register_builtin_const(
"Output",
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Type::from(m.clone() + o.clone()..=n.clone() + p.clone())),
);
interval.register_trait(class.clone(), interval_add);
@ -55,6 +56,7 @@ impl Context {
interval_sub.register_builtin_const(
"Output",
Visibility::BUILTIN_PUBLIC,
None,
ValueObj::builtin_class(Type::from(m - p..=n - o)),
);
interval.register_trait(class, interval_sub);