feat: remove eval function and update related tests; enhance pattern matching and runtime value operations

Author: oboard

interpreter/core/builtin.mbt

@@ -5,7 +5,6 @@ let core_stubs : Map[String, String] = {
   "println_mono": "%println",
   "println": "%println_mono",
   "typeof": "%typeof",
-  "eval": "%eval",
   "require": "%require",
   "panic": "%panic",
   "abort": "%abort",
@@ -20,7 +19,6 @@ let builtin_embedded_code : Map[String, RuntimeFunction] = {
   "%abort": abort_fn,
   "%panic": panic_fn,
   "%typeof": typeof_fn,
-  "%eval": eval_fn,
   "%require": require_fn,
   "%println_mono": println_mono_fn,
   "%ignore": ignore_fn,
@@ -251,20 +249,6 @@ let typeof_fn : RuntimeFunction = ctx => {
   }
 }
 
-///|
-let eval_fn : RuntimeFunction = ctx => {
-  match ctx.args {
-    [{ val: String(code), .. }] => {
-      let expr = parse_code_to_expr(code)
-      match expr {
-        Ok(expr) => ctx.context.visit(expr)
-        Err(error) => raise Raise(String(error))
-      }
-    }
-    _ => Unit
-  }
-}
-
 ///|
 let require_fn : RuntimeFunction = ctx => {
   match ctx.args {

interpreter/core/functions.mbt

@@ -163,17 +163,21 @@ fn ClosureInterpreter::bind_runtime_parameters(
           _ => break
         }
       (@list.More(param, tail=rest_params), @list.More(arg, tail=rest_args)) => {
-        let value = arg.val
         match param {
           // 位置参数：直接绑定参数值
-          Positional(binder={ name, .. }, ..)
+          Positional(binder={ name, .. }, ty~)
           // 标签参数：绑定带标签的参数值
-          | Labelled(binder={ name, .. }, ..)
+          | Labelled(binder={ name, .. }, ty~)
           // 问号可选参数：绑定参数值
-          | QuestionOptional(binder={ name, .. }, ..)
+          | QuestionOptional(binder={ name, .. }, ty~)
           // 可选参数：当有参数提供时绑定参数值
-          | Optional(binder={ name, .. }, ..) =>
+          | Optional(binder={ name, .. }, ty~, ..) => {
+            let value = match ty {
+              Some(ty) => arg.val.overload_literal(extract_type_name(ty))
+              None => arg.val
+            }
             self.current_pkg.env.set(name, value)
+          }
           // 丢弃位置参数：不绑定到任何变量
           DiscardPositional(..) => ()
         }

interpreter/core/interpreter.mbt

@@ -15,6 +15,8 @@ pub(all) struct ClosureInterpreter {
 ///|
 pub fn ClosureInterpreter::new() -> ClosureInterpreter {
   let main = RuntimePackage::new("main")
+  main.deps.set("builtin", moonbitlang_core_builtin_module)
+  main.deps.set("moonbitlang/core/builtin", moonbitlang_core_builtin_module)
   main.deps.set("fs", fs_package)
   let self = {
     extern_fns: {},
@@ -24,6 +26,7 @@ pub fn ClosureInterpreter::new() -> ClosureInterpreter {
     current_pkg: main,
     call_stack: [],
   }
+  self.load_package(moonbitlang_core_builtin_module)
   self.load_package(main)
   self
 }

interpreter/core/method_execution.mbt

@@ -88,14 +88,18 @@ fn ClosureInterpreter::call_by_name(
     .to_array(),
   )
   self.with_ident(long_ident, (pkg, name) => {
-    let name = pkg.find_stub(name)
     match self.lookup_function(pkg, name) {
       FunctionLookupResult::DirectFunction(func) =>
         self.execute_embedded_function(func, evaluated_args)
       FunctionLookupResult::NotFound =>
-        self.error(
-          "execute_function_by_name method @\{pkg.name}.\{name} not found",
-        )
+        match self.lookup_function(pkg, pkg.find_stub(name)) {
+          FunctionLookupResult::DirectFunction(func) =>
+            self.execute_embedded_function(func, evaluated_args)
+          FunctionLookupResult::NotFound =>
+            self.error(
+              "execute_function_by_name method @\{pkg.name}.\{name} not found",
+            )
+        }
     }
   })
 }

interpreter/core/pattern_matching.mbt

@@ -191,6 +191,83 @@ pub fn ClosureInterpreter::match_case(
   value : RuntimeValue,
   pattern : @syntax.Pattern,
 ) -> Bool {
+  fn match_array_pattern_list(
+    patterns : @list.List[@syntax.ArrayPattern],
+    values : Array[RuntimeValue],
+    start : Int,
+  ) -> Bool {
+    let mut index = start
+    for state = patterns {
+      match state {
+        @list.More(array_pat, tail=pat_tail) => {
+          if index >= values.length() {
+            return false
+          }
+          match array_pat {
+            @syntax.ArrayPattern::Pattern(pat) =>
+              if !self.match_case(values[index], pat) {
+                return false
+              }
+            _ => return false
+          }
+          index += 1
+          continue pat_tail
+        }
+        @list.Empty => break
+      }
+    }
+    true
+  }
+
+  fn map_pattern_key(key : @syntax.Constant) -> RuntimeValue? {
+    match key {
+      String(str) => Some(String(str))
+      Int(str) =>
+        Some(Int(@string.parse_int(str), raw=None)) catch {
+          _ => None
+        }
+      _ => None
+    }
+  }
+
+  fn json_pattern_key(key : @syntax.Constant) -> String? {
+    match key {
+      String(str) => Some(str)
+      _ => None
+    }
+  }
+
+  fn match_json_constructor(
+    json : Json,
+    constr_name : String,
+    pattern_args : @list.List[@syntax.ConstrPatArg]?,
+  ) -> Bool {
+    fn match_unary(value : RuntimeValue) -> Bool {
+      match pattern_args {
+        Some(@list.More(arg, tail=@list.Empty)) =>
+          self.match_case(value, arg.pat)
+        _ => false
+      }
+    }
+    match (json, constr_name, pattern_args) {
+      (Null, "Null", None) => true
+      (True, "True", None) => true
+      (False, "False", None) => true
+      (String(str), "String", _) => match_unary(String(str))
+      (Number(num, ..), "Number", _) => match_unary(Double(num))
+      (Array(arr), "Array", _) =>
+        match_unary(Array(arr.map(item => Json(item))))
+      (Object(obj), "Object", _) => {
+        let map : Map[RuntimeValue, RuntimeValue] = {}
+        for key, item in obj {
+          map.set(String(key), Json(item))
+        }
+        match_unary(Map(map))
+      }
+      _ => false
+    }
+  }
+
   match pattern {
     // 变量模式匹配（总是匹配，并绑定变量）
     Var({ name, .. }) => {
@@ -275,26 +352,38 @@ pub fn ClosureInterpreter::match_case(
               if values.length() != patterns.length() {
                 return false
               }
-              let mut index = 0
-              for state = patterns {
-                match state {
-                  @list.More(array_pat, tail=pat_tail) => {
-                    match array_pat {
-                      @syntax.ArrayPattern::Pattern(pat) =>
-                        if !self.match_case(values[index], pat) {
-                          return false
-                        }
-                      _ => return false // 其他数组模式暂不支持
-                    }
-                    index = index + 1
-                    continue pat_tail
-                  }
-                  @list.Empty => break
-                }
+              match_array_pattern_list(patterns, values, 0)
+            }
+            @syntax.ArrayPatterns::Open(left, right, binder) => {
+              let left_len = left.length()
+              let right_len = right.length()
+              if values.length() < left_len + right_len {
+                return false
+              }
+              if !match_array_pattern_list(left, values, 0) {
+                return false
+              }
+              if !match_array_pattern_list(
+                  right,
+                  values,
+                  values.length() - right_len,
+                ) {
+                return false
+              }
+              let rest_view = values[left_len:values.length() - right_len]
+              let rest = Array::new(capacity=rest_view.length())
+              for item in rest_view {
+                rest.push(item)
+              }
+              match binder {
+                @syntax.DotDotBinder::Binder(binder) =>
+                  self.current_pkg.env.set(binder.name, Array(rest))
+                @syntax.DotDotBinder::BinderAs(binder) =>
+                  self.current_pkg.env.set(binder.name, Array(rest))
+                _ => ()
               }
               true
             }
-            _ => false // 其他数组模式暂不支持
           }
         _ => false
       }
@@ -320,6 +409,42 @@ pub fn ClosureInterpreter::match_case(
         }
         _ => false
       }
+    Map(elems~, ..) =>
+      match value {
+        Map(values) => {
+          for elem in elems {
+            match map_pattern_key(elem.key) {
+              Some(key) =>
+                match values.get(key) {
+                  Some(item) =>
+                    if !self.match_case(item, elem.pat) {
+                      return false
+                    }
+                  None => return false
+                }
+              None => return false
+            }
+          }
+          true
+        }
+        Json(Object(values)) => {
+          for elem in elems {
+            match json_pattern_key(elem.key) {
+              Some(key) =>
+                match values.get(key) {
+                  Some(item) =>
+                    if !self.match_case(Json(item), elem.pat) {
+                      return false
+                    }
+                  None => return false
+                }
+              None => return false
+            }
+          }
+          true
+        }
+        _ => false
+      }
 
     // Range模式匹配
     Range(lhs~, rhs~, kind~, ..) =>
@@ -328,6 +453,8 @@ pub fn ClosureInterpreter::match_case(
     // Constructor模式匹配
     Constr(constr~, args=pattern_args, ..) =>
       match value {
+        Json(json) =>
+          match_json_constructor(json, constr.name.name, pattern_args)
         Constructor({ val: { name, fields }, ty }) =>
           if name == constr.name.name &&
             self.constructor_pattern_matches_type(ty, constr) {

interpreter/core/runtime_value.mbt

@@ -938,9 +938,13 @@ pub fn runtime_value_infix(
     // Char 运算
     (Char(left), Char(right)) =>
       match op {
-        "+" => String(left.to_string() + right.to_string())
+        "+" => String([left, right])
         "==" => Bool(left == right)
         "!=" => Bool(left != right)
+        "<" => Bool(left < right)
+        ">" => Bool(left > right)
+        "<=" => Bool(left <= right)
+        ">=" => Bool(left >= right)
         _ => Unit
       }
     // Bytes 运算
@@ -961,6 +965,7 @@ pub fn runtime_value_infix(
       }
     (Array(left), Array(right)) =>
       match op {
+        "+" => Array(left + right)
         "==" => Bool(left == right)
         "!=" => Bool(left != right)
         _ => Unit

moon.mod.json

@@ -3,7 +3,8 @@
   "version": "0.9.2",
   "deps": {
     "moonbitlang/parser": "0.3.0",
-    "moonbitlang/x": "0.4.43"
+    "moonbitlang/x": "0.4.43",
+    "moonbitlang/async": "0.19.0"
   },
   "readme": "README.md",
   "repository": "https://github.com/oboard/eval",

test/eval.mbt

@@ -1,42 +1,14 @@
 ///|
-test "eval" {
+test "eval_can_be_user_defined" {
   let vm = MoonBitVM::new()
-  let result = vm.eval("eval(\"1 + 2\")")
-  inspect(result, content="3")
-}
-
-///|
-test "eval eval" {
-  let vm = MoonBitVM::new()
-  let result = vm.eval("eval(\"eval(\\\"1 + 2\\\")\")")
-  inspect(result, content="3")
-}
-
-///|
-test "typeof eval" {
-  let vm = MoonBitVM::new()
-  inspect(
-    vm.eval(
-      (
-        #|typeof(eval("(1+2).to_string()"))
-      ),
-    ),
-    content="@moonbitlang/core/string.String",
-  )
-  inspect(
-    vm.eval(
-      (
-        #|typeof(eval("1+2"))
-      ),
-    ),
-    content="@moonbitlang/core/int.Int",
-  )
-  inspect(
+  ignore(
     vm.eval(
       (
-        #|eval("1+2") is 3
+        #|fn eval(value : Int) -> Int {
+        #|  value + 1
+        #|}
       ),
     ),
-    content="true",
   )
+  inspect(vm.eval("eval(2)"), content="3")
 }