Implement Array/SetWithLength

compiler/erg_compiler/codegen.rs

@@ -1700,6 +1700,15 @@ impl CodeGenerator {
                         self.stack_dec_n(len - 1);
                     }
                 }
+                Array::WithLength(arr) => {
+                    self.emit_expr(*arr.elem);
+                    self.write_instr(BUILD_LIST);
+                    self.write_arg(1u8);
+                    self.emit_expr(*arr.len);
+                    self.write_instr(BINARY_MULTIPLY);
+                    self.write_arg(0);
+                    self.stack_dec();
+                }
                 other => todo!("{other}"),
             },
             // TODO: tuple comprehension
@@ -1733,7 +1742,11 @@ impl CodeGenerator {
                         self.stack_dec_n(len - 1);
                     }
                 }
-                crate::hir::Set::WithLength(_) => todo!(),
+                crate::hir::Set::WithLength(st) => {
+                    self.emit_expr(*st.elem);
+                    self.write_instr(BUILD_SET);
+                    self.write_arg(1u8);
+                }
             },
             Expr::Record(rec) => self.emit_record(rec),
             Expr::Code(code) => {

compiler/erg_compiler/context/tyvar.rs

@@ -671,6 +671,13 @@ impl Context {
                     }
                     Ok(())
                 }
+                hir::Array::WithLength(arr) => {
+                    let loc = arr.loc();
+                    arr.t = self.deref_tyvar(mem::take(&mut arr.t), Covariant, loc)?;
+                    self.resolve_expr_t(&mut arr.elem)?;
+                    self.resolve_expr_t(&mut arr.len)?;
+                    Ok(())
+                }
                 _ => todo!(),
             },
             hir::Expr::Tuple(tuple) => match tuple {
@@ -683,12 +690,20 @@ impl Context {
             },
             hir::Expr::Set(set) => match set {
                 hir::Set::Normal(st) => {
+                    let loc = st.loc();
+                    st.t = self.deref_tyvar(mem::take(&mut st.t), Covariant, loc)?;
                     for elem in st.elems.pos_args.iter_mut() {
                         self.resolve_expr_t(&mut elem.expr)?;
                     }
                     Ok(())
                 }
-                hir::Set::WithLength(_) => todo!(),
+                hir::Set::WithLength(st) => {
+                    let loc = st.loc();
+                    st.t = self.deref_tyvar(mem::take(&mut st.t), Covariant, loc)?;
+                    self.resolve_expr_t(&mut st.elem)?;
+                    self.resolve_expr_t(&mut st.len)?;
+                    Ok(())
+                }
             },
             hir::Expr::Dict(_dict) => {
                 todo!()

compiler/erg_compiler/link.rs

@@ -59,6 +59,10 @@ impl<'a> Linker<'a> {
                         self.replace_import(&mut elem.expr);
                     }
                 }
+                Array::WithLength(arr) => {
+                    self.replace_import(&mut arr.elem);
+                    self.replace_import(&mut arr.len);
+                }
                 _ => todo!(),
             },
             Expr::Tuple(tuple) => match tuple {
@@ -74,9 +78,11 @@ impl<'a> Linker<'a> {
                         self.replace_import(&mut elem.expr);
                     }
                 }
-                Set::WithLength(_) => todo!(),
+                Set::WithLength(st) => {
+                    self.replace_import(&mut st.elem);
+                    self.replace_import(&mut st.len);
+                }
             },
-
             Expr::Dict(_dict) => {
                 todo!()
             }

compiler/erg_compiler/ownercheck.rs

@@ -156,6 +156,10 @@ impl OwnershipChecker {
                         self.check_expr(&a.expr, ownership, false);
                     }
                 }
+                Array::WithLength(arr) => {
+                    self.check_expr(&arr.elem, ownership, false);
+                    self.check_expr(&arr.len, ownership, false);
+                }
                 _ => todo!(),
             },
             Expr::Tuple(tuple) => match tuple {
@@ -182,12 +186,15 @@ impl OwnershipChecker {
                 }
             }
             Expr::Set(set) => match set {
-                hir::Set::Normal(set) => {
+                hir::Set::Normal(st) => {
-                    for a in set.elems.pos_args.iter() {
+                    for a in st.elems.pos_args.iter() {
                         self.check_expr(&a.expr, ownership, false);
                     }
                 }
-                hir::Set::WithLength(_) => todo!(),
+                hir::Set::WithLength(st) => {
+                    self.check_expr(&st.elem, ownership, false);
+                    self.check_expr(&st.len, ownership, false);
+                }
             },
             // TODO: capturing
             Expr::Lambda(lambda) => {

compiler/erg_compiler/std/_erg_std_prelude.py

@@ -4,5 +4,12 @@ def in_operator(x, y):
             return True
         # TODO: trait check
         return False
+    elif type(y) == list or type(y) == set:
+        # FIXME:
+        type_check = in_operator(x[0], y[0])
+        len_check = len(x) == len(y)
+        return type_check and len_check
+    elif type(y) == dict:
+        NotImplemented
     else:
         return x in y