refactor: rename package and update imports to use new structure; add list comprehension support

Author: oboard

README.md

@@ -1,8 +1,8 @@
 # MoonBit Eval
 
-[![Version](https://img.shields.io/badge/dynamic/json?url=https%3A//mooncakes.io/assets/oboard/moonbit-eval/resource.json&query=%24.meta_info.version&label=mooncakes&color=yellow)](https://mooncakes.io/docs/oboard/moonbit-eval)
-[![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/oboard/moonbit-eval/check.yaml)](https://github.com/oboard/moonbit-eval/actions/workflows/check.yaml)
-[![License](https://img.shields.io/github/license/oboard/moonbit-eval)](https://github.com/oboard/moonbit-eval/blob/main/LICENSE)
+[![Version](https://img.shields.io/badge/dynamic/json?url=https%3A//mooncakes.io/assets/oboard/eval/resource.json&query=%24.meta_info.version&label=mooncakes&color=yellow)](https://mooncakes.io/docs/oboard/eval)
+[![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/oboard/eval/check.yaml)](https://github.com/oboard/eval/actions/workflows/check.yaml)
+[![License](https://img.shields.io/github/license/oboard/eval)](https://github.com/oboard/eval/blob/main/LICENSE)
 
 ## Demo
 🚀 **[REPL Demo](https://github.com/oboard/moonbit-repl/releases/)**

example/moon.pkg

@@ -1,5 +1,5 @@
 import {
-  "oboard/moonbit-eval" @eval,
+  "oboard/eval" @eval,
 }
 
 options(

example/pkg.generated.mbti

@@ -1,5 +1,5 @@
 // Generated using `moon info`, DON'T EDIT IT
-package "oboard/moonbit-eval/example"
+package "oboard/eval/example"
 
 // Values
 

export.mbt

@@ -23,7 +23,7 @@ pub fn eval_result_to_string(result : EvalResult) -> String {
 
 ///|
 pub fn code_to_ast(code : String) -> String {
-  match @front.parse_code_to_impl(code) {
+  match @front.parse_code_to_impl(@core.normalize_v092_syntax(code)) {
     Ok(i) => i.to_json().stringify()
     Err(msg) => msg
   }

interpreter/core/expression_visitors.mbt

@@ -134,12 +134,101 @@ fn ClosureInterpreter::visit_tuple(
   Tuple(evaluated_values)
 }
 
+///|
+fn ClosureInterpreter::syntax_iterable_to_iter(
+  self : ClosureInterpreter,
+  expr : @syntax.Expr,
+) -> Iter[RuntimeValue] raise ControlFlow {
+  match expr {
+    Infix(op~, lhs~, rhs~, ..) =>
+      match op.name {
+        Ident(name="..<") => {
+          let start_val = self.visit(lhs)
+          let end_val = self.visit(rhs)
+          match (start_val, end_val) {
+            (Int(start, ..), Int(end, ..)) =>
+              start.until(end).map(fn(i) { Int(i, raw=None) })
+            _ => Iter::empty()
+          }
+        }
+        Ident(name="..=") => {
+          let start_val = self.visit(lhs)
+          let end_val = self.visit(rhs)
+          match (start_val, end_val) {
+            (Int(start, ..), Int(end, ..)) =>
+              start.until(end, inclusive=true).map(fn(i) { Int(i, raw=None) })
+            _ => Iter::empty()
+          }
+        }
+        _ => self.visit_iterable_expr(expr)
+      }
+    _ => self.visit_iterable_expr(expr)
+  }
+}
+
+///|
+fn ClosureInterpreter::visit_iterable_expr(
+  self : ClosureInterpreter,
+  expr : @syntax.Expr,
+) -> Iter[RuntimeValue] raise ControlFlow {
+  match self.visit(expr) {
+    Iter(iter) => iter
+    value =>
+      match self.method_call(value, "iter", @list.new()) {
+        Iter(iter) => iter
+        _ => self.error("iter method not found")
+      }
+  }
+}
+
+///|
+fn ClosureInterpreter::visit_for_each_as_array(
+  self : ClosureInterpreter,
+  binders : @list.List[@syntax.Binder?],
+  expr : @syntax.Expr,
+  body : @syntax.Expr,
+) -> RuntimeValue raise ControlFlow {
+  let result : Array[RuntimeValue] = []
+  let binder_count = binders.length()
+  for value in self.syntax_iterable_to_iter(expr) {
+    self.push_scope(RuntimeLocation::ControlFlow("list comprehension"))
+    defer self.pop_scope()
+    match binders {
+      @list.More(Some(binder), tail=@list.Empty) =>
+        self.current_pkg.env.set(binder.name, value)
+      @list.More(
+        Some(binder1),
+        tail=@list.More(Some(binder2), tail=@list.Empty)
+      ) =>
+        match value {
+          Tuple([first, second]) => {
+            self.current_pkg.env.set(binder1.name, first)
+            self.current_pkg.env.set(binder2.name, second)
+          }
+          _ => ()
+        }
+      _ => if binder_count == 0 { () }
+    }
+    let value = self.visit(body) catch {
+      Continue(_) => continue
+      e => raise e
+    }
+    result.push(value)
+  }
+  Array(result)
+}
+
 ///|
 /// 处理数组表达式
 fn ClosureInterpreter::visit_array(
   self : ClosureInterpreter,
   exprs : @list.List[@syntax.Expr],
 ) -> RuntimeValue raise ControlFlow {
+  match exprs {
+    @list.More(ForEach(binders~, expr~, body~, ..), tail=@list.Empty) =>
+      return self.visit_for_each_as_array(binders, expr, body)
+    _ => ()
+  }
   let result_values = []
   for expr in exprs {
     match expr {
@@ -190,6 +279,40 @@ fn ClosureInterpreter::call_struct_constr(
   }
 }
 
+///|
+fn ClosureInterpreter::call_struct_constr_with_type_name(
+  self : ClosureInterpreter,
+  type_name : @syntax.TypeName,
+  constr_name : String,
+  field_values : @list.List[@syntax.Argument],
+) -> RuntimeValue? raise ControlFlow {
+  self.with_ident(type_name.name, (pkg, name) => {
+    let ty = pkg.find_static_type(name)
+    if pkg.struct_constrs.get(name) is Some(method_name) {
+      let method_name = if constr_name == "" {
+        method_name
+      } else {
+        constr_name
+      }
+      Some(self.execute_static_method_call(ty, method_name, field_values))
+    } else {
+      None
+    }
+  })
+}
+
+///|
+fn ClosureInterpreter::constructor_runtime_package(
+  self : ClosureInterpreter,
+  constr : @syntax.Constructor,
+) -> RuntimePackage {
+  match constr.extra_info {
+    Package(pkg_name) => self.find_pkg(pkg_name)
+    TypeName(type_name) => self.with_ident(type_name.name, (pkg, _) => pkg)
+    NoExtraInfo => self.current_pkg
+  }
+}
+
 ///|
 /// 处理函数调用
 fn ClosureInterpreter::visit_apply(
@@ -203,16 +326,15 @@ fn ClosureInterpreter::visit_apply(
       // 处理构造函数调用，如 Some(5)
       Constr(constr~, ..) => {
         match constr.extra_info {
-          TypeName(type_name) => {
-            let constr_type_name = match type_name.name {
-              Ident(name~) => name
-              Dot(id~, ..) => id
-            }
-            if self.call_struct_constr(None, constr_type_name, args)
+          TypeName(type_name) =>
+            if self.call_struct_constr_with_type_name(
+                type_name,
+                constr.name.name,
+                args,
+              )
               is Some(result) {
               return result
             }
-          }
           Package(pkg_name) if self.call_struct_constr(
               Some(pkg_name),
               constr.name.name,
@@ -245,9 +367,10 @@ fn ClosureInterpreter::visit_apply(
           })
           .to_array()
         let constr_name = constr.name.name
+        let pkg = self.constructor_runtime_package(constr)
         Constructor({
           val: { name: constr_name, fields },
-          ty: self.current_pkg.find_static_type(constr_name),
+          ty: pkg.find_static_type(constr_name),
         })
       }
       // 处理静态方法调用，如 Bool::default()

interpreter/core/interpreter.mbt

@@ -72,6 +72,7 @@ pub fn ClosureInterpreter::top_eval(
   self : ClosureInterpreter,
   code : String,
 ) -> Unit {
+  let code = normalize_v092_syntax(code)
   let (impls, _diagnostics) = @moonbitlang/parser.parse_string(
     code,
     parser=Handrolled,
@@ -793,13 +794,11 @@ pub fn ClosureInterpreter::visit(
       let name = constr.name.name
       match constr.extra_info {
         TypeName(ty_name) =>
-          self.with_ident(ty_name.name, (_env, _name) => {
-            self.current_pkg.cons(name, [])
-          })
+          self.with_ident(ty_name.name, (pkg, _name) => pkg.cons(name, []))
         Package(pkg) =>
           self.find_pkg(pkg).env
           .find(name)
-          .unwrap_or(self.current_pkg.cons(name, []))
+          .unwrap_or(self.find_pkg(pkg).cons(name, []))
         _ =>
           self.current_pkg.env
           .find(name)

interpreter/core/moon.pkg

@@ -16,5 +16,5 @@ import {
   "moonbitlang/parser/tokens",
   "moonbitlang/parser/attribute",
   "moonbitlang/x/fs",
-  "oboard/moonbit-eval/interpreter/host" @host,
+  "oboard/eval/interpreter/host" @host,
 }

interpreter/core/pattern_matching.mbt

@@ -151,6 +151,39 @@ fn format_pattern(pattern : @syntax.Pattern) -> String {
   }
 }
 
+///|
+fn ClosureInterpreter::constructor_pattern_matches_type(
+  self : ClosureInterpreter,
+  value_type : RuntimeType,
+  constr : @syntax.Constructor,
+) -> Bool {
+  match constr.extra_info {
+    TypeName(type_name) =>
+      self.with_ident(type_name.name, (pkg, name) => {
+        let expected_type = pkg.find_static_type(name)
+        if value_type == expected_type {
+          true
+        } else {
+          match (value_type, expected_type) {
+            (Any, _) | (_, Any) => true
+            (Object(name=value_name, ..), Object(name=expected_name, ..)) =>
+              value_name == expected_name
+            (Name(name=value_name, ..), Name(name=expected_name, ..)) =>
+              value_name == expected_name
+            _ => false
+          }
+        }
+      })
+    Package(pkg_name) =>
+      match value_type {
+        Object(pkg~, ..) => pkg.name == self.find_pkg(pkg_name).name
+        Name(pkg~, ..) => pkg.name == self.find_pkg(pkg_name).name
+        _ => false
+      }
+    NoExtraInfo => true
+  }
+}
+
 ///|
 /// 检查模式是否匹配给定的运行时值
 pub fn ClosureInterpreter::match_case(
@@ -295,8 +328,9 @@ pub fn ClosureInterpreter::match_case(
     // Constructor模式匹配
     Constr(constr~, args=pattern_args, ..) =>
       match value {
-        Constructor({ val: { name, fields }, .. }) =>
-          if name == constr.name.name {
+        Constructor({ val: { name, fields }, ty }) =>
+          if name == constr.name.name &&
+            self.constructor_pattern_matches_type(ty, constr) {
             // 检查参数匹配
             match pattern_args {
               // 无参数的构造函数，只需要名称匹配

interpreter/core/pkg.generated.mbti

@@ -1,5 +1,5 @@
 // Generated using `moon info`, DON'T EDIT IT
-package "oboard/moonbit-eval/interpreter/core"
+package "oboard/eval/interpreter/core"
 
 import {
   "moonbitlang/core/bigint",
@@ -46,6 +46,8 @@ pub fn manualUnescape(StringView, StringBuilder) -> Unit
 
 pub let map_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]
 
+pub fn normalize_v092_syntax(String) -> String
+
 pub let option_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]
 
 pub fn parse_code_to_expr(String) -> Result[@syntax.Expr, String]