Bump @forthic/interp to 0.2.0

- FIX: Parallel map over record
- Change behavior of `.s`
    `.s` now halts execution and console.logs the top of stack

Author: rjose

forthic-ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forthic/interp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Forthic interpreter",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

forthic-ts/src/forthic/global_module.ts

@@ -2638,7 +2638,13 @@ export class GlobalModule extends Module {
   // ( -- )
   word_dot_s(interp: Interpreter) {
     const stack = (interp as any).stack;
-    console.log(stack);
+    if (stack.length > 0) {
+      console.log(stack[stack.length - 1]);
+    }
+    else {
+      console.log("<STACK EMPTY>");
+    }
+    interp.halt()
   }
 
   // ( a b -- a - b )

forthic-ts/src/forthic/global_module/map_word.ts

@@ -19,7 +19,7 @@ export class MapWord {
   push_error?: boolean;
   with_key?: boolean;
   cur_index: number;
-  result: any[];
+  result: any[] | { [key: string]: any };
   errors: any[];
   is_debugging: boolean;
   processing_item: boolean;
@@ -64,7 +64,10 @@ export class MapWord {
     this.result = [];
     this.errors = [];
     if (this.num_interps > 1) {
-      const group_size = Math.ceil(items.length / this.num_interps);
+      interp.stack_push(items)
+      await interp.run("LENGTH");
+      const num_items = interp.stack_pop();
+      const group_size = Math.ceil(num_items / this.num_interps);
       interp.stack_push(items);
       interp.stack_push(group_size);
       await interp.run("GROUPS-OF");
@@ -82,13 +85,21 @@ export class MapWord {
       const run_results = await Promise.all(interp_runs);
 
       // Gather results
-      let result = [];
+      const is_array = items instanceof Array;
+      let array_result = []
+      let object_result = {}
       let errors = [];
       for (const res of run_results) {
-        result = [...result, ...res[0]];
+        if (is_array) {
+          array_result = [...array_result, ...res[0]]
+        }
+        else {
+          object_result = { ...object_result, ...res[0] };
+        }
+
         errors = [...errors, ...res[1]];
       }
-      this.result = result;
+      this.result = is_array ? array_result : object_result;
       this.errors = errors;
     } else {
       await this.map(interp, items);

forthic-ts/src/forthic/interpreter.ts

@@ -73,6 +73,7 @@ export class Interpreter {
   private module_stack: Module[];
   private registered_modules: { [key: string]: Module };
   private is_compiling: boolean;
+  private should_stop: boolean;
   private is_memo_definition: boolean;
   private cur_definition: any; // Assuming this can be of any type, update if you have a specific type
   private screens: { [key: string]: any }; // Assuming screens can be of any type, update if you have a specific type
@@ -96,6 +97,7 @@ export class Interpreter {
     this.module_stack = [this.app_module];
     this.registered_modules = {};
     this.is_compiling = false;
+    this.should_stop = false;
     this.is_memo_definition = false;
     this.cur_definition = null;
     this.screens = {};
@@ -114,6 +116,10 @@ export class Interpreter {
     this.timestamps = [];
   }
 
+  halt() {
+    this.should_stop = true;
+  }
+
   get_app_module(): Module {
     return this.app_module;
   }
@@ -196,6 +202,10 @@ export class Interpreter {
         if (token.type === TokenType.EOS) {
           break;
         }
+        if (this.should_stop) {
+          this.should_stop = false;
+          break;
+        }
 
         // Regardless of debug mode, we don't want to stop when compiling definitions or going through comments
         if (

forthic-ts/src/forthic/tests/global_module.test.ts

@@ -395,6 +395,26 @@ test("Groups of", async () => {
   expect(groups[2]).toEqual([7, 8]);
 });
 
+test("Groups of record", async () => {
+  await interp.run(`
+    [
+      ['a' 1]
+      ['b' 2]
+      ['c' 3]
+      ['d' 4]
+      ['e' 5]
+      ['f' 6]
+      ['g' 7]
+      ['h' 8]
+    ] REC 3 GROUPS-OF
+  `);
+  const groups = interp.stack_pop();
+  expect(groups[0]).toEqual({ a: 1, b: 2, c: 3 });
+  expect(groups[1]).toEqual({ d: 4, e: 5, f: 6 });
+  expect(groups[2]).toEqual({ g: 7, h: 8 });
+});
+
+
 test("Groups of using record", async () => {
   // Test grouping a record
   interp = new Interpreter();
@@ -1666,6 +1686,18 @@ test("Parallel map", async () => {
   expect(interp.stack_pop()).toEqual([1, 4, 9, 16, 25]);
 });
 
+test("Parallel map over record", async () => {
+  await interp.run(`
+    [
+      ['a' 1]
+      ['b' 2]
+      ['c' 3]
+      ['d' 4]
+    ] REC "3 *" 2 !INTERPS MAP
+    `);
+  expect(interp.stack_pop()).toEqual({ a: 3, b: 6, c: 9, d: 12 });
+});
+
 test("|REC@|", async () => {
   interp.stack_push([{ a: 1 }, { a: 2 }, { a: 3 }]);
   await interp.run(`'a' |REC@`);
@@ -1828,3 +1860,9 @@ test("ADD-DAYS", async () => {
   const res1 = interp.stack_pop();
   console.log("ADD-DAYS", res1);
 });
+
+test(".s", async () => {
+  await interp.run("1 2 .s 3 4");
+  const res1 = interp.stack_pop();
+  expect(res1).toEqual(2);
+})