@graffiticode/basis 1.5.18 → 1.5.20

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@graffiticode/basis",
   "type": "module",
-  "version": "1.5.18",
+  "version": "1.5.20",
   "description": "The basis library for creating Graffiticode languages",
   "main": "index.js",
   "scripts": {
     "test": "jest",
     "build-spec": "npx spec-md ./spec/spec.md > ./spec/spec.html",
-    "watch-spec": "npx nodemon --exec 'npx spec-md > ./spec/spec.html' ./spec/spec.md"
+    "watch-spec": "npx nodemon --exec 'npx spec-md > ./spec/spec.html' ./spec/spec.md",
+    "publish-spec": "npm run build-spec && for dir in ../l0*/packages/api/public; do cp ./spec/spec.html \"$dir/graffiticode-language-spec.html\"; echo \"Copied to $dir/graffiticode-language-spec.html\"; done"
   },
   "engines": {
     "node": "22.x"

package/spec/spec.html

@@ -174,6 +174,9 @@ end
 <li><strong>Strict evaluation</strong>: arguments evaluated before function application</li>
 <li><strong>Immutable data</strong>: all values are immutable</li>
 </ul>
+<p>Many built-in functions in Graffiticode follow a model-threading pattern. In this pattern, functions are defined to take one or more arguments followed by a model, which represents the current state of the program or view. The function uses the earlier arguments to compute an update to the model and returns a new model as its result.</p>
+<p>This style enables a declarative and order-independent composition of functions. Since each function call returns a new model, multiple calls can be reordered without changing the final result, provided the functional dependencies are preserved.</p>
+<p>This approach draws inspiration from <strong>Model-View-Update</strong> (MVU) architectures, in which the model represents the application state and functions describe pure, deterministic transformations of that state.</p>
 </section>
 <section id="sec-Functions" secid="4.2">
 <h2><span class="spec-secid" title="link to this section"><a href="#sec-Functions">4.2</a></span>Functions</h2>
@@ -305,12 +308,12 @@ end
 </tr>
 <tr>
 <td align="left"><code>get</code></td>
-<td align="left"><code>&lt;record string: any&gt;</code></td>
+<td align="left"><code>&lt;string record: any&gt;</code></td>
 <td align="left">Retrieves a value from a record by key</td>
 </tr>
 <tr>
 <td align="left"><code>set</code></td>
-<td align="left"><code>&lt;record string any: record&gt;</code></td>
+<td align="left"><code>&lt;string any record: record&gt;</code></td>
 <td align="left">Returns a new record with a key set to a value</td>
 </tr>
 </tbody>
@@ -414,13 +417,13 @@ end
 <section id="sec-get" secid="5.2.17">
 <h3><span class="spec-secid" title="link to this section"><a href="#sec-get">5.2.17</a></span>get</h3>
 <p>Retrieve a record field</p>
-<pre><code>get {a: 1, b: 2} "b"  | returns 2
+<pre><code>get "b" {a: 1, b: 2}  | returns 2
 </code></pre>
 </section>
 <section id="sec-set" secid="5.2.18">
 <h3><span class="spec-secid" title="link to this section"><a href="#sec-set">5.2.18</a></span>set</h3>
 <p>Return a new record with an updated field</p>
-<pre><code>set {a: 1} "a" 2  | returns {a: 2}
+<pre><code>set "a" 2 {a: 1}  | returns {a: 2}
 </code></pre>
 </section>
 </section>

package/spec/spec.md

@@ -119,6 +119,14 @@ Tags are resolved as special constants with symbolic identity. They are case-sen
 - **Strict evaluation**: arguments evaluated before function application
 - **Immutable data**: all values are immutable
 
+Many built-in functions in Graffiticode follow a model-threading pattern. In this pattern, functions are defined to take one or more arguments followed by a model, which represents the current state of the program or view. The function uses the earlier arguments to compute an update to the model and returns a new model as its result.
+
+This style enables a declarative and order-independent composition of functions. Since each function call returns a new model, multiple calls can be reordered without changing the final result, provided the functional dependencies are preserved.
+
+This approach draws inspiration from **Model-View-Update** (MVU) architectures, in which the model represents the application state and functions describe pure, deterministic transformations of that state.
+
+
+
 ## Functions
 
 - **Fixed arity**: every function has a known number of parameters
@@ -167,8 +175,8 @@ Tags are resolved as special constants with symbolic identity. They are case-sen
 | `nth` | `<number list: any>` | Nth element of list |
 | `apply` | `<function list: any>` | Applies a function to a list of arguments |
 | `isEmpty` | `<list: bool>` | Returns true if the list is empty |
-| `get` | `<record string: any>` | Retrieves a value from a record by key |
-| `set` | `<record string any: record>` | Returns a new record with a key set to a value |
+| `get` | `<string record: any>` | Retrieves a value from a record by key |
+| `set` | `<string any record: record>` | Returns a new record with a key set to a value |
 
 ### add
 
@@ -303,7 +311,7 @@ isEmpty []  | returns true
 Retrieve a record field
 
 ```
-get {a: 1, b: 2} "b"  | returns 2
+get "b" {a: 1, b: 2}  | returns 2
 ```
 
 ### set
@@ -311,7 +319,7 @@ get {a: 1, b: 2} "b"  | returns 2
 Return a new record with an updated field
 
 ```
-set {a: 1} "a" 2  | returns {a: 2}
+set "a" 2 {a: 1}  | returns {a: 2}
 ```
 
 # Program Examples

package/src/compiler.js

@@ -27,7 +27,7 @@ class Visitor {
   }
   visit(nid, options, resume) {
     try {
-      assert(nid);
+      assert(nid, "Invalid nid=" + nid);
       let node;
       if (typeof nid === "object") {
         node = nid;
@@ -425,6 +425,62 @@ export class Checker extends Visitor {
       });
     });
   }
