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

clean: add and use const str

Browse source
This commit is contained in:
GreasySlug 2024-02-14 23:37:12 +09:00
parent 46610a1ae0
commit eba80469a6
3 changed files with 112 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -491,7 +491,7 @@ impl Context {
mono(BYTES),
);
int.register_py_builtin(FUNC_TO_BYTES, t_to_bytes, Some(FUNC_TO_BYTES), 55);
let t_call = no_var_func(vec![pos(Obj)], vec![kw("base", Nat)], Int);
let t_call = no_var_func(vec![pos(Obj)], vec![kw(KW_BASE, Nat)], Int);
int.register_builtin_erg_impl(
FUNDAMENTAL_CALL,
t_call,
@ -659,7 +659,7 @@ impl Context {
Some(FUNC_TIMES),
13,
);
let t_call = no_var_func(vec![pos(Obj)], vec![kw("base", Nat)], Nat);
let t_call = no_var_func(vec![pos(Obj)], vec![kw(KW_BASE, Nat)], Nat);
nat.register_builtin_erg_impl(
FUNDAMENTAL_CALL,
t_call,
@ -1198,7 +1198,7 @@ impl Context {
);
str_.register_marker_trait(self, poly(INDEXABLE, vec![ty_tp(Nat), ty_tp(Str)]))
.unwrap();
let t_call = func(vec![], None, vec![kw("object", Obj)], None, Str);
let t_call = func(vec![], None, vec![kw(KW_OBJECT, Obj)], None, Str);
str_.register_builtin_erg_impl(
FUNDAMENTAL_CALL,
t_call,
@ -1853,7 +1853,7 @@ impl Context {
array_t(T.clone(), TyParam::erased(Nat)),
vec![],
vec![kw(
"same_bucket",
KW_SAME_BUCKET,
or(func2(T.clone(), T.clone(), Bool), NoneType),
)],
array_t(T.clone(), TyParam::erased(Nat)),
@ -1862,7 +1862,7 @@ impl Context {
let sum_t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
vec![],
vec![kw("start", T.clone())],
vec![kw(KW_START, T.clone())],
T.clone(),
);
let sum = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
@ -1875,7 +1875,7 @@ impl Context {
let prod_t = no_var_fn_met(
array_t(T.clone(), TyParam::erased(Nat)),
vec![],
vec![kw("start", T.clone())],
vec![kw(KW_START, T.clone())],
T.clone(),
);
let prod = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
@ -2140,11 +2140,11 @@ impl Context {
None,
)));
dict_.register_builtin_const(FUNC_AS_RECORD, Visibility::BUILTIN_PUBLIC, None, as_record);
let Def = type_q("Default");
let Def = type_q(TY_DEFAULT);
let get_t = no_var_fn_met(
dict_t.clone(),
vec![kw("key", T.clone())],
vec![kw_default("default", Def.clone(), NoneType)],
vec![kw(KW_KEY, T.clone())],
vec![kw_default(KW_DEFAULT, Def.clone(), NoneType)],
or(
proj_call(D.clone(), FUNDAMENTAL_GETITEM, vec![ty_tp(T.clone())]),
Def,
@ -2154,7 +2154,7 @@ impl Context {
dict_.register_py_builtin(FUNC_GET, get_t, Some(FUNC_GET), 9);
let copy_t = fn0_met(dict_t.clone(), dict_t.clone()).quantify();
dict_.register_py_builtin(COPY, copy_t, Some(COPY), 7);
let D2 = mono_q_tp("D2", instanceof(mono(GENERIC_DICT)));
let D2 = mono_q_tp(TY_D2, instanceof(mono(GENERIC_DICT)));
let other_dict_t = poly(DICT, vec![D2.clone()]);
let dict_concat_t = fn1_met(
dict_t.clone(),
@ -2335,7 +2335,7 @@ impl Context {
Visibility::BUILTIN_PUBLIC,
);
record.register_trait(mono(RECORD), record_eq);
let Slf = mono_q("Self", subtypeof(mono(RECORD)));
let Slf = mono_q(SELF, subtypeof(mono(RECORD)));
let as_dict_t =
fn0_met(Slf.clone(), proj_call(ty_tp(Slf), FUNC_AS_DICT, vec![])).quantify();
let as_dict = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
@ -2349,7 +2349,7 @@ impl Context {
Visibility::BUILTIN_PUBLIC,
None,
as_dict,
Some("_asdict"),
Some(FUNC_ASDICT),
None,
);
let mut record_meta_type = Self::builtin_mono_class(RECORD_META_TYPE, 2);
@ -2358,7 +2358,7 @@ impl Context {
/* GenericNamedTuple */
let mut generic_named_tuple = Self::builtin_mono_class(GENERIC_NAMED_TUPLE, 2);
generic_named_tuple.register_superclass(mono(GENERIC_TUPLE), &generic_tuple);
let Slf = mono_q("Self", subtypeof(mono(GENERIC_NAMED_TUPLE)));
let Slf = mono_q(SELF, subtypeof(mono(GENERIC_NAMED_TUPLE)));
let input_t = tp_enum(Nat, set! {N.clone()});
let return_t = proj_call(ty_tp(Slf.clone()), FUNDAMENTAL_GETITEM, vec![N.clone()]);
let named_tuple_getitem =
@ -2681,7 +2681,7 @@ impl Context {
let mut int_mut = Self::builtin_mono_class(MUT_INT, 2);
int_mut.register_superclass(Int, &int);
int_mut.register_superclass(mono(MUT_FLOAT), &float_mut);
let t = pr_met(mono(MUT_INT), vec![], None, vec![kw("i", Int)], NoneType);
let t = pr_met(mono(MUT_INT), vec![], None, vec![kw(KW_I, Int)], NoneType);
int_mut.register_builtin_py_impl(
PROC_INC,
t.clone(),
@ -2809,7 +2809,7 @@ impl Context {
str_mut.register_trait(mono(MUT_STR), str_mut_mutable);
let t = pr_met(
ref_mut(mono(MUT_STR), None),
vec![kw("s", Str)],
vec![kw(KW_S, Str)],
None,
vec![],
NoneType,
@ -2839,7 +2839,7 @@ impl Context {
);
let t = pr_met(
ref_mut(mono(MUT_STR), None),
vec![kw("idx", Nat), kw("s", Str)],
vec![kw(KW_IDX, Nat), kw(KW_S, Str)],
None,
vec![],
NoneType,
@ -2853,7 +2853,7 @@ impl Context {
);
let t = pr_met(
ref_mut(mono(MUT_STR), None),
vec![kw("idx", Nat)],
vec![kw(KW_IDX, Nat)],
None,
vec![],
Str,
@ -3130,8 +3130,8 @@ impl Context {
let mut dict_mut =
Self::builtin_poly_class(MUT_DICT, vec![PS::named_nd(TY_D, mono(GENERIC_DICT))], 3);
dict_mut.register_superclass(dict_t.clone(), &dict_);
let K = type_q("K");
let V = type_q("V");
let K = type_q(TY_K);
let V = type_q(TY_V);
let insert_t = pr_met(
ref_mut(
dict_mut_t.clone(),

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

@ -190,8 +190,9 @@ impl Context {
Nat,
)
} else {
let S = Type::from(dict! { Field::public("__len__".into()) => fn0_met(Never, Nat) })
.structuralize();
let S =
Type::from(dict! { Field::public(FUNDAMENTAL_LEN.into()) => fn0_met(Never, Nat) })
.structuralize();
func1(S, Nat)
};
let len = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
@ -392,7 +393,7 @@ impl Context {
self.register_py_builtin(FUNC_ARRAY, t_array, 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 { "assert" } else { "assert__" };
let name = if PYTHON_MODE { FUNC_ASSERT } else { "assert__" };
self.register_builtin_py_impl(FUNC_ASSERT, t_assert, Const, vis.clone(), Some(name));
self.register_builtin_py_impl(FUNC_BIN, t_bin, Immutable, vis.clone(), Some(FUNC_BIN));
self.register_builtin_py_impl(
@ -913,7 +914,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("add"),
Some(FUNC_ADD),
);
let L = mono_q(TY_L, subtypeof(poly(SUB, params.clone())));
let op_t = bin_op(L.clone(), R.clone(), proj(L, OUTPUT)).quantify();
@ -922,7 +923,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("sub"),
Some(FUNC_SUB),
);
let L = mono_q(TY_L, subtypeof(poly(MUL, params.clone())));
let op_t = bin_op(L.clone(), R.clone(), proj(L, OUTPUT)).quantify();
@ -931,7 +932,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("mul"),
Some(FUNC_MUL),
);
let L = mono_q(TY_L, subtypeof(poly(DIV, params.clone())));
let op_t = bin_op(L.clone(), R.clone(), proj(L, OUTPUT)).quantify();
@ -940,7 +941,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("truediv"),
Some(FUNC_TRUEDIV),
);
let L = mono_q(TY_L, subtypeof(poly(FLOOR_DIV, params)));
let op_t = bin_op(L.clone(), R, proj(L, OUTPUT)).quantify();
@ -949,7 +950,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("floordiv"),
Some(FUNC_FLOORDIV),
);
let P = mono_q(TY_P, Constraint::Uninited);
let P = mono_q(TY_P, subtypeof(poly(MUL, vec![ty_tp(P)])));
@ -960,7 +961,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("pow"),
Some(FUNC_POW),
);
let M = mono_q(TY_M, Constraint::Uninited);
let M = mono_q(TY_M, subtypeof(poly(DIV, vec![ty_tp(M)])));
@ -970,7 +971,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("mod"),
Some(FUNC_MOD),
);
let op_t = nd_proc(vec![kw(KW_LHS, Obj), kw(KW_RHS, Obj)], None, Bool);
self.register_builtin_py_impl(
@ -978,14 +979,14 @@ impl Context {
op_t.clone(),
Const,
Visibility::BUILTIN_PRIVATE,
Some("is_"),
Some(FUNC_IS),
);
self.register_builtin_py_impl(
OP_IS_NOT,
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("is_not"),
Some(FUNC_IS_NOT),
);
let E = mono_q(TY_E, subtypeof(mono(EQ)));
let E2 = mono_q(TY_E, subtypeof(mono(IRREGULAR_EQ)));
@ -996,9 +997,15 @@ impl Context {
op_t.clone(),
Const,
Visibility::BUILTIN_PRIVATE,
Some("eq"),
Some(FUNC_EQ),
);
self.register_builtin_py_impl(
OP_NE,
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some(FUNC_NE),
);
self.register_builtin_py_impl(OP_NE, op_t, Const, Visibility::BUILTIN_PRIVATE, Some("ne"));
let PO = mono_q(TY_O, subtypeof(mono(PARTIAL_ORD)));
let op_t = bin_op(PO.clone(), PO.clone(), Bool).quantify();
self.register_builtin_py_impl(
@ -1006,23 +1013,29 @@ impl Context {
op_t.clone(),
Const,
Visibility::BUILTIN_PRIVATE,
Some("lt"),
Some(FUNC_LT),
);
self.register_builtin_py_impl(
OP_LE,
op_t.clone(),
Const,
Visibility::BUILTIN_PRIVATE,
Some("le"),
Some(FUNC_LE),
);
self.register_builtin_py_impl(
OP_GT,
op_t.clone(),
Const,
Visibility::BUILTIN_PRIVATE,
Some("gt"),
Some(FUNC_GT),
);
self.register_builtin_py_impl(
OP_GE,
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some(FUNC_GE),
);
self.register_builtin_py_impl(OP_GE, op_t, Const, Visibility::BUILTIN_PRIVATE, Some("ge"));
let T = type_q(TY_T);
let U = type_q(TY_U);
let or_t = bin_op(Bool, Bool, Bool)
@ -1033,7 +1046,13 @@ impl Context {
)
.quantify()
& bin_op(Type, Type, Type);
self.register_builtin_py_impl(OP_OR, or_t, Const, Visibility::BUILTIN_PRIVATE, Some("or_"));
self.register_builtin_py_impl(
OP_OR,
or_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some(FUNC_OR),
);
let and_t = bin_op(Bool, Bool, Bool)
& bin_op(
tp_enum(Type, set! { ty_tp(T.clone()) }),
@ -1046,7 +1065,7 @@ impl Context {
and_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("and_"),
Some(FUNC_AND),
);
let xor_t = bin_op(Bool, Bool, Bool);
self.register_builtin_py_impl(
@ -1054,7 +1073,7 @@ impl Context {
xor_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("xor"),
Some(FUNC_XOR),
);
let shift_t = bin_op(Int, Nat, Int);
self.register_builtin_py_impl(
@ -1062,14 +1081,14 @@ impl Context {
shift_t.clone(),
Const,
Visibility::BUILTIN_PRIVATE,
Some("lshift"),
Some(FUNC_LSHIFT),
);
self.register_builtin_py_impl(
OP_RSHIFT,
shift_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("rshift"),
Some(FUNC_RSHIFT),
);
let O = mono_q(TY_O, subtypeof(mono(ORD)));
let op_t = bin_op(
@ -1105,7 +1124,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("__pos__"),
Some(OP_POS),
);
let N = mono_q(TY_N, subtypeof(mono(NEG)));
let op_t = func1(N.clone(), proj(N, OUTPUT)).quantify();
@ -1114,7 +1133,7 @@ impl Context {
op_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("__neg__"),
Some(OP_MUL),
);
let invert_t = func1(Int, Int);
self.register_builtin_py_impl(
@ -1122,19 +1141,19 @@ impl Context {
invert_t,
Const,
Visibility::BUILTIN_PRIVATE,
Some("__invert__"),
Some(OP_INVERT),
);
}
pub(super) fn init_py_compat_builtin_operators(&mut self) {
/* binary */
let R = type_q("R");
let O = type_q("O");
let R = type_q(TY_R);
let O = type_q(TY_O);
// Erg : |L <: Add(R), R: Type|(lhs: L, rhs: R) -> L.Output
// Python : |L, R, O: Type|(lhs: Structural({ .__add__ = (L, R) -> O }), rhs: R) -> O
let op_t = {
let S = Type::from(
dict! { Field::public("__add__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_ADD.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1142,7 +1161,7 @@ impl Context {
self.register_builtin_erg_impl(OP_ADD, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__sub__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_SUB.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1150,7 +1169,7 @@ impl Context {
self.register_builtin_erg_impl(OP_SUB, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__mul__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_MUL.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1158,7 +1177,7 @@ impl Context {
self.register_builtin_erg_impl(OP_MUL, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__div__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_DIV.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1166,7 +1185,7 @@ impl Context {
self.register_builtin_erg_impl(OP_DIV, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__floordiv__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_FLOOR_DIV.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1174,7 +1193,7 @@ impl Context {
self.register_builtin_erg_impl(OP_FLOOR_DIV, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__pow__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_POW.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1182,7 +1201,7 @@ impl Context {
self.register_builtin_erg_impl(OP_POW, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__mod__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_MOD.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1191,13 +1210,13 @@ impl Context {
let op_t = nd_proc(vec![kw(KW_LHS, Obj), kw(KW_RHS, Obj)], None, Bool);
self.register_builtin_erg_impl(OP_IS, op_t.clone(), Const, Visibility::BUILTIN_PRIVATE);
self.register_builtin_erg_impl(OP_IS_NOT, op_t, Const, Visibility::BUILTIN_PRIVATE);
let E = type_q("E");
let E = type_q(TY_E);
let op_t = bin_op(E.clone(), E, Bool).quantify();
self.register_builtin_erg_impl(OP_EQ, op_t.clone(), Const, Visibility::BUILTIN_PRIVATE);
self.register_builtin_erg_impl(OP_NE, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__lt__".into()) => fn1_met(Never, R.clone(), Bool) },
dict! { Field::public(OP_LT.into()) => fn1_met(Never, R.clone(), Bool) },
)
.structuralize();
bin_op(S, R.clone(), Bool).quantify()
@ -1205,7 +1224,7 @@ impl Context {
self.register_builtin_erg_impl(OP_LT, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__le__".into()) => fn1_met(Never, R.clone(), Bool) },
dict! { Field::public(OP_LE.into()) => fn1_met(Never, R.clone(), Bool) },
)
.structuralize();
bin_op(S, R.clone(), Bool).quantify()
@ -1213,7 +1232,7 @@ impl Context {
self.register_builtin_erg_impl(OP_LE, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__gt__".into()) => fn1_met(Never, R.clone(), Bool) },
dict! { Field::public(OP_GT.into()) => fn1_met(Never, R.clone(), Bool) },
)
.structuralize();
bin_op(S, R.clone(), Bool).quantify()
@ -1221,7 +1240,7 @@ impl Context {
self.register_builtin_erg_impl(OP_GT, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__ge__".into()) => fn1_met(Never, R.clone(), Bool) },
dict! { Field::public(OP_GE.into()) => fn1_met(Never, R.clone(), Bool) },
)
.structuralize();
bin_op(S, R.clone(), Bool).quantify()
@ -1229,7 +1248,7 @@ impl Context {
self.register_builtin_erg_impl(OP_GE, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__and__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_AND.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1237,7 +1256,7 @@ impl Context {
self.register_builtin_erg_impl(OP_AND, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__or__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_OR.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1245,7 +1264,7 @@ impl Context {
self.register_builtin_erg_impl(OP_OR, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__xor__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_XOR.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1253,7 +1272,7 @@ impl Context {
self.register_builtin_erg_impl(OP_XOR, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__lshift__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_LSHIFT.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O.clone()).quantify()
@ -1261,7 +1280,7 @@ impl Context {
self.register_builtin_erg_impl(OP_LSHIFT, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__rshift__".into()) => fn1_met(Never, R.clone(), O.clone()) },
dict! { Field::public(OP_RSHIFT.into()) => fn1_met(Never, R.clone(), O.clone()) },
)
.structuralize();
bin_op(S, R.clone(), O).quantify()
@ -1281,24 +1300,21 @@ impl Context {
let op_t = func1(M.clone(), proj(M, MUTABLE_MUT_TYPE)).quantify();
self.register_builtin_erg_impl(OP_MUTATE, op_t, Const, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S =
Type::from(dict! { Field::public("__pos__".into()) => fn0_met(Never, R.clone()) })
.structuralize();
let S = Type::from(dict! { Field::public(OP_POS.into()) => fn0_met(Never, R.clone()) })
.structuralize();
func1(S, R.clone()).quantify()
};
self.register_builtin_erg_decl(OP_POS, op_t, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S =
Type::from(dict! { Field::public("__neg__".into()) => fn0_met(Never, R.clone()) })
.structuralize();
let S = Type::from(dict! { Field::public(OP_NEG.into()) => fn0_met(Never, R.clone()) })
.structuralize();
func1(S, R.clone()).quantify()
};
self.register_builtin_erg_decl(OP_NEG, op_t, Visibility::BUILTIN_PRIVATE);
let op_t = {
let S = Type::from(
dict! { Field::public("__invert__".into()) => fn0_met(Never, R.clone()) },
)
.structuralize();
let S =
Type::from(dict! { Field::public(OP_INVERT.into()) => fn0_met(Never, R.clone()) })
.structuralize();
func1(S, R).quantify()
};
self.register_builtin_erg_decl(OP_INVERT, op_t, Visibility::BUILTIN_PRIVATE);

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

@ -202,6 +202,24 @@ const FUNC_ISSPACE: &str = "isspace";
const FUNC_ISTITLE: &str = "istitle";
const FUNC_ISIDENTIFIER: &str = "isidentifier";
const FUNC_ISPRINTABLE: &str = "isprintable";
const FUNC_RSHIFT: &str = "rshift";
const FUNC_LSHIFT: &str = "lshift";
const FUNC_IS: &str = "is_";
const FUNC_NE: &str = "ne";
const FUNC_EQ: &str = "eq";
const FUNC_LT: &str = "lt";
const FUNC_GT: &str = "gt";
const FUNC_GE: &str = "ge";
const FUNC_LE: &str = "le";
const FUNC_XOR: &str = "xor";
const FUNC_AND: &str = "and_";
const FUNC_OR: &str = "or_";
const FUNC_MOD: &str = "mod";
const FUNC_MUL: &str = "mul";
const FUNC_SUB: &str = "sub";
const FUNC_TRUEDIV: &str = "truedive";
const FUNC_FLOORDIV: &str = "floordiv";
const FUNC_IS_NOT: &str = "is_not";
const NONE_TYPE: &str = "NoneType";
const TYPE: &str = "Type";
const CLASS: &str = "Class";
@ -283,6 +301,7 @@ const FUNC_UNION: &str = "union";
const FUNC_SHAPE: &str = "shape";
const FUNC_SCALAR_TYPE: &str = "scalar_type";
const FUNC_AS_DICT: &str = "as_dict";
const FUNC_ASDICT: &str = "_asdict";
const FUNC_AS_RECORD: &str = "as_record";
const FUNC_INC: &str = "inc";
const PROC_INC: &str = "inc!";
@ -515,6 +534,7 @@ const TY_A: &str = "A";
const TY_B: &str = "B";
const TY_C: &str = "C";
const TY_D: &str = "D";
const TY_D2: &str = "D2";
const TY_E: &str = "E";
const TY_F: &str = "F";
const TY_T: &str = "T";
@ -530,6 +550,7 @@ const TY_M: &str = "M";
const TY_O: &str = "O";
const TY_K: &str = "K";
const TY_V: &str = "V";
const TY_DEFAULT: &str = "Default";
const KW_OLD: &str = "old";
const KW_B: &str = "b";
@ -561,6 +582,7 @@ const KW_OBJECT: &str = "object";
const KW_OBJECTS: &str = "objects";
const KW_TEST: &str = "test";
const KW_MSG: &str = "msg";
const KW_SAME_BUCKET: &str = "same_bucket";
const KW_SPEC: &str = "spec";
const KW_STR: &str = "str";
const KW_I: &str = "i";