erg_compiler/context/initialize/
funcs.rs

1use erg_common::consts::{DEBUG_MODE, ERG_MODE, GAL, PYTHON_MODE};
2#[allow(unused_imports)]
3use erg_common::log;
4
5use crate::ty::constructors::*;
6use crate::ty::typaram::TyParam;
7use crate::ty::value::ValueObj;
8use crate::ty::{CastTarget, Field, Type, Visibility};
9use Type::*;
10
11use crate::context::initialize::*;
12use crate::context::Context;
13use crate::varinfo::Mutability;
14use Mutability::*;
15
16impl Context {
17    pub(super) fn init_builtin_funcs(&mut self) {
18        let vis = if PYTHON_MODE {
19            Visibility::BUILTIN_PUBLIC
20        } else {
21            Visibility::BUILTIN_PRIVATE
22        };
23        let T = mono_q(TY_T, instanceof(Type));
24        let U = mono_q(TY_U, instanceof(Type));
25        let Path = mono_q_tp(PATH, instanceof(Str));
26        let t_abs = nd_func(vec![kw(KW_N, mono(NUM))], None, Nat);
27        let abs = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
28            FUNC_ABS,
29            abs_func,
30            t_abs.clone(),
31            None,
32        )));
33        let t_all = no_var_func(
34            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(Bool)]))],
35            vec![],
36            Bool,
37        );
38        let all = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
39            FUNC_ALL,
40            all_func,
41            t_all.clone(),
42            None,
43        )));
44        let t_any = no_var_func(
45            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(Bool)]))],
46            vec![],
47            Bool,
48        );
49        let any = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
50            FUNC_ANY,
51            any_func,
52            t_any.clone(),
53            None,
54        )));
55        let t_ascii = nd_func(vec![kw(KW_OBJECT, Obj)], None, Str);
56        let t_assert = no_var_func(vec![kw(KW_TEST, Bool)], vec![kw(KW_MSG, Str)], NoneType);
57        let t_bin = nd_func(vec![kw(KW_N, Int)], None, Str);
58        let t_bytes = func0(mono(BYTES))
59            & no_var_func(
60                vec![kw(KW_STR, Str), kw(KW_ENCODING, Str)],
61                vec![kw(KW_ERRORS, Str)],
62                mono(BYTES),
63            )
64            // (iterable_of_ints) -> bytes | (bytes_or_buffer) -> bytes & nat -> bytes
65            & nd_func(
66                // TODO: Bytes-like
67                vec![pos(poly(ITERABLE, vec![ty_tp(Nat)]) | Nat | mono(BYTES))],
68                None,
69                mono(BYTES),
70            );
71        let t_bytes_array = no_var_func(
72            vec![],
73            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(Int)]))],
74            mono(MUT_BYTEARRAY),
75        );
76        let t_callable = func1(Obj, Bool);
77        let t_chr_in = if PYTHON_MODE {
78            Int
79        } else {
80            Type::from(value(0usize)..=value(1_114_111usize))
81        };
82        let t_chr = nd_func(vec![kw(KW_I, t_chr_in)], None, Str);
83        let F = mono_q(TY_F, instanceof(mono(GENERIC_CALLABLE)));
84        let t_classmethod = nd_func(vec![kw(KW_FUNC, F.clone())], None, F.clone()).quantify();
85        let t_compile = nd_func(vec![kw(KW_SRC, Str)], None, Code);
86        let t_cond = nd_func(
87            vec![
88                kw(KW_TEST, Bool),
89                kw(KW_THEN, T.clone()),
90                kw(KW_ELSE, T.clone()),
91            ],
92            None,
93            T.clone(),
94        )
95        .quantify();
96        let t_dict = no_var_func(
97            vec![],
98            vec![kw(
99                KW_ITERABLE,
100                poly(ITERABLE, vec![ty_tp(tuple_t(vec![T.clone(), U.clone()]))]),
101            )],
102            out_dict_t(dict! { T.clone() => U.clone() }.into()),
103        )
104        .quantify();
105        let t_discard = nd_func(vec![kw(KW_OBJ, Obj)], None, NoneType);
106        let M = mono_q(TY_M, Constraint::Uninited);
107        let M = mono_q(TY_M, subtypeof(poly(MUL, vec![ty_tp(M)])));
108        let Out = M.clone().proj(MOD_OUTPUT);
109        let t_divmod = nd_func(
110            vec![kw(KW_A, M.clone()), kw(KW_B, M.clone())],
111            None,
112            tuple_t(vec![Out.clone(), Out]),
113        )
114        .quantify();
115        let t_enumerate = no_var_func(
116            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
117            vec![kw(KW_START, Int)],
118            poly(ENUMERATE, vec![ty_tp(T.clone())]),
119        )
120        .quantify();
121        let grd = guard(
122            "<builtins>".into(),
123            CastTarget::arg(0, "x".into(), Location::Unknown),
124            U.clone(),
125        );
126        let t_filter = nd_func(
127            vec![
128                kw(KW_FUNC, nd_func(vec![kw("x", T.clone())], None, grd)),
129                kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())])),
130            ],
131            None,
132            poly(FILTER, vec![ty_tp(T.clone() & U.clone())]),
133        )
134        .quantify()
135            & nd_func(
136                vec![
137                    kw(KW_FUNC, nd_func(vec![anon(T.clone())], None, Bool)),
138                    kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())])),
139                ],
140                None,
141                poly(FILTER, vec![ty_tp(T.clone())]),
142            )
143            .quantify();
144        let t_filter = t_filter.with_default_intersec_index(1);
145        let filter = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
146            FUNC_FILTER,
147            filter_func,
148            t_filter.clone(),
149            None,
150        )));
151        let t_float = default_func(vec![kw(KW_OBJ, Obj)], Float);
152        let t_format = no_var_func(vec![kw(KW_VALUE, Obj)], vec![kw(KW_SPEC, Str)], Str);
153        let t_frozenset = no_var_func(
154            vec![],
155            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
156            poly(FROZENSET, vec![ty_tp(T.clone())]),
157        )
158        .quantify();
159        let getattr_t = no_var_func(
160            vec![kw(KW_OBJ, Obj), kw(KW_NAME, Str)],
161            vec![kw_default(KW_DEFAULT, T.clone(), Obj)],
162            T.clone(),
163        )
164        .quantify();
165        let hasattr_t = no_var_func(vec![kw(KW_OBJ, Obj), kw(KW_NAME, Str)], vec![], Bool);
166        let t_hash = func1(mono(HASH), Int);
167        let t_hex = nd_func(vec![kw(KW_N, Int)], None, Str);
168        let t_if = no_var_func(
169            vec![
170                kw(KW_COND, Bool),
171                kw(KW_THEN, nd_func(vec![], None, T.clone())),
172            ],
173            vec![kw_default(
174                KW_ELSE,
175                nd_func(vec![], None, U.clone()),
176                nd_func(vec![], None, NoneType),
177            )],
178            or(T.clone(), U.clone()),
179        )
180        .quantify();
181        let t_int = no_var_func(vec![kw(KW_OBJ, Obj)], vec![kw(KW_BASE, Nat)], Int);
182        let t_import = nd_func(
183            vec![anon(tp_enum(Str, set! {Path.clone()}))],
184            None,
185            module(TyParam::app(FUNC_RESOLVE_PATH.into(), vec![Path.clone()])),
186        )
187        .quantify();
188        let t_isinstance = nd_func(
189            vec![
190                kw(KW_OBJECT, Obj),
191                kw(
192                    KW_CLASSINFO,
193                    ClassType | type_poly(HOMOGENOUS_TUPLE, vec![ClassType]),
194                ), // TODO: => ClassInfo
195            ],
196            None,
197            Bool,
198        );
199        let t_issubclass = nd_func(
200            vec![
201                kw(KW_SUBCLASS, ClassType),
202                kw(
203                    KW_CLASSINFO,
204                    ClassType | type_poly(HOMOGENOUS_TUPLE, vec![ClassType]),
205                ), // TODO: => ClassInfo
206            ],
207            None,
208            Bool,
209        );
210        let I = mono_q(TY_I, subtypeof(poly(ITERABLE, vec![ty_tp(T.clone())])));
211        let t_iter = nd_func(vec![kw(KW_OBJECT, I.clone())], None, proj(I, ITERATOR)).quantify();
212        // Python : |L|(seq: Structural({ .__len__ = (L) -> Nat })) -> Nat
213        let t_len = if ERG_MODE {
214            nd_func(
215                vec![kw(KW_S, poly(SEQUENCE, vec![TyParam::erased(Type)]))],
216                None,
217                Nat,
218            )
219        } else {
220            let S =
221                Type::from(dict! { Field::public(FUNDAMENTAL_LEN.into()) => fn0_met(Never, Nat) })
222                    .structuralize();
223            func1(S, Nat)
224        };
225        let len = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
226            FUNC_LEN,
227            len_func,
228            t_len.clone(),
229            None,
230        )));
231        let t_list = no_var_func(
232            vec![],
233            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
234            out_list_t(T.clone(), TyParam::erased(Nat)),
235        )
236        .quantify();
237        let t_log = func(
238            vec![],
239            Some(kw(KW_OBJECTS, ref_(Obj))),
240            vec![
241                kw(KW_SEP, Str),
242                kw(KW_END, Str),
243                kw(KW_FILE, mono(WRITE)),
244                kw(KW_FLUSH, Bool),
245            ],
246            None,
247            NoneType,
248        );
249        let t_map = nd_func(
250            vec![
251                kw(KW_FUNC, nd_func(vec![anon(T.clone())], None, U.clone())),
252                kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())])),
253            ],
254            None,
255            poly(MAP, vec![ty_tp(U.clone())]),
256        )
257        .quantify();
258        let map = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
259            FUNC_MAP,
260            map_func,
261            t_map.clone(),
262            None,
263        )));
264        let O = mono_q(TY_O, subtypeof(mono(ORD)));
265        // TODO: iterable should be non-empty
266        let t_max = func(
267            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(O.clone())]))],
268            None,
269            vec![
270                kw(KW_DEFAULT, O.clone()),
271                kw(KW_KEY, func1(O.clone(), O.clone())),
272            ],
273            None,
274            O.clone(),
275        )
276        .quantify()
277            & func(
278                vec![kw(KW_ARG1, O.clone()), kw(KW_ARG2, O.clone())],
279                Some(kw(KW_ARGS, O.clone())),
280                vec![kw(KW_KEY, func1(O.clone(), O.clone()))],
281                None,
282                O.clone(),
283            )
284            .quantify();
285        let max = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
286            FUNC_MAX,
287            max_func,
288            t_max.clone(),
289            None,
290        )));
291        let t_memoryview = nd_func(
292            vec![kw(
293                KW_OBJ,
294                mono(BYTES) | mono(MUT_BYTEARRAY) | mono("array.Array!"),
295            )],
296            None,
297            mono(MEMORYVIEW),
298        );
299        let t_min = func(
300            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(O.clone())]))],
301            None,
302            vec![
303                kw(KW_DEFAULT, O.clone()),
304                kw(KW_KEY, func1(O.clone(), O.clone())),
305            ],
306            None,
307            O.clone(),
308        )
309        .quantify()
310            & func(
311                vec![kw(KW_ARG1, O.clone()), kw(KW_ARG2, O.clone())],
312                Some(kw(KW_ARGS, O.clone())),
313                vec![kw(KW_KEY, func1(O.clone(), O.clone()))],
314                None,
315                O,
316            )
317            .quantify();
318        let min = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
319            FUNC_MIN,
320            min_func,
321            t_min.clone(),
322            None,
323        )));
324        let t_nat = nd_func(vec![kw(KW_OBJ, Obj)], None, Nat);
325        // e.g. not(b: Bool!): Bool!
326        let B = mono_q(TY_B, subtypeof(Bool));
327        let t_not = nd_func(vec![kw(KW_B, B.clone())], None, B).quantify();
328        let not = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
329            FUNC_NOT,
330            not_func,
331            t_not.clone(),
332            None,
333        )));
334        let t_object = nd_func(vec![], None, Obj);
335        let t_oct = nd_func(vec![kw(KW_X, Int)], None, Str);
336        let t_ord = nd_func(vec![kw(KW_C, Str)], None, Nat);
337        let t_panic = nd_func(vec![kw(KW_MSG, Str)], None, Never);
338        let M = mono_q(TY_M, Constraint::Uninited);
339        let M = mono_q(TY_M, subtypeof(poly(MUL, vec![ty_tp(M)])));
340        // TODO: mod
341        let t_pow = nd_func(
342            vec![kw(KW_BASE, M.clone()), kw(KW_EXP, M.clone())],
343            None,
344            proj(M, OUTPUT),
345        )
346        .quantify();
347        let t_pyimport = func(
348            vec![anon(tp_enum(Str, set! {Path.clone()}))],
349            None,
350            vec![
351                kw(KW_GLOBALS, dict! { Str => Obj }.into()),
352                kw(KW_LOCALS, dict! { Str => Obj }.into()),
353                kw(KW_FROMLIST, unknown_len_list_t(Str)),
354                kw(KW_LEVEL, Int),
355            ],
356            None,
357            py_module(TyParam::app(FUNC_RESOLVE_DECL_PATH.into(), vec![Path])),
358        )
359        .quantify();
360        let t_pycompile = nd_func(
361            vec![kw(KW_SRC, Str), kw(KW_FILENAME, Str), kw(KW_MODE, Str)],
362            None,
363            Code,
364        );
365        let t_quit = no_var_func(vec![], vec![kw(KW_CODE, Int)], Never);
366        let t_exit = t_quit.clone();
367        let t_repr = nd_func(vec![kw(KW_OBJECT, Obj)], None, Str);
368        let t_reversed = nd_func(
369            vec![kw(KW_SEQ, poly(SEQUENCE, vec![ty_tp(T.clone())]))],
370            None,
371            poly(REVERSED, vec![ty_tp(T.clone())]),
372        )
373        .quantify();
374        let reversed = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
375            FUNC_REVERSED,
376            reversed_func,
377            t_reversed.clone(),
378            None,
379        )));
380        let t_round = nd_func(vec![kw(KW_NUMBER, Float)], None, Int);
381        let t_set = no_var_func(
382            vec![],
383            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
384            out_set_t(T.clone(), TyParam::erased(Nat)),
385        )
386        .quantify();
387        let t_slice = no_var_func(
388            vec![kw(KW_START, Int | NoneType)],
389            vec![kw(KW_STOP, Int | NoneType), kw(KW_STEP, Int | NoneType)],
390            mono(SLICE),
391        );
392        let t_sorted = nd_func(
393            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(T.clone())]))],
394            None,
395            out_list_t(T.clone(), TyParam::erased(Nat)),
396        )
397        .quantify();
398        let t_staticmethod = nd_func(vec![kw(KW_FUNC, F.clone())], None, F.clone()).quantify();
399        let t_str = nd_func(vec![kw(KW_OBJECT, ref_(Obj))], None, Str)
400            & no_var_func(
401                vec![kw(KW_BYTES_OR_BUFFER, mono(BYTES)), kw(KW_ENCODING, Str)],
402                vec![kw(KW_ERRORS, Str)],
403                Str,
404            );
405        let str_ = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
406            FUNC_STR,
407            str_func,
408            t_str.clone(),
409            None,
410        )));
411        let A = mono_q(TY_A, Constraint::Uninited);
412        let A = mono_q(TY_A, subtypeof(poly(ADD, vec![ty_tp(A)])));
413        let t_sum = no_var_func(
414            vec![kw(KW_ITERABLE, poly(ITERABLE, vec![ty_tp(A.clone())]))],
415            vec![kw_default(KW_START, or(A.clone(), Int), Int)],
416            A,
417        )
418        .quantify();
419        let sum = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
420            FUNC_SUM,
421            sum_func,
422            t_sum.clone(),
423            None,
424        )));
425        let t_unreachable = d_func(vec![kw(KW_MSG, Obj)], Never);
426        let t_vars = no_var_func(
427            vec![],
428            vec![kw_default(KW_OBJECT, Obj, Obj)],
429            out_dict_t(dict! { Str => Obj }.into()),
430        );
431        let t_zip = nd_func(
432            vec![
433                kw(KW_ITERABLE1, poly(ITERABLE, vec![ty_tp(T.clone())])),
434                kw(KW_ITERABLE2, poly(ITERABLE, vec![ty_tp(U.clone())])),
435            ],
436            None,
437            poly(ZIP, vec![ty_tp(T.clone()), ty_tp(U.clone())]),
438        )
439        .quantify();
440        let zip = ValueObj::Subr(ConstSubr::Builtin(BuiltinConstSubr::new(
441            FUNC_ZIP,
442            zip_func,
443            t_zip.clone(),
444            None,
445        )));
446        self.register_py_builtin_const(
447            FUNC_ABS,
448            vis.clone(),
449            Some(t_abs),
450            abs,
451            Some(FUNC_ABS),
452            Some(11),
453        );
454        self.register_py_builtin_const(
455            FUNC_ALL,
456            vis.clone(),
457            Some(t_all),
458            all,
459            Some(FUNC_ALL),
460            Some(22),
461        );
462        self.register_py_builtin_const(
463            FUNC_ANY,
464            vis.clone(),
465            Some(t_any),
466            any,
467            Some(FUNC_ANY),
468            Some(33),
469        );
470        self.register_py_builtin(FUNC_LIST, t_list, Some(FUNC_LIST), 215);
471        self.register_py_builtin(FUNC_ASCII, t_ascii, Some(FUNC_ASCII), 53);
472        // Leave as `Const`, as it may negatively affect assert casting.
473        let name = if PYTHON_MODE { FUNC_ASSERT } else { "assert__" };
474        self.register_builtin_py_impl(FUNC_ASSERT, t_assert, Const, vis.clone(), Some(name));
475        self.register_builtin_py_impl(FUNC_BIN, t_bin, Immutable, vis.clone(), Some(FUNC_BIN));
476        self.register_builtin_py_impl(
477            FUNC_BYTES,
478            t_bytes,
479            Immutable,
480            vis.clone(),
481            Some(FUNC_BYTES),
482        );
483        self.register_builtin_py_impl(
484            FUNC_BYTEARRAY,
485            t_bytes_array,
486            Immutable,
487            vis.clone(),
488            Some(FUNC_BYTEARRAY),
489        );
490        self.register_builtin_py_impl(
491            FUNC_CALLABLE,
492            t_callable,
493            Immutable,
494            vis.clone(),
495            Some(FUNC_CALLABLE),
496        );
497        self.register_builtin_py_impl(FUNC_CHR, t_chr, Immutable, vis.clone(), Some(FUNC_CHR));
498        self.register_builtin_py_impl(
499            FUNC_CLASSMETHOD,
500            t_classmethod,
501            Immutable,
502            vis.clone(),
503            Some(FUNC_CLASSMETHOD),
504        );
505        self.register_builtin_py_impl(
506            FUNC_COMPILE,
507            t_compile,
508            Immutable,
509            vis.clone(),
510            Some(FUNC_COMPILE),
511        );
512        self.register_builtin_erg_impl(KW_COND, t_cond, Immutable, vis.clone());
513        self.register_py_builtin(FUNC_DICT, t_dict, Some(FUNC_DICT), 224);
514        self.register_builtin_py_impl(
515            FUNC_DIVMOD,
516            t_divmod,
517            Immutable,
518            vis.clone(),
519            Some(FUNC_DIVMOD),
520        );
521        self.register_builtin_py_impl(
522            FUNC_ENUMERATE,
523            t_enumerate,
524            Immutable,
525            vis.clone(),
526            Some(FUNC_ENUMERATE),
527        );
528        self.register_builtin_py_impl(FUNC_EXIT, t_exit, Immutable, vis.clone(), Some(FUNC_EXIT));
529        self.register_builtin_py_impl(
530            FUNC_FLOAT,
531            t_float,
532            Immutable,
533            vis.clone(),
534            Some(FUNC_FLOAT),
535        );
536        self.register_builtin_py_impl(
537            FUNC_FORMAT,
538            t_format,
539            Immutable,
540            vis.clone(),
541            Some(FUNC_FORMAT),
542        );
543        self.register_py_builtin_const(
544            FUNC_FILTER,
545            vis.clone(),
546            Some(t_filter),
547            filter,
548            Some(FUNC_FILTER),
549            None,
550        );
551        self.register_builtin_py_impl(
552            FUNC_FROZENSET,
553            t_frozenset,
554            Immutable,
555            vis.clone(),
556            Some(FUNC_FROZENSET),
557        );
558        self.register_builtin_py_impl(
559            FUNC_GETATTR,
560            getattr_t,
561            Immutable,
562            vis.clone(),
563            Some(FUNC_GETATTR),
564        );
565        self.register_builtin_py_impl(
566            FUNC_HASATTR,
567            hasattr_t,
568            Immutable,
569            vis.clone(),
570            Some(FUNC_HASATTR),
571        );
572        self.register_builtin_py_impl(FUNC_HASH, t_hash, Immutable, vis.clone(), Some(FUNC_HASH));
573        self.register_builtin_py_impl(FUNC_HEX, t_hex, Immutable, vis.clone(), Some(FUNC_HEX));
574        self.register_builtin_py_impl(
575            FUNC_ISINSTANCE,
576            t_isinstance,
577            Immutable,
578            vis.clone(),
579            Some(FUNC_ISINSTANCE),
580        );
581        self.register_builtin_py_impl(
582            FUNC_ISSUBCLASS,
583            t_issubclass,
584            Immutable,
585            vis.clone(),
586            Some(FUNC_ISSUBCLASS),
587        );
588        self.register_builtin_py_impl(FUNC_ITER, t_iter, Immutable, vis.clone(), Some(FUNC_ITER));
589        self.register_py_builtin_const(
590            FUNC_LEN,
591            vis.clone(),
592            Some(t_len),
593            len,
594            Some(FUNC_LEN),
595            None,
596        );
597        self.register_py_builtin_const(
598            FUNC_MAP,
599            vis.clone(),
600            Some(t_map),
601            map,
602            Some(FUNC_MAP),
603            None,
604        );
605        self.register_py_builtin_const(
606            FUNC_MAX,
607            vis.clone(),
608            Some(t_max),
609            max,
610            Some(FUNC_MAX),
611            None,
612        );
613        self.register_builtin_py_impl(
614            FUNC_MEMORYVIEW,
615            t_memoryview,
616            Immutable,
617            vis.clone(),
618            Some(FUNC_MEMORYVIEW),
619        );
620        self.register_py_builtin_const(
621            FUNC_MIN,
622            vis.clone(),
623            Some(t_min),
624            min,
625            Some(FUNC_MIN),
626            None,
627        );
628        self.register_py_builtin_const(FUNC_NOT, vis.clone(), Some(t_not), not, None, None); // `not` is not a function in Python
629        self.register_builtin_py_impl(
630            FUNC_OBJECT,
631            t_object,
632            Immutable,
633            vis.clone(),
634            Some(FUNC_OBJECT),
635        );
636        self.register_builtin_py_impl(FUNC_OCT, t_oct, Immutable, vis.clone(), Some(FUNC_OCT));
637        self.register_builtin_py_impl(FUNC_ORD, t_ord, Immutable, vis.clone(), Some(FUNC_ORD));
638        self.register_builtin_py_impl(FUNC_POW, t_pow, Immutable, vis.clone(), Some(FUNC_POW));
639        self.register_builtin_py_impl(
640            PYIMPORT,
641            t_pyimport.clone(),
642            Immutable,
643            vis.clone(),
644            Some(FUNDAMENTAL_IMPORT),
645        );
646        self.register_builtin_py_impl(FUNC_QUIT, t_quit, Immutable, vis.clone(), Some(FUNC_QUIT));
647        let MAX = mono_q_tp("MAX", instanceof(Int));
648        let MIN = mono_q_tp("MIN", instanceof(Int));
649        let t_range = nd_func(
650            vec![kw(KW_START, singleton(Int, MAX.clone()))],
651            None,
652            poly(
653                RANGE,
654                vec![ty_tp((TyParam::value(0u64)..MAX.clone()).into())],
655            ),
656        )
657        .quantify()
658            & nd_func(
659                vec![
660                    kw(KW_START, singleton(Int, MIN.clone())),
661                    kw(KW_STOP, singleton(Int, MAX.clone())),
662                ],
663                None,
664                poly(RANGE, vec![ty_tp((MIN.clone()..MAX.clone()).into())]),
665            )
666            .quantify()
667            & nd_func(
668                vec![
669                    kw(KW_START, singleton(Int, MIN.clone())),
670                    kw(KW_STOP, singleton(Int, MAX.clone())),
671                    kw(KW_STEP, Int),
672                ],
673                None,
674                poly(RANGE, vec![ty_tp((MIN..MAX).into())]),
675            )
676            .quantify()
677            & nd_func(vec![kw(KW_START, Int)], None, poly(RANGE, vec![ty_tp(Int)]))
678            & nd_func(
679                vec![kw(KW_START, Int), kw(KW_STOP, Int)],
680                None,
681                poly(RANGE, vec![ty_tp(Int)]),
682            )
683            & nd_func(
684                vec![kw(KW_START, Int), kw(KW_STOP, Int), kw(KW_STEP, Int)],
685                None,
686                poly(RANGE, vec![ty_tp(Int)]),
687            );
688        self.register_builtin_py_impl(
689            FUNC_RANGE,
690            t_range,
691            Immutable,
692            vis.clone(),
693            Some(FUNC_RANGE),
694        );
695        self.register_builtin_py_impl(FUNC_REPR, t_repr, Immutable, vis.clone(), Some(FUNC_REPR));
696        self.register_py_builtin_const(
697            FUNC_REVERSED,
698            vis.clone(),
699            Some(t_reversed),
700            reversed,
701            Some(FUNC_REVERSED),
702            None,
703        );
704        self.register_builtin_py_impl(
705            FUNC_ROUND,
706            t_round,
707            Immutable,
708            vis.clone(),
709            Some(FUNC_ROUND),
710        );
711        self.register_py_builtin(FUNC_SET, t_set, Some(FUNC_SET), 233);
712        self.register_builtin_py_impl(
713            FUNC_SLICE,
714            t_slice,
715            Immutable,
716            vis.clone(),
717            Some(FUNC_SLICE),
718        );
719        self.register_builtin_py_impl(
720            FUNC_SORTED,
721            t_sorted,
722            Immutable,
723            vis.clone(),
724            Some(FUNC_SORTED),
725        );
726        self.register_builtin_py_impl(
727            FUNC_STATICMETHOD,
728            t_staticmethod,
729            Immutable,
730            vis.clone(),
731            Some(FUNC_STATICMETHOD),
732        );
733        self.register_py_builtin_const(
734            FUNC_STR,
735            vis.clone(),
736            Some(t_str),
737            str_,
738            Some(FUNC_STR__),
739            None,
740        );
741        self.register_py_builtin_const(
742            FUNC_SUM,
743            vis.clone(),
744            Some(t_sum),
745            sum,
746            Some(FUNC_SUM),
747            None,
748        );
749        self.register_builtin_py_impl(FUNC_VARS, t_vars, Immutable, vis.clone(), Some(FUNC_VARS));
750        self.register_py_builtin_const(
751            FUNC_ZIP,
752            vis.clone(),
753            Some(t_zip),
754            zip,
755            Some(FUNC_ZIP),
756            None,
757        );
758        let name = if PYTHON_MODE { FUNC_INT } else { FUNC_INT__ };
759        self.register_builtin_py_impl(FUNC_INT, t_int, Immutable, vis.clone(), Some(name));
760        if DEBUG_MODE {
761            self.register_builtin_py_impl(
762                PY,
763                t_pyimport.clone(),
764                Immutable,
765                vis.clone(),
766                Some(FUNDAMENTAL_IMPORT),
767            );
768        }
769        if GAL {
770            self.register_builtin_py_impl(
771                RSIMPORT,
772                t_pyimport.clone(),
773                Immutable,
774                vis.clone(),
775                Some(FUNDAMENTAL_IMPORT),
776            );
777        }
778        if ERG_MODE {
779            self.register_builtin_py_impl(FUNC_IF, t_if, Immutable, vis.clone(), Some(FUNC_IF__));
780            self.register_builtin_py_impl(
781                FUNC_DISCARD,
782                t_discard,
783                Immutable,
784                vis.clone(),
785                Some(FUNC_DISCARD__),
786            );
787            self.register_builtin_py_impl(
788                FUNC_IMPORT,
789                t_import,
790                Immutable,
791                vis.clone(),
792                Some(FUNDAMENTAL_IMPORT),
793            );
794            self.register_builtin_py_impl(
795                FUNC_LOG,
796                t_log,
797                Immutable,
798                vis.clone(),
799                Some(FUNC_PRINT),
800            );
801            self.register_builtin_py_impl(
802                FUNC_NAT,
803                t_nat,
804                Immutable,
805                vis.clone(),
806                Some(FUNC_NAT__),
807            );
808            self.register_builtin_py_impl(
809                FUNC_PANIC,
810                t_panic,
811                Immutable,
812                vis.clone(),
813                Some(FUNC_QUIT),
814            );
815            self.register_builtin_py_impl(
816                PYCOMPILE,
817                t_pycompile,
818                Immutable,
819                vis.clone(),
820                Some(FUNC_COMPILE),
821            );
822            // TODO: original implementation
823            self.register_builtin_py_impl(
824                FUNC_UNREACHABLE,
825                t_unreachable.clone(),
826                Immutable,
827                vis.clone(),
828                Some(FUNC_EXIT),
829            );
830            self.register_builtin_py_impl(
831                FUNC_TODO,
832                t_unreachable,
833                Immutable,
834                vis,
835                Some(FUNC_EXIT),
836            );
837        } else {
838            self.register_builtin_py_impl(
839                PYIMPORT,
840                t_pyimport,
841                Immutable,
842                Visibility::BUILTIN_PRIVATE,
843                None,
844            );
845        }
846    }
847
848    pub(super) fn init_builtin_const_funcs(&mut self) {
849        let vis = if PYTHON_MODE {
850            Visibility::BUILTIN_PUBLIC
851        } else {
852            Visibility::BUILTIN_PRIVATE
853        };
854        let class_t = no_var_func(
855            vec![],
856            vec![kw(KW_REQUIREMENT, or(Type, Ellipsis)), kw(KW_IMPL, Type)],
857            ClassType,
858        );
859        let class = ConstSubr::Builtin(BuiltinConstSubr::new(CLASS, class_func, class_t, None));
860        self.register_builtin_const(CLASS, vis.clone(), None, ValueObj::Subr(class));
861        let inherit_t = no_var_func(
862            vec![kw(KW_SUPER, ClassType)],
863            vec![kw(KW_IMPL, Type), kw(KW_ADDITIONAL, Type)],
864            ClassType,
865        );
866        let inherit = ConstSubr::Builtin(BuiltinConstSubr::new(
867            INHERIT,
868            inherit_func,
869            inherit_t,
870            None,
871        ));
872        self.register_builtin_const(INHERIT, vis.clone(), None, ValueObj::Subr(inherit));
873        let trait_t = no_var_func(
874            vec![kw(KW_REQUIREMENT, Type)],
875            vec![kw(KW_IMPL, Type)],
876            TraitType,
877        );
878        let trait_ = ConstSubr::Builtin(BuiltinConstSubr::new(TRAIT, trait_func, trait_t, None));
879        self.register_builtin_const(TRAIT, vis.clone(), None, ValueObj::Subr(trait_));
880        let subsume_t = no_var_func(
881            vec![kw(KW_SUPER, TraitType)],
882            vec![kw(KW_IMPL, Type), kw(KW_ADDITIONAL, Type)],
883            TraitType,
884        );
885        let subsume = ConstSubr::Builtin(BuiltinConstSubr::new(
886            SUBSUME,
887            subsume_func,
888            subsume_t,
889            None,
890        ));
891        self.register_builtin_const(SUBSUME, vis.clone(), None, ValueObj::Subr(subsume));
892        let structural = ConstSubr::Builtin(BuiltinConstSubr::new(
893            STRUCTURAL,
894            structural_func,
895            func1(Type, Type),
896            None,
897        ));
898        self.register_builtin_const(STRUCTURAL, vis.clone(), None, ValueObj::Subr(structural));
899        // decorators
900        let inheritable_t = func1(ClassType, ClassType);
901        let inheritable = ConstSubr::Builtin(BuiltinConstSubr::new(
902            INHERITABLE,
903            inheritable_func,
904            inheritable_t,
905            None,
906        ));
907        self.register_builtin_const(INHERITABLE, vis.clone(), None, ValueObj::Subr(inheritable));
908        let F = mono_q(TY_F, instanceof(mono(GENERIC_CALLABLE)));
909        let override_t = func1(F.clone(), F).quantify();
910        let override_ = ConstSubr::Builtin(BuiltinConstSubr::new(
911            OVERRIDE,
912            override_func,
913            override_t,
914            None,
915        ));
916        self.register_builtin_const(OVERRIDE, vis.clone(), None, ValueObj::Subr(override_));
917        // TODO: register Del function object
918        let t_del = nd_func(vec![kw(KW_OBJ, Obj)], None, NoneType);
919        self.register_builtin_erg_impl(DEL, t_del, Immutable, vis.clone());
920        let patch_t = no_var_func(
921            vec![kw(KW_REQUIREMENT, Type)],
922            vec![kw(KW_IMPL, Type)],
923            TraitType,
924        );
925        let patch = ConstSubr::Builtin(BuiltinConstSubr::new(PATCH, patch_func, patch_t, None));
926        self.register_builtin_const(PATCH, vis.clone(), None, ValueObj::Subr(patch));
927        let t_resolve_path = nd_func(vec![kw(KW_PATH, Str)], None, Str);
928        let resolve_path = ConstSubr::Builtin(BuiltinConstSubr::new(
929            FUNC_RESOLVE_PATH,
930            resolve_path_func,
931            t_resolve_path,
932            None,
933        ));
934        self.register_builtin_const(
935            FUNC_RESOLVE_PATH,
936            vis.clone(),
937            None,
938            ValueObj::Subr(resolve_path),
939        );
940        let t_resolve_decl_path = nd_func(vec![kw(KW_PATH, Str)], None, Str);
941        let resolve_decl_path = ConstSubr::Builtin(BuiltinConstSubr::new(
942            FUNC_RESOLVE_DECL_PATH,
943            resolve_decl_path_func,
944            t_resolve_decl_path,
945            None,
946        ));
947        self.register_builtin_const(
948            FUNC_RESOLVE_DECL_PATH,
949            vis.clone(),
950            None,
951            ValueObj::Subr(resolve_decl_path),
952        );
953        let t_succ = nd_func(vec![kw(KW_N, Nat)], None, Nat);
954        let succ = ConstSubr::Builtin(BuiltinConstSubr::new(FUNC_SUCC, succ_func, t_succ, None));
955        self.register_builtin_const(FUNC_SUCC, vis.clone(), None, ValueObj::Subr(succ));
956        let t_pred = nd_func(vec![kw(KW_N, Nat)], None, Nat);
957        let pred = ConstSubr::Builtin(BuiltinConstSubr::new(FUNC_PRED, pred_func, t_pred, None));
958        self.register_builtin_const(FUNC_PRED, vis.clone(), None, ValueObj::Subr(pred));
959        let t_derefine = nd_func(vec![kw(KW_T, Type)], None, Type);
960        let derefine = ConstSubr::Builtin(BuiltinConstSubr::new(
961            FUNC_DEREFINE,
962            derefine_func,
963            t_derefine,
964            None,
965        ));
966        self.register_builtin_const(FUNC_DEREFINE, vis.clone(), None, ValueObj::Subr(derefine));
967        let t_classof = nd_func(vec![kw(KW_OBJ, Obj)], None, ClassType);
968        let classof = ConstSubr::Builtin(BuiltinConstSubr::new(
969            FUNC_CLASSOF,
970            classof_func,
971            t_classof,
972            None,
973        ));
974        self._register_builtin_const(
975            FUNC_CLASSOF,
976            vis.clone(),
977            None,
978            ValueObj::Subr(classof),
979            Some(FUNC_TYPE.into()),
980        );
981        let t_fill_ord = nd_func(vec![kw(KW_T, Type)], None, Type);
982        let fill_ord = ConstSubr::Builtin(BuiltinConstSubr::new(
983            FUNC_FILL_ORD,
984            fill_ord_func,
985            t_fill_ord,
986            None,
987        ));
988        self.register_builtin_const(FUNC_FILL_ORD, vis.clone(), None, ValueObj::Subr(fill_ord));
989    }
990
991    pub(super) fn init_builtin_py_specific_funcs(&mut self) {
992        let setattr_t = no_var_func(
993            vec![kw(KW_OBJ, Obj), kw(KW_NAME, Str), kw(KW_VALUE, Obj)],
994            vec![],
995            NoneType,
996        );
997        self.register_builtin_py_impl(
998            FUNC_SETATTR,
999            setattr_t,
1000            Immutable,
1001            Visibility::BUILTIN_PUBLIC,
1002            None,
1003        );
1004        let delattr_t = no_var_func(vec![kw(KW_OBJ, Obj), kw(KW_NAME, Str)], vec![], NoneType);
1005        self.register_builtin_py_impl(
1006            FUNC_DELATTR,
1007            delattr_t,
1008            Immutable,
1009            Visibility::BUILTIN_PUBLIC,
1010            None,
1011        );
1012        let t_exec = func(
1013            vec![kw(KW_CODE, Str | Code)],
1014            None,
1015            vec![
1016                kw(KW_GLOBALS, mono(GENERIC_DICT)),
1017                kw(KW_LOCALS, mono(GENERIC_DICT)),
1018            ],
1019            None,
1020            NoneType,
1021        );
1022        self.register_builtin_py_impl(
1023            FUNC_EXEC,
1024            t_exec,
1025            Immutable,
1026            Visibility::BUILTIN_PUBLIC,
1027            Some(FUNC_EXEC),
1028        );
1029        let t_eval = func(
1030            vec![kw(KW_CODE, Str | Code)],
1031            None,
1032            vec![
1033                kw(KW_GLOBALS, mono(GENERIC_DICT)),
1034                kw(KW_LOCALS, mono(GENERIC_DICT)),
1035            ],
1036            None,
1037            NoneType,
1038        );
1039        self.register_builtin_py_impl(
1040            FUNC_EVAL,
1041            t_eval,
1042            Immutable,
1043            Visibility::BUILTIN_PUBLIC,
1044            Some(FUNC_EVAL),
1045        );
1046    }
1047
1048    pub(super) fn init_builtin_operators(&mut self) {
1049        /* binary */
1050        let R = mono_q(TY_R, instanceof(Type));
1051        let params = vec![ty_tp(R.clone())];
1052        let L = mono_q(TY_L, subtypeof(poly(ADD, params.clone())));
1053        let op_t = nd_func(
1054            vec![kw(KW_LHS, L.clone()), kw(KW_RHS, R.clone())],
1055            None,
1056            proj(L, OUTPUT),
1057        )
1058        .quantify();
1059        self.register_builtin_py_impl(
1060            OP_ADD,
1061            op_t,
1062            Const,
1063            Visibility::BUILTIN_PRIVATE,
1064            Some(FUNC_ADD),
1065        );
1066        let L = mono_q(TY_L, subtypeof(poly(SUB, params.clone())));
1067        let op_t = bin_op(L.clone(), R.clone(), proj(L, OUTPUT)).quantify();
1068        self.register_builtin_py_impl(
1069            OP_SUB,
1070            op_t,
1071            Const,
1072            Visibility::BUILTIN_PRIVATE,
1073            Some(FUNC_SUB),
1074        );
1075        let L = mono_q(TY_L, subtypeof(poly(MUL, params.clone())));
1076        let L2 = type_q(TY_L);
1077        let R2 = mono_q(TY_R, subtypeof(poly(RMUL, vec![ty_tp(L2.clone())])));
1078        let op_t = (bin_op(L.clone(), R.clone(), proj(L, OUTPUT)).quantify()
1079            & bin_op(L2.clone(), R2.clone(), proj(R2, OUTPUT)).quantify())
1080        .with_default_intersec_index(0);
1081        self.register_builtin_py_impl(
1082            OP_MUL,
1083            op_t,
1084            Const,
1085            Visibility::BUILTIN_PRIVATE,
1086            Some(FUNC_MUL),
1087        );
1088        let L = mono_q(TY_L, subtypeof(poly(DIV, params.clone())));
1089        let L2 = type_q(TY_L);
1090        let R2 = mono_q(TY_R, subtypeof(poly(RDIV, vec![ty_tp(L2.clone())])));
1091        let op_t = (bin_op(L.clone(), R.clone(), proj(L, OUTPUT)).quantify()
1092            & bin_op(L2.clone(), R2.clone(), proj(R2, OUTPUT)).quantify())
1093        .with_default_intersec_index(0);
1094        self.register_builtin_py_impl(
1095            OP_DIV,
1096            op_t,
1097            Const,
1098            Visibility::BUILTIN_PRIVATE,
1099            Some(FUNC_TRUEDIV),
1100        );
1101        let L = mono_q(TY_L, subtypeof(poly(FLOOR_DIV, params)));
1102        let op_t = bin_op(L.clone(), R, proj(L, OUTPUT)).quantify();
1103        self.register_builtin_py_impl(
1104            OP_FLOOR_DIV,
1105            op_t,
1106            Const,
1107            Visibility::BUILTIN_PRIVATE,
1108            Some(FUNC_FLOORDIV),
1109        );
1110        let P = mono_q(TY_P, Constraint::Uninited);
1111        let P = mono_q(TY_P, subtypeof(poly(MUL, vec![ty_tp(P)])));
1112        let op_t = bin_op(P.clone(), P.clone(), proj(P, POW_OUTPUT)).quantify();
1113        // TODO: add bound: M == M.Output
1114        self.register_builtin_py_impl(
1115            OP_POW,
1116            op_t,
1117            Const,
1118            Visibility::BUILTIN_PRIVATE,
1119            Some(FUNC_POW),
1120        );
1121        let M = mono_q(TY_M, Constraint::Uninited);
1122        let M = mono_q(TY_M, subtypeof(poly(DIV, vec![ty_tp(M)])));
1123        let op_t = bin_op(M.clone(), M.clone(), proj(M, MOD_OUTPUT)).quantify();
1124        self.register_builtin_py_impl(
1125            OP_MOD,
1126            op_t,
1127            Const,
1128            Visibility::BUILTIN_PRIVATE,
1129            Some(FUNC_MOD),
1130        );
1131        let op_t = nd_proc(vec![kw(KW_LHS, Obj), kw(KW_RHS, Obj)], None, Bool);
1132        self.register_builtin_py_impl(
1133            OP_IS,
1134            op_t.clone(),
1135            Const,
1136            Visibility::BUILTIN_PRIVATE,
1137            Some(FUNC_IS),
1138        );
1139        self.register_builtin_py_impl(
1140            OP_IS_NOT,
1141            op_t,
1142            Const,
1143            Visibility::BUILTIN_PRIVATE,
1144            Some(FUNC_IS_NOT),
1145        );
1146        let E = mono_q(TY_E, subtypeof(mono(EQ)));
1147        let E2 = mono_q(TY_E, subtypeof(mono(IRREGULAR_EQ)));
1148        let op_t = (bin_op(E.clone(), E, Bool).quantify()
1149            & bin_op(E2.clone(), E2.clone(), E2.proj(OUTPUT)).quantify())
1150        .with_default_intersec_index(0);
1151        self.register_builtin_py_impl(
1152            OP_EQ,
1153            op_t.clone(),
1154            Const,
1155            Visibility::BUILTIN_PRIVATE,
1156            Some(FUNC_EQ),
1157        );
1158        self.register_builtin_py_impl(
1159            OP_NE,
1160            op_t,
1161            Const,
1162            Visibility::BUILTIN_PRIVATE,
1163            Some(FUNC_NE),
1164        );
1165        let PO = mono_q(TY_O, subtypeof(mono(PARTIAL_ORD)));
1166        let op_t = bin_op(PO.clone(), PO.clone(), Bool).quantify();
1167        self.register_builtin_py_impl(
1168            OP_LT,
1169            op_t.clone(),
1170            Const,
1171            Visibility::BUILTIN_PRIVATE,
1172            Some(FUNC_LT),
1173        );
1174        self.register_builtin_py_impl(
1175            OP_LE,
1176            op_t.clone(),
1177            Const,
1178            Visibility::BUILTIN_PRIVATE,
1179            Some(FUNC_LE),
1180        );
1181        self.register_builtin_py_impl(
1182            OP_GT,
1183            op_t.clone(),
1184            Const,
1185            Visibility::BUILTIN_PRIVATE,
1186            Some(FUNC_GT),
1187        );
1188        self.register_builtin_py_impl(
1189            OP_GE,
1190            op_t,
1191            Const,
1192            Visibility::BUILTIN_PRIVATE,
1193            Some(FUNC_GE),
1194        );
1195        let T = type_q(TY_T);
1196        let U = type_q(TY_U);
1197        let or_t = bin_op(Bool, Bool, Bool)
1198            & bin_op(
1199                tp_enum(Type, set! { ty_tp(T.clone()) }),
1200                tp_enum(Type, set! { ty_tp(U.clone()) }),
1201                tp_enum(Type, set! { ty_tp(T.clone() | U.clone()) }),
1202            )
1203            .quantify()
1204            & bin_op(Type, Type, Type);
1205        self.register_builtin_py_impl(
1206            OP_OR,
1207            or_t,
1208            Const,
1209            Visibility::BUILTIN_PRIVATE,
1210            Some(FUNC_OR),
1211        );
1212        let and_t = bin_op(Bool, Bool, Bool)
1213            & bin_op(
1214                tp_enum(Type, set! { ty_tp(T.clone()) }),
1215                tp_enum(Type, set! { ty_tp(U.clone()) }),
1216                tp_enum(Type, set! { ty_tp(T & U) }),
1217            )
1218            .quantify();
1219        self.register_builtin_py_impl(
1220            OP_AND,
1221            and_t,
1222            Const,
1223            Visibility::BUILTIN_PRIVATE,
1224            Some(FUNC_AND),
1225        );
1226        let xor_t = bin_op(Bool, Bool, Bool);
1227        self.register_builtin_py_impl(
1228            OP_XOR,
1229            xor_t,
1230            Const,
1231            Visibility::BUILTIN_PRIVATE,
1232            Some(FUNC_XOR),
1233        );
1234        let shift_t = bin_op(Int, Nat, Int);
1235        self.register_builtin_py_impl(
1236            OP_LSHIFT,
1237            shift_t.clone(),
1238            Const,
1239            Visibility::BUILTIN_PRIVATE,
1240            Some(FUNC_LSHIFT),
1241        );
1242        self.register_builtin_py_impl(
1243            OP_RSHIFT,
1244            shift_t,
1245            Const,
1246            Visibility::BUILTIN_PRIVATE,
1247            Some(FUNC_RSHIFT),
1248        );
1249        let O = mono_q(TY_O, subtypeof(mono(ORD)));
1250        let op_t = bin_op(
1251            O.clone(),
1252            O.clone(),
1253            range(poly(FUNC_FILL_ORD, vec![ty_tp(O)])),
1254        )
1255        .quantify();
1256        self.register_builtin_erg_decl(OP_RNG, op_t.clone(), Visibility::BUILTIN_PRIVATE);
1257        self.register_builtin_erg_decl(OP_LORNG, op_t.clone(), Visibility::BUILTIN_PRIVATE);
1258        self.register_builtin_erg_decl(OP_RORNG, op_t.clone(), Visibility::BUILTIN_PRIVATE);
1259        self.register_builtin_erg_decl(OP_ORNG, op_t, Visibility::BUILTIN_PRIVATE);
1260        // TODO: use existential type: |T: Type| (Container(T), T) -> Bool
1261        // __contains__: |T, C <: Container(T)| (C, T) -> Bool
1262        let T = mono_q(TY_T, instanceof(Type));
1263        let C = mono_q(TY_C, subtypeof(poly(CONTAINER, vec![ty_tp(T.clone())])));
1264        let op_t = bin_op(C, T, Bool).quantify();
1265        self.register_builtin_erg_impl(
1266            FUNDAMENTAL_CONTAINS,
1267            op_t.clone(),
1268            Const,
1269            Visibility::BUILTIN_PRIVATE,
1270        );
1271        /* unary */
1272        // TODO: +/- Bool would like to be warned
1273        let M = mono_q(TY_M, subtypeof(mono(MUTIZABLE)));
1274        let op_t = func1(M.clone(), proj(M, MUTABLE_MUT_TYPE)).quantify();
1275        self.register_builtin_erg_impl(OP_MUTATE, op_t, Const, Visibility::BUILTIN_PRIVATE);
1276        let P = mono_q(TY_N, subtypeof(mono(POS)));
1277        let op_t = func1(P.clone(), proj(P, OUTPUT)).quantify();
1278        self.register_builtin_py_impl(
1279            OP_POS,
1280            op_t,
1281            Const,
1282            Visibility::BUILTIN_PRIVATE,
1283            Some(OP_POS),
1284        );
1285        let N = mono_q(TY_N, subtypeof(mono(NEG)));
1286        let op_t = func1(N.clone(), proj(N, OUTPUT)).quantify();
1287        self.register_builtin_py_impl(
1288            OP_NEG,
1289            op_t,
1290            Const,
1291            Visibility::BUILTIN_PRIVATE,
1292            Some(OP_NEG),
1293        );
1294        let invert_t = func1(Int, Int);
1295        self.register_builtin_py_impl(
1296            OP_INVERT,
1297            invert_t,
1298            Const,
1299            Visibility::BUILTIN_PRIVATE,
1300            Some(OP_INVERT),
1301        );
1302    }
1303
1304    pub(super) fn init_py_compat_builtin_operators(&mut self) {
1305        /* binary */
1306        let R = type_q(TY_R);
1307        let O = type_q(TY_O);
1308        // Erg    : |L <: Add(R), R: Type|(lhs: L, rhs: R) -> L.Output
1309        // Python : |L, R, O: Type|(lhs: Structural({ .__add__ = (L, R) -> O }), rhs: R) -> O
1310        let op_t = {
1311            let S = Type::from(
1312                dict! { Field::public(OP_ADD.into()) => fn1_met(Never, R.clone(), O.clone()) },
1313            )
1314            .structuralize();
1315            bin_op(S, R.clone(), O.clone()).quantify()
1316        };
1317        self.register_builtin_erg_impl(OP_ADD, op_t, Const, Visibility::BUILTIN_PRIVATE);
1318        let op_t = {
1319            let S = Type::from(
1320                dict! { Field::public(OP_SUB.into()) => fn1_met(Never, R.clone(), O.clone()) },
1321            )
1322            .structuralize();
1323            bin_op(S, R.clone(), O.clone()).quantify()
1324        };
1325        self.register_builtin_erg_impl(OP_SUB, op_t, Const, Visibility::BUILTIN_PRIVATE);
1326        let op_t = {
1327            let S = Type::from(
1328                dict! { Field::public(OP_MUL.into()) => fn1_met(Never, R.clone(), O.clone()) },
1329            )
1330            .structuralize();
1331            bin_op(S, R.clone(), O.clone()).quantify()
1332        };
1333        self.register_builtin_erg_impl(OP_MUL, op_t, Const, Visibility::BUILTIN_PRIVATE);
1334        let op_t = {
1335            let S = Type::from(
1336                dict! { Field::public(OP_DIV.into()) => fn1_met(Never, R.clone(), O.clone()) },
1337            )
1338            .structuralize();
1339            bin_op(S, R.clone(), O.clone()).quantify()
1340        };
1341        self.register_builtin_erg_impl(OP_DIV, op_t, Const, Visibility::BUILTIN_PRIVATE);
1342        let op_t = {
1343            let S = Type::from(
1344                dict! { Field::public(OP_FLOOR_DIV.into()) => fn1_met(Never, R.clone(), O.clone()) },
1345            )
1346            .structuralize();
1347            bin_op(S, R.clone(), O.clone()).quantify()
1348        };
1349        self.register_builtin_erg_impl(OP_FLOOR_DIV, op_t, Const, Visibility::BUILTIN_PRIVATE);
1350        let op_t = {
1351            let S = Type::from(
1352                dict! { Field::public(OP_POW.into()) => fn1_met(Never, R.clone(), O.clone()) },
1353            )
1354            .structuralize();
1355            bin_op(S, R.clone(), O.clone()).quantify()
1356        };
1357        self.register_builtin_erg_impl(OP_POW, op_t, Const, Visibility::BUILTIN_PRIVATE);
1358        let op_t = {
1359            let S = Type::from(
1360                dict! { Field::public(OP_MOD.into()) => fn1_met(Never, R.clone(), O.clone()) },
1361            )
1362            .structuralize();
1363            bin_op(S, R.clone(), O.clone()).quantify()
1364        };
1365        self.register_builtin_erg_impl(OP_MOD, op_t, Const, Visibility::BUILTIN_PRIVATE);
1366        let op_t = nd_proc(vec![kw(KW_LHS, Obj), kw(KW_RHS, Obj)], None, Bool);
1367        self.register_builtin_erg_impl(OP_IS, op_t.clone(), Const, Visibility::BUILTIN_PRIVATE);
1368        self.register_builtin_erg_impl(OP_IS_NOT, op_t, Const, Visibility::BUILTIN_PRIVATE);
1369        let E = type_q(TY_E);
1370        let op_t = bin_op(E.clone(), E, Bool).quantify();
1371        self.register_builtin_erg_impl(OP_EQ, op_t.clone(), Const, Visibility::BUILTIN_PRIVATE);
1372        self.register_builtin_erg_impl(OP_NE, op_t, Const, Visibility::BUILTIN_PRIVATE);
1373        let op_t = {
1374            let S = Type::from(
1375                dict! { Field::public(OP_LT.into()) => fn1_met(Never, R.clone(), Bool) },
1376            )
1377            .structuralize();
1378            bin_op(S, R.clone(), Bool).quantify()
1379        };
1380        self.register_builtin_erg_impl(OP_LT, op_t, Const, Visibility::BUILTIN_PRIVATE);
1381        let op_t = {
1382            let S = Type::from(
1383                dict! { Field::public(OP_LE.into()) => fn1_met(Never, R.clone(), Bool) },
1384            )
1385            .structuralize();
1386            bin_op(S, R.clone(), Bool).quantify()
1387        };
1388        self.register_builtin_erg_impl(OP_LE, op_t, Const, Visibility::BUILTIN_PRIVATE);
1389        let op_t = {
1390            let S = Type::from(
1391                dict! { Field::public(OP_GT.into()) => fn1_met(Never, R.clone(), Bool) },
1392            )
1393            .structuralize();
1394            bin_op(S, R.clone(), Bool).quantify()
1395        };
1396        self.register_builtin_erg_impl(OP_GT, op_t, Const, Visibility::BUILTIN_PRIVATE);
1397        let op_t = {
1398            let S = Type::from(
1399                dict! { Field::public(OP_GE.into()) => fn1_met(Never, R.clone(), Bool) },
1400            )
1401            .structuralize();
1402            bin_op(S, R.clone(), Bool).quantify()
1403        };
1404        self.register_builtin_erg_impl(OP_GE, op_t, Const, Visibility::BUILTIN_PRIVATE);
1405        let op_t = {
1406            let S = Type::from(
1407                dict! { Field::public(OP_AND.into()) => fn1_met(Never, R.clone(), O.clone()) },
1408            )
1409            .structuralize();
1410            bin_op(S, R.clone(), O.clone()).quantify()
1411        };
1412        self.register_builtin_erg_impl(OP_AND, op_t, Const, Visibility::BUILTIN_PRIVATE);
1413        let op_t = {
1414            let S = Type::from(
1415                dict! { Field::public(OP_OR.into()) => fn1_met(Never, R.clone(), O.clone()) },
1416            )
1417            .structuralize();
1418            bin_op(S, R.clone(), O.clone()).quantify()
1419        };
1420        self.register_builtin_erg_impl(OP_OR, op_t, Const, Visibility::BUILTIN_PRIVATE);
1421        let op_t = {
1422            let S = Type::from(
1423                dict! { Field::public(OP_XOR.into()) => fn1_met(Never, R.clone(), O.clone()) },
1424            )
1425            .structuralize();
1426            bin_op(S, R.clone(), O.clone()).quantify()
1427        };
1428        self.register_builtin_erg_impl(OP_XOR, op_t, Const, Visibility::BUILTIN_PRIVATE);
1429        let op_t = {
1430            let S = Type::from(
1431                dict! { Field::public(OP_LSHIFT.into()) => fn1_met(Never, R.clone(), O.clone()) },
1432            )
1433            .structuralize();
1434            bin_op(S, R.clone(), O.clone()).quantify()
1435        };
1436        self.register_builtin_erg_impl(OP_LSHIFT, op_t, Const, Visibility::BUILTIN_PRIVATE);
1437        let op_t = {
1438            let S = Type::from(
1439                dict! { Field::public(OP_RSHIFT.into()) => fn1_met(Never, R.clone(), O.clone()) },
1440            )
1441            .structuralize();
1442            bin_op(S, R.clone(), O).quantify()
1443        };
1444        self.register_builtin_erg_impl(OP_RSHIFT, op_t, Const, Visibility::BUILTIN_PRIVATE);
1445        let op_t = {
1446            let S = Type::from(
1447                dict! { Field::public(FUNDAMENTAL_CONTAINS.into()) => fn1_met(Never, R.clone(), Bool) },
1448            )
1449            .structuralize();
1450            bin_op(S, R.clone(), Bool).quantify()
1451        };
1452        let op_t2 = {
1453            let S = Type::from(
1454                dict! { Field::public(FUNDAMENTAL_ITER.into()) => fn0_met(Never, poly(ITERATOR, vec![ty_tp(R.clone())])) },
1455            )
1456            .structuralize();
1457            bin_op(S, R.clone(), Bool).quantify()
1458        };
1459        let op_t = (op_t & op_t2).with_default_intersec_index(0);
1460        self.register_builtin_erg_impl(
1461            FUNDAMENTAL_CONTAINS,
1462            op_t.clone(),
1463            Const,
1464            Visibility::BUILTIN_PRIVATE,
1465        );
1466        /* unary */
1467        let M = mono_q(TY_M, subtypeof(mono(MUTIZABLE)));
1468        let op_t = func1(M.clone(), proj(M, MUTABLE_MUT_TYPE)).quantify();
1469        self.register_builtin_erg_impl(OP_MUTATE, op_t, Const, Visibility::BUILTIN_PRIVATE);
1470        let op_t = {
1471            let S = Type::from(dict! { Field::public(OP_POS.into()) => fn0_met(Never, R.clone()) })
1472                .structuralize();
1473            func1(S, R.clone()).quantify()
1474        };
1475        self.register_builtin_erg_decl(OP_POS, op_t, Visibility::BUILTIN_PRIVATE);
1476        let op_t = {
1477            let S = Type::from(dict! { Field::public(OP_NEG.into()) => fn0_met(Never, R.clone()) })
1478                .structuralize();
1479            func1(S, R.clone()).quantify()
1480        };
1481        self.register_builtin_erg_decl(OP_NEG, op_t, Visibility::BUILTIN_PRIVATE);
1482        let op_t = {
1483            let S =
1484                Type::from(dict! { Field::public(OP_INVERT.into()) => fn0_met(Never, R.clone()) })
1485                    .structuralize();
1486            func1(S, R).quantify()
1487        };
1488        self.register_builtin_erg_decl(OP_INVERT, op_t, Visibility::BUILTIN_PRIVATE);
1489    }
1490}
erg_compiler/context/initialize/funcs.rs

erg_compiler/context/initialize/
funcs.rs
