Clean: add and change to block comment

compiler/erg_compiler/context/initialize/mod.rs

@@ -247,6 +247,7 @@ impl Context {
         let mut mutizable = Self::builtin_mono_trait("Mutizable", 2);
         mutizable.register_builtin_decl("MutType!", Type, Public);
         let pathlike = Self::builtin_mono_trait("PathLike", 2);
+        /* Readable */
         let mut readable = Self::builtin_mono_trait("Readable!", 2);
         let t_read = pr_met(
             ref_mut(mono_q("Self"), None),
@@ -260,6 +261,7 @@ impl Context {
             set! { subtypeof(mono_q("Self"), builtin_mono("Readable!")) },
         );
         readable.register_builtin_decl("read!", t_read, Public);
+        /* Show */
         let mut show = Self::builtin_mono_trait("Show", 2);
         let t_show = fn0_met(ref_(mono_q("Self")), Str);
         let t_show = quant(
@@ -267,6 +269,7 @@ impl Context {
             set! { subtypeof(mono_q("Self"), builtin_mono("Show")) },
         );
         show.register_builtin_decl("to_str", t_show, Public);
+        /* In */
         let mut in_ = Self::builtin_poly_trait("In", vec![PS::t("T", NonDefault)], 2);
         let params = vec![PS::t("T", NonDefault)];
         let input = Self::builtin_poly_trait("Input", params.clone(), 2);
@@ -278,6 +281,7 @@ impl Context {
             set! { static_instance("T", Type), subtypeof(mono_q("I"), builtin_poly("In", vec![ty_tp(mono_q("T"))])) },
         );
         in_.register_builtin_decl("__in__", op_t, Public);
+        /* Eq */
         // Erg does not have a trait equivalent to `PartialEq` in Rust
         // This means, Erg's `Float` cannot be compared with other `Float`
         // use `l - r < EPSILON` to check if two floats are almost equal
@@ -293,6 +297,7 @@ impl Context {
             },
         );
         eq.register_builtin_decl("__eq__", op_t, Public);
+        /* Partial_ord */
         let mut partial_ord =
             Self::builtin_poly_trait("PartialOrd", vec![PS::t("R", WithDefault)], 2);
         partial_ord.register_superclass(builtin_poly("Eq", vec![ty_tp(mono_q("R"))]), &eq);
@@ -309,6 +314,7 @@ impl Context {
             },
         );
         partial_ord.register_builtin_decl("__partial_cmp__", op_t, Public);
+        /* Ord */
         let mut ord = Self::builtin_mono_trait("Ord", 2);
         ord.register_superclass(builtin_poly("Eq", vec![ty_tp(builtin_mono("Self"))]), &eq);
         ord.register_superclass(
@@ -316,12 +322,14 @@ impl Context {
             &partial_ord,
         );
         // FIXME: poly trait
+        /* Num */
         let num = Self::builtin_mono_trait("Num", 2);
         /* vec![
             poly("Add", vec![]),
             poly("Sub", vec![]),
             poly("Mul", vec![]),
         ], */
+        /* Seq */
         let mut seq = Self::builtin_poly_trait("Seq", vec![PS::t("T", NonDefault)], 2);
         seq.register_superclass(builtin_poly("Output", vec![ty_tp(mono_q("T"))]), &output);
         let self_t = mono_q("Self");
@@ -342,6 +350,7 @@ impl Context {
         let r_bound = static_instance("R", Type);
         let params = vec![PS::t("R", WithDefault)];
         let ty_params = vec![ty_tp(mono_q("R"))];
+        /* Num */
         let mut add = Self::builtin_poly_trait("Add", params.clone(), 2);
         // Rについて共変(__add__の型とは関係ない)
         add.register_superclass(builtin_poly("Output", vec![ty_tp(mono_q("R"))]), &output);
@@ -354,6 +363,7 @@ impl Context {
         let op_t = quant(op_t, set! {r_bound.clone(), self_bound});
         add.register_builtin_decl("__add__", op_t, Public);
         add.register_builtin_decl("Output", Type, Public);
+        /* Sub */
         let mut sub = Self::builtin_poly_trait("Sub", params.clone(), 2);
         sub.register_superclass(builtin_poly("Output", vec![ty_tp(mono_q("R"))]), &output);
         let op_t = fn1_met(
@@ -365,6 +375,7 @@ impl Context {
         let op_t = quant(op_t, set! {r_bound.clone(), self_bound});
         sub.register_builtin_decl("__sub__", op_t, Public);
         sub.register_builtin_decl("Output", Type, Public);
+        /* Mul */
         let mut mul = Self::builtin_poly_trait("Mul", params.clone(), 2);
         mul.register_superclass(builtin_poly("Output", vec![ty_tp(mono_q("R"))]), &output);
         let op_t = fn1_met(
@@ -376,6 +387,7 @@ impl Context {
         let op_t = quant(op_t, set! {r_bound.clone(), self_bound});
         mul.register_builtin_decl("__mul__", op_t, Public);
         mul.register_builtin_decl("Output", Type, Public);
+        /* Div */
         let mut div = Self::builtin_poly_trait("Div", params, 2);
         div.register_superclass(builtin_poly("Output", vec![ty_tp(mono_q("R"))]), &output);
         let op_t = fn1_met(mono_q("Self"), r, mono_proj(mono_q("Self"), "Output"));
@@ -443,7 +455,7 @@ impl Context {
     }
 
     fn init_builtin_classes(&mut self) {
-        // *** Obj *** //
+        /* Obj */
         let mut obj = Self::builtin_mono_class("Obj", 2);
         let t = fn0_met(mono_q("Self"), mono_q("Self"));
         let t = quant(t, set! {subtypeof(mono_q("Self"), builtin_mono("Obj"))});
@@ -466,7 +478,7 @@ impl Context {
         obj_mutizable.register_builtin_const("MutType!", ValueObj::builtin_t(builtin_mono("Obj!")));
         obj.register_trait(Obj, builtin_mono("Mutizable"), obj_mutizable);
 
-        // *** Float *** //
+        /* Float */
         let mut float = Self::builtin_mono_class("Float", 2);
         float.register_superclass(Obj, &obj);
         // TODO: support multi platform
@@ -516,7 +528,7 @@ impl Context {
         float_show.register_builtin_impl("to_str", t, Immutable, Public);
         float.register_trait(Float, builtin_mono("Show"), float_show);
 
-        // *** Ratio *** //
+        /* Ratio */
         // TODO: Int, Nat, Boolの継承元をRatioにする(今はFloat)
         let mut ratio = Self::builtin_mono_class("Ratio", 2);
         ratio.register_superclass(Obj, &obj);
@@ -567,7 +579,7 @@ impl Context {
         ratio_show.register_builtin_impl("to_str", t, Immutable, Public);
         ratio.register_trait(Ratio, builtin_mono("Show"), ratio_show);
 
-        // *** Int *** //
+        /* Int */
         let mut int = Self::builtin_mono_class("Int", 2);
         int.register_superclass(Float, &float); // TODO: Float -> Ratio
         int.register_marker_trait(builtin_mono("Num"));
@@ -616,7 +628,7 @@ impl Context {
         int.register_builtin_impl("Real", Int, Const, Public);
         int.register_builtin_impl("Imag", Int, Const, Public);
 
-        // *** Nat *** //
+        /* Nat */
         let mut nat = Self::builtin_mono_class("Nat", 10);
         nat.register_superclass(Int, &int);
         // class("Rational"),
@@ -666,7 +678,7 @@ impl Context {
         nat.register_builtin_impl("Real", Nat, Const, Public);
         nat.register_builtin_impl("Imag", Nat, Const, Public);
 
-        // *** Bool *** //
+        /* Bool */
         let mut bool_ = Self::builtin_mono_class("Bool", 10);
         bool_.register_superclass(Nat, &nat);
         // class("Rational"),
@@ -702,6 +714,7 @@ impl Context {
         let mut bool_show = Self::builtin_methods("Show", 1);
         bool_show.register_builtin_impl("to_str", fn0_met(Bool, Str), Immutable, Public);
         bool_.register_trait(Bool, builtin_mono("Show"), bool_show);
+        /* Str */
         let mut str_ = Self::builtin_mono_class("Str", 10);
         str_.register_superclass(Obj, &obj);
         str_.register_marker_trait(builtin_mono("Ord"));
@@ -730,7 +743,6 @@ impl Context {
             Immutable,
             Public,
         );
-        // *** Str *** //
         let mut str_eq = Self::builtin_methods("Eq", 2);
         str_eq.register_builtin_impl("__eq__", fn1_met(Str, Str, Bool), Const, Public);
         str_.register_trait(Str, builtin_poly("Eq", vec![ty_tp(Str)]), str_eq);
@@ -752,6 +764,7 @@ impl Context {
         let mut str_show = Self::builtin_methods("Show", 1);
         str_show.register_builtin_impl("to_str", fn0_met(Str, Str), Immutable, Public);
         str_.register_trait(Str, builtin_mono("Show"), str_show);
+        /* Type */
         let mut type_ = Self::builtin_mono_class("Type", 2);
         type_.register_superclass(Obj, &obj);
         type_.register_builtin_impl("mro", array(Type, TyParam::erased(Nat)), Immutable, Public);
@@ -784,7 +797,6 @@ impl Context {
         let module_t = module(mono_q_tp("Path"));
         let mut module = Self::builtin_poly_class("Module", vec![PS::named_nd("Path", Str)], 2);
         module.register_superclass(g_module_t.clone(), &generic_module);
-
         /* Array */
         let mut array_ =
             Self::builtin_poly_class("Array", vec![PS::t_nd("T"), PS::named_nd("N", Nat)], 10);
@@ -875,8 +887,7 @@ impl Context {
         let mut set_show = Self::builtin_methods("Show", 1);
         set_show.register_builtin_impl("to_str", fn0_met(set_t.clone(), Str), Immutable, Public);
         set_.register_trait(set_t, builtin_mono("Show"), set_show);
-
+        /* Bytes */
-        // *** Bytes *** //
         let mut bytes = Self::builtin_mono_class("Bytes", 2);
         bytes.register_superclass(Obj, &obj);
         // FIXME: replace to Tuple Ts (e.g. Tuple [Int, Str])
@@ -915,8 +926,7 @@ impl Context {
             ),
             tuple1_eq,
         );
-
+        /* Tuple(n) */
-        // *** Tuple(n) *** //
         let mut tuple2 = Self::builtin_poly_class("Tuple2", vec![PS::t_nd("A"), PS::t_nd("B")], 2);
         tuple2.register_superclass(builtin_mono("Tuple"), &tuple_);
         let mut tuple2_eq = Self::builtin_methods("Eq", 2);
@@ -1333,15 +1343,13 @@ impl Context {
             ),
             tuple8_eq,
         );
-
+        /* record */
-        // *** record *** //
         let mut record = Self::builtin_mono_class("Record", 2);
         record.register_superclass(Obj, &obj);
         let mut record_type = Self::builtin_mono_class("RecordType", 2);
         record_type.register_superclass(builtin_mono("Record"), &record);
         record_type.register_superclass(builtin_mono("Type"), &type_);
-
+        /* Float_mut */
-        // *** Float_mut *** //
         let mut float_mut = Self::builtin_mono_class("Float!", 2);
         float_mut.register_superclass(Float, &float);
         let mut float_mut_mutable = Self::builtin_methods("Mutable", 2);
@@ -1360,8 +1368,7 @@ impl Context {
             builtin_mono("Mutable"),
             float_mut_mutable,
         );
-
+        /* Ratio_mut */
-        // *** Ratio_mut *** //
         let mut ratio_mut = Self::builtin_mono_class("Ratio!", 2);
         ratio_mut.register_superclass(Ratio, &ratio);
         let mut ratio_mut_mutable = Self::builtin_methods("Mutable", 2);
@@ -1388,8 +1395,7 @@ impl Context {
             builtin_mono("Mutable"),
             ratio_mut_mutable,
         );
-
+        /* Int_mut */
-        // *** Int_mut *** //
         let mut int_mut = Self::builtin_mono_class("Int!", 2);
         int_mut.register_superclass(Int, &int);
         int_mut.register_superclass(builtin_mono("Float!"), &float_mut);
@@ -1412,8 +1418,7 @@ impl Context {
         let mut nat_mut = Self::builtin_mono_class("Nat!", 2);
         nat_mut.register_superclass(Nat, &nat);
         nat_mut.register_superclass(builtin_mono("Int!"), &int_mut);
-
+        /* Nat_mut */
-        // *** Nat_mut *** //
         let mut nat_mut_mutable = Self::builtin_methods("Mutable", 2);
         nat_mut_mutable.register_builtin_const("ImmutType", ValueObj::builtin_t(Nat));
         let f_t = kw("f", func(vec![kw("old", Nat)], None, vec![], Nat));
@@ -1430,8 +1435,7 @@ impl Context {
             builtin_mono("Mutable"),
             nat_mut_mutable,
         );
-
+        /* Bool_mut */
-        // *** Bool_mut *** //
         let mut bool_mut = Self::builtin_mono_class("Bool!", 2);
         bool_mut.register_superclass(Bool, &bool_);
         bool_mut.register_superclass(builtin_mono("Nat!"), &nat_mut);
@@ -1451,8 +1455,7 @@ impl Context {
             builtin_mono("Mutable"),
             bool_mut_mutable,
         );
-
+        /* Str_mut */
-        // *** Str_mut *** //
         let mut str_mut = Self::builtin_mono_class("Str!", 2);
         str_mut.register_superclass(Str, &str_);
         let mut str_mut_mutable = Self::builtin_methods("Mutable", 2);
@@ -1471,8 +1474,7 @@ impl Context {
             builtin_mono("Mutable"),
             str_mut_mutable,
         );
-
+        /* File_mut */
-        // *** File_mut *** //
         let mut file_mut = Self::builtin_mono_class("File!", 2);
         let mut file_mut_readable = Self::builtin_methods("Readable!", 1);
         file_mut_readable.register_builtin_impl(
@@ -1492,8 +1494,7 @@ impl Context {
             builtin_mono("Readable!"),
             file_mut_readable,
         );
-
+        /* Array_mut */
-        // *** Array_mut *** //
         let array_t = builtin_poly("Array", vec![ty_tp(mono_q("T")), mono_q_tp("N")]);
         let array_mut_t = builtin_poly("Array!", vec![ty_tp(mono_q("T")), mono_q_tp("N")]);
         let mut array_mut_ = Self::builtin_poly_class(
@@ -1555,8 +1556,7 @@ impl Context {
             builtin_mono("Mutable"),
             array_mut_mutable,
         );
-
+        /* Set_mut */
-        // *** Set_mut *** //
         let set_t = builtin_poly("Set", vec![ty_tp(mono_q("T")), mono_q_tp("N")]);
         let set_mut_t = builtin_poly("Set!", vec![ty_tp(mono_q("T")), mono_q_tp("N")]);
         let mut set_mut_ = Self::builtin_poly_class(
@@ -1609,8 +1609,7 @@ impl Context {
         let mut set_mut_mutable = Self::builtin_methods("Mutable", 2);
         set_mut_mutable.register_builtin_impl("update!", t, Immutable, Public);
         set_mut_.register_trait(set_mut_t.clone(), builtin_mono("Mutable"), set_mut_mutable);
-
+        /* Range */
-        // *** Range *** //
         let range_t = builtin_poly("Range", vec![TyParam::t(mono_q("T"))]);
         let mut range = Self::builtin_poly_class("Range", vec![PS::t_nd("T")], 2);
         range.register_superclass(Obj, &obj);
@@ -1627,15 +1626,13 @@ impl Context {
             builtin_poly("Eq", vec![ty_tp(range_t.clone())]),
             range_eq,
         );
-
+        /* Proc */
-        // *** Proc *** //
         let mut proc = Self::builtin_mono_class("Proc", 2);
         proc.register_superclass(Obj, &obj);
         let mut named_proc = Self::builtin_mono_class("NamedProc", 2);
         named_proc.register_superclass(Obj, &obj);
         named_proc.register_marker_trait(builtin_mono("Named"));
-
+        /* Func */
-        // *** Func *** //
         let mut func = Self::builtin_mono_class("Func", 2);
         func.register_superclass(builtin_mono("Proc"), &proc);
         let mut named_func = Self::builtin_mono_class("NamedFunc", 2);