@graffiticode/basis 1.5.19 → 1.5.21

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graffiticode/basis",
   "type": "module",
-  "version": "1.5.19",
+  "version": "1.5.21",
   "description": "The basis library for creating Graffiticode languages",
   "main": "index.js",
   "scripts": {

package/spec/spec.html

@@ -64,6 +64,10 @@
 <li><a href="#sec-isEmpty"><span class="spec-secid">5.2.16</span>isEmpty</a></li>
 <li><a href="#sec-get"><span class="spec-secid">5.2.17</span>get</a></li>
 <li><a href="#sec-set"><span class="spec-secid">5.2.18</span>set</a></li>
+<li><a href="#sec-not"><span class="spec-secid">5.2.19</span>not</a></li>
+<li><a href="#sec-equiv"><span class="spec-secid">5.2.20</span>equiv</a></li>
+<li><a href="#sec-or"><span class="spec-secid">5.2.21</span>or</a></li>
+<li><a href="#sec-and"><span class="spec-secid">5.2.22</span>and</a></li>
 </ol>
 </li>
 </ol>
@@ -278,8 +282,8 @@ end
 </tr>
 <tr>
 <td align="left"><code>reduce</code></td>
-<td align="left"><code>&lt;function list: any&gt;</code></td>
-<td align="left">Combines list using a reducer</td>
+<td align="left"><code>&lt;function any list: any&gt;</code></td>
+<td align="left">Combines list using a reducer with initial value</td>
 </tr>
 <tr>
 <td align="left"><code>hd</code></td>
@@ -316,6 +320,26 @@ end
 <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>
+<tr>
+<td align="left"><code>not</code></td>
+<td align="left"><code>&lt;bool: bool&gt;</code></td>
+<td align="left">Logical NOT operation, inverts a boolean value</td>
+</tr>
+<tr>
+<td align="left"><code>equiv</code></td>
+<td align="left"><code>&lt;any any: bool&gt;</code></td>
+<td align="left">Tests if two values are strictly equivalent</td>
+</tr>
+<tr>
+<td align="left"><code>or</code></td>
+<td align="left"><code>&lt;bool bool: bool&gt;</code></td>
+<td align="left">Logical OR operation</td>
+</tr>
+<tr>
+<td align="left"><code>and</code></td>
+<td align="left"><code>&lt;bool bool: bool&gt;</code></td>
+<td align="left">Logical AND operation</td>
+</tr>
 </tbody>
 </table>
 <section id="sec-add" secid="5.2.1">
@@ -426,6 +450,41 @@ end
 <pre><code>set "a" 2 {a: 1}  | returns {a: 2}
 </code></pre>
 </section>
+<section id="sec-not" secid="5.2.19">
+<h3><span class="spec-secid" title="link to this section"><a href="#sec-not">5.2.19</a></span>not</h3>
+<p>Logical NOT that inverts a boolean value</p>
+<pre><code>not true   | returns false
+not false  | returns true
+</code></pre>
+</section>
+<section id="sec-equiv" secid="5.2.20">
+<h3><span class="spec-secid" title="link to this section"><a href="#sec-equiv">5.2.20</a></span>equiv</h3>
+<p>Tests if two values are strictly equivalent</p>
+<pre><code>equiv 1 1        | returns true
+equiv "a" "a"    | returns true
+equiv true true  | returns true
+equiv 1 2        | returns false
+equiv "a" "b"    | returns false
+</code></pre>
+</section>
+<section id="sec-or" secid="5.2.21">
+<h3><span class="spec-secid" title="link to this section"><a href="#sec-or">5.2.21</a></span>or</h3>
+<p>Logical OR operation</p>
+<pre><code>or false false  | returns false
+or false true   | returns true
+or true false   | returns true
+or true true    | returns true
+</code></pre>
+</section>
+<section id="sec-and" secid="5.2.22">
+<h3><span class="spec-secid" title="link to this section"><a href="#sec-and">5.2.22</a></span>and</h3>
+<p>Logical AND operation</p>
+<pre><code>and false false  | returns false
+and false true   | returns false
+and true false   | returns false
+and true true    | returns true
+</code></pre>
+</section>
 </section>
 </section>
 <section id="sec-Program-Examples" secid="6">
@@ -518,6 +577,10 @@ Written in <a href="https://spec-md.com" target="_blank">Spec Markdown</a>.</foo
 <li id="_sidebar_5.2.16"><a href="#sec-isEmpty"><span class="spec-secid">5.2.16</span>isEmpty</a></li>
 <li id="_sidebar_5.2.17"><a href="#sec-get"><span class="spec-secid">5.2.17</span>get</a></li>
 <li id="_sidebar_5.2.18"><a href="#sec-set"><span class="spec-secid">5.2.18</span>set</a></li>
+<li id="_sidebar_5.2.19"><a href="#sec-not"><span class="spec-secid">5.2.19</span>not</a></li>
+<li id="_sidebar_5.2.20"><a href="#sec-equiv"><span class="spec-secid">5.2.20</span>equiv</a></li>
+<li id="_sidebar_5.2.21"><a href="#sec-or"><span class="spec-secid">5.2.21</span>or</a></li>
+<li id="_sidebar_5.2.22"><a href="#sec-and"><span class="spec-secid">5.2.22</span>and</a></li>
 </ol>
 </li>
 </ol>

package/spec/spec.md

@@ -169,7 +169,7 @@ This approach draws inspiration from **Model-View-Update** (MVU) architectures,
 | `range` | `<number number number: list>` | Generates a range list |
 | `map` | `<function list: list>` | Applies function to each item |
 | `filter` | `<function list: list>` | Keeps items matching predicate |
-| `reduce` | `<function list: any>` | Combines list using a reducer |
+| `reduce` | `<function any list: any>` | Combines list using a reducer with initial value |
 | `hd` | `<list: any>` | First item of list |
 | `tl` | `<list: list>` | All items except first |
 | `nth` | `<number list: any>` | Nth element of list |
@@ -177,6 +177,10 @@ This approach draws inspiration from **Model-View-Update** (MVU) architectures,
 | `isEmpty` | `<list: bool>` | Returns true if the list is empty |
 | `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 |
+| `not` | `<bool: bool>` | Logical NOT operation, inverts a boolean value |
+| `equiv` | `<any any: bool>` | Tests if two values are strictly equivalent |
+| `or` | `<bool bool: bool>` | Logical OR operation |
+| `and` | `<bool bool: bool>` | Logical AND operation |
 
 ### add
 
@@ -322,6 +326,49 @@ Return a new record with an updated field
 set "a" 2 {a: 1}  | returns {a: 2}
 ```
 
+### not
+
+Logical NOT that inverts a boolean value
+
+```
+not true   | returns false
+not false  | returns true
+```
+
+### equiv
+
+Tests if two values are strictly equivalent
+
+```
+equiv 1 1        | returns true
+equiv "a" "a"    | returns true
+equiv true true  | returns true
+equiv 1 2        | returns false
+equiv "a" "b"    | returns false
+```
+
+### or
+
+Logical OR operation
+
+```
+or false false  | returns false
+or false true   | returns true
+or true false   | returns true
+or true true    | returns true
+```
+
+### and
+
+Logical AND operation
+
+```
+and false false  | returns false
+and false true   | returns false
+and true false   | returns false
+and true true    | returns true
+```
+
 # 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,86 @@ 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);
+      });
+    });
+  }
+  HD(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      let err = [].concat(err1);
+      // if (!Array.isArray(val1)) {
+      //   err.push(`HD operation requires a list argument, got ${typeof val1}`);
+      // } else if (val1.length === 0) {
+      //   err.push(`HD operation called on an empty list`);
+      // }
+      const val = node;
+      resume(err, val);
+    });
+  }
+  TL(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      let err = [].concat(err1);
+      // if (!Array.isArray(val1)) {
+      //   err.push(`TL operation requires a list argument, got ${typeof val1}`);
+      // } else if (val1.length === 0) {
+      //   err.push(`TL operation called on an empty list`);
+      // }
+      const val = node;
+      resume(err, val);
+    });
+  }
 }
 
 function enterEnv(ctx, name, paramc) {
@@ -724,7 +804,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 +904,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 +950,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 +999,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) => {
@@ -1150,7 +1229,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 +1254,115 @@ 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);
+        }
+      });
+    });
+  }
+  HD(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = [].concat(e0);
+      try {
+        if (!Array.isArray(v0)) {
+          resume([...err, `Error in HD operation: expected an array, got ${typeof v0}`], null);
+          return;
+        }
+        if (v0.length === 0) {
+          resume([...err, `Error in HD operation: empty array has no head`], null);
+          return;
+        }
+        // Return the first element of the array
+        const val = v0[0];
+        resume(err, val);
+      } catch (e) {
+        resume([...err, `Error in HD operation: ${e.message}`], null);
+      }
+    });
+  }
+  TL(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = [].concat(e0);
+      try {
+        if (!Array.isArray(v0)) {
+          resume([...err, `Error in TL operation: expected an array, got ${typeof v0}`], []);
+          return;
+        }
+        if (v0.length === 0) {
+          resume([...err, `Error in TL operation: empty array has no tail`], []);
+          return;
+        }
+        // Return all elements except the first
+        const val = v0.slice(1);
+        resume(err, val);
+      } catch (e) {
+        resume([...err, `Error in TL operation: ${e.message}`], []);
+      }
+    });
+  }
 }
 
 export class Renderer {

package/src/lexicon.js

@@ -12,7 +12,6 @@ export const lexicon = {
     "cls": "function",
     "length": 2,
     "arity": 2,
-    "args": ["key", "record"]
   },
   "set" : {
     "tk": 1,
@@ -20,7 +19,6 @@ export const lexicon = {
     "cls": "function",
     "length": 3,
     "arity": 3,
-    "args": ["key", "value", "record"]
   },
   "nth" : {
     "tk": 1,
@@ -189,5 +187,47 @@ 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
+  },
+  "hd" : {
+    "tk": 1,
+    "name": "HD",
+    "cls": "function",
+    "length": 1,
+    "arity": 1
+  },
+  "tl" : {
+    "tk": 1,
+    "name": "TL",
+    "cls": "function",
+    "length": 1,
+    "arity": 1
   }
 }