+  NOT(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      let err = [].concat(err1);
+      if (typeof val1 !== "boolean" && val1 !== null && val1 !== undefined && val1 !== 0 && val1 !== "" && val1 !== false) {
+        err.push(`NOT operation requires a boolean argument, got ${typeof val1}`);
+      }
+      const val = node;
+      resume(err, val);
+    });
+  }
+  EQUIV(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        let err = [].concat(err1).concat(err2);
+        const validTypes = ["boolean", "string", "number"];
+        if (!validTypes.includes(typeof val1) && val1 !== null) {
+          err.push(`EQUIV operation requires primitive arguments, got ${typeof val1} for first argument`);
+        }
+        if (!validTypes.includes(typeof val2) && val2 !== null) {
+          err.push(`EQUIV operation requires primitive arguments, got ${typeof val2} for second argument`);
+        }
+        const val = node;
+        resume(err, val);
+      });
+    });
+  }
+  OR(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        let err = [].concat(err1).concat(err2);
+        if (typeof val1 !== "boolean" && val1 !== null && val1 !== undefined && val1 !== 0 && val1 !== "" && val1 !== false) {
+          err.push(`OR operation requires boolean arguments, got ${typeof val1} for first argument`);
+        }
+        if (typeof val2 !== "boolean" && val2 !== null && val2 !== undefined && val2 !== 0 && val2 !== "" && val2 !== false) {
+          err.push(`OR operation requires boolean arguments, got ${typeof val2} for second argument`);
+        }
+        const val = node;
+        resume(err, val);
+      });
+    });
+  }
+  AND(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        let err = [].concat(err1).concat(err2);
+        if (typeof val1 !== "boolean" && val1 !== null && val1 !== undefined && val1 !== 0 && val1 !== "" && val1 !== false) {
+          err.push(`AND operation requires boolean arguments, got ${typeof val1} for first argument`);
+        }
+        if (typeof val2 !== "boolean" && val2 !== null && val2 !== undefined && val2 !== 0 && val2 !== "" && val2 !== false) {
+          err.push(`AND operation requires boolean arguments, got ${typeof val2} for second argument`);
+        }
+        const val = node;
+        resume(err, val);
+      });
+    });
+  }
 }
 
 function enterEnv(ctx, name, paramc) {
@@ -724,7 +780,6 @@ export class Transformer extends Visitor {
   }
   BINDING(node, options, resume) {
     const err = [];
-    const val = node;
     this.visit(node.elts[0], options, (err1, val1) => {
       this.visit(node.elts[1], options, (err2, val2) => {
         resume([].concat(err1).concat(err2), {key: val1, val: val2});
@@ -825,9 +880,11 @@ export class Transformer extends Visitor {
     resume(err, val);
   }
   LEN(node, options, resume) {
-    const err = [];
-    const val = node;
-    resume(err, val);
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = e0;
+      const val = Array.isArray(v0) && v0.length;
+      resume(err, val);
+    });
   }
   ARG(node, options, resume) {
     const err = [];
@@ -869,11 +926,8 @@ export class Transformer extends Visitor {
     this.visit(node.elts[1], options, (e1, v1) => {
       let err = [];
       let val = [];
-      console.log(
-        "MAP()",
-        "v1=" + JSON.stringify(v1),
-      );
       v1.forEach(args => {
+        options.SYNC = true;
         options.args = args;
         options = JSON.parse(JSON.stringify(options));  // Copy option arg support async.
         this.visit(node.elts[0], options, (e0, v0) => {
@@ -921,6 +975,7 @@ export class Transformer extends Visitor {
         let err = [];
         let val = v1;
         v2.forEach((args, index) => {
+          options.SYNC = true;
           options.args = [val, args];
           options = JSON.parse(JSON.stringify(options));  // Copy option arg support async.
           this.visit(node.elts[0], options, (e0, v0) => {
@@ -1007,9 +1062,9 @@ export class Transformer extends Visitor {
     this.visit(node.elts[0], options, (e0, v0) => {
       this.visit(node.elts[1], options, (e1, v1) => {
         const err = [...e0, ...e1];
-        assert(typeof v0 === "object", "Type Error: expected v0 to be an object. Got " + JSON.stringify(v0));
-        assert(typeof v1 === "string", "Type Error: expected v1 to be a string.");
-        const val = v0[v1];
+        assert(typeof v0 === "string", "Type Error: expected v0 to be a string.");
+        assert(typeof v1 === "object", "Type Error: expected v1 to be an object. Got " + JSON.stringify(v1));
+        const val = v1[v0];
         resume(err, val);
       });
     });
@@ -1018,12 +1073,12 @@ export class Transformer extends Visitor {
     this.visit(node.elts[0], options, (e0, v0) => {
       this.visit(node.elts[1], options, (e1, v1) => {
         this.visit(node.elts[2], options, (e2, v2) => {
-          const err = [...e0, ...e1];
-          assert(typeof v0 === "object", "Type Error: expected v0 to be an object.");
-          assert(typeof v1 === "string", "Type Error: expected v1 to be a string.");
+          const err = [...e0, ...e1, ...e2];
+          assert(typeof v0 === "string", "Type Error: expected v0 to be a string.");
+          assert(typeof v2 === "object", "Type Error: expected v2 to be an object.");
           const val = {
-            ...v0,
-            [v1]: v2,
+            ...v2,
+            [v0]: v1,
           };
           resume(err, val);
         });
@@ -1150,7 +1205,6 @@ export class Transformer extends Visitor {
             const start = new Decimal(v0);
             const end = new Decimal(v1);
             const step = new Decimal(v2);
-            
             if (step.isZero()) {
               resume([...err, 'Error in RANGE operation: step cannot be zero'], []);
               return;
@@ -1176,6 +1230,75 @@ export class Transformer extends Visitor {
       });
     });
   }
+  NOT(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = [].concat(e0);
+      try {
+        // Handle various falsy values explicitly
+        if (v0 === null || v0 === undefined || v0 === 0 || v0 === "" || v0 === false) {
+          resume(err, true);
+        } else {
+          resume(err, !v0);
+        }
+      } catch (e) {
+        resume([...err, `Error in NOT operation: ${e.message}`], false);
+      }
+    });
+  }
+  EQUIV(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      this.visit(node.elts[1], options, (e1, v1) => {
+        const err = [].concat(e0).concat(e1);
+        try {
+          // Use strict equality for primitive comparison
+          const val = v0 === v1;
+          resume(err, val);
+        } catch (e) {
+          resume([...err, `Error in EQUIV operation: ${e.message}`], false);
+        }
+      });
+    });
+  }
+  OR(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      // Short-circuit evaluation - if first argument is truthy, return true immediately
+      if (v0) {
+        resume(e0, true);
+        return;
+      }
+
+      this.visit(node.elts[1], options, (e1, v1) => {
+        const err = [].concat(e0).concat(e1);
+        try {
+          // Standard boolean OR operation
+          const val = Boolean(v0) || Boolean(v1);
+          resume(err, val);
+        } catch (e) {
+          resume([...err, `Error in OR operation: ${e.message}`], false);
+        }
+      });
+    });
+  }
+  AND(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      // Short-circuit evaluation - if first argument is falsy, return false immediately
+      if (!v0) {
+        resume(e0, false);
+        return;
+      }
+
+      this.visit(node.elts[1], options, (e1, v1) => {
+        const err = [].concat(e0).concat(e1);
+        try {
+          // Standard boolean AND operation
+          const val = Boolean(v0) && Boolean(v1);
+          resume(err, val);
+        } catch (e) {
+          resume([...err, `Error in AND operation: ${e.message}`], false);
+        }
+      });
+    });
+  }
 }
 
 export class Renderer {

package/src/lexicon.js

@@ -11,14 +11,16 @@ export const lexicon = {
     "name": "GET",
     "cls": "function",
     "length": 2,
-    "arity": 2
+    "arity": 2,
+    "args": ["key", "record"]
   },
   "set" : {
     "tk": 1,
     "name": "SET",
     "cls": "function",
     "length": 3,
-    "arity": 3
+    "arity": 3,
+    "args": ["key", "value", "record"]
   },
   "nth" : {
     "tk": 1,
@@ -187,5 +189,33 @@ export const lexicon = {
     "cls": "function",
     "length": 3,
     "arity": 3
+  },
+  "not" : {
+    "tk": 1,
+    "name": "NOT",
+    "cls": "function",
+    "length": 1,
+    "arity": 1
+  },
+  "equiv" : {
+    "tk": 1,
+    "name": "EQUIV",
+    "cls": "function",
+    "length": 2,
+    "arity": 2
+  },
+  "or" : {
+    "tk": 1,
+    "name": "OR",
+    "cls": "function",
+    "length": 2,
+    "arity": 2
+  },
+  "and" : {
+    "tk": 1,
+    "name": "AND",
+    "cls": "function",
+    "length": 2,
+    "arity": 2
   }
 }