exprforge 0.2.0 → 0.3.0

package/index.js

@@ -1,6 +1,9 @@
 // exprforge/index.js
 const { num, v, bin, call, add, mul, sub, div, neg, letIn, letChain, cmp, select, outputs, collectLets } = require("./ast.js");
 const { forComponents } = require("./util.js");
+const { expr } = require("./expr.js");
+const { fn } = require("./fn.js");
+const { evaluate } = require("./evaluate.js");
 const emitters = require("./emitters/registry.js");
 const { catmullRomAst } = require("./samples/catmull-rom.js");
 const { fibonacciAst } = require("./samples/fibonacci.js");
@@ -12,10 +15,10 @@ const { mathDemoAst } = require("./samples/math-demo.js");
  * Run every registered emitter against one AST function definition.
  * Returns { [lang]: { ext, source } }.
  */
-function emitAll(fn) {
+function emitAll(fnDef) {
     const result = {};
     for (const [lang, emitter] of Object.entries(emitters)) {
-        result[lang] = { ext: emitter.ext, source: emitter.emitFunction(fn) };
+        result[lang] = { ext: emitter.ext, source: emitter.emitFunction(fnDef) };
     }
     return result;
 }
@@ -25,6 +28,15 @@ module.exports = {
     num, v, bin, call, add, mul, sub, div, neg, letIn, letChain, cmp, select, outputs, collectLets,
     // Authoring convenience — not an AST primitive, see util.js.
     forComponents,
+    // Infix syntax sugar over the builders above — same Nodes, see expr.js.
+    expr,
+    // Full function-body syntax (let/return) on top of expr's grammar —
+    // see fn.js. "fn's contain expr's": every expression inside a fn`...`
+    // template is parsed by the exact same engine expr() uses.
+    fn,
+    // A native interpreter over the AST -- evaluate(fn, args) computes a
+    // result directly in JS, no codegen/compile step. See evaluate.js.
+    evaluate,
     // Built-in example formulas — see samples/ for the source.
     catmullRomAst,
     fibonacciAst,

package/math/index.js

@@ -67,6 +67,14 @@ function cross3(ax, ay, az, bx, by, bz) {
 // with another normalize3() binding inside the same function body, and a
 // process-wide counter trivially guarantees that regardless of how many
 // times normalize3 is called across however many functions.
+//
+// The name itself starts with a letter, not "__" -- confirmed against a
+// real Fortran compiler ("Invalid character in name") that a leading
+// underscore isn't a valid identifier start there, unlike JS/Python/etc.
+// This is an internal implementation detail (never part of any documented
+// return value or public name), so there's nothing for a leading-"__"
+// convention to usefully signal here that a portable identifier can't
+// signal just as well.
 let normalizeGensymCounter = 0;
 
 // Safe-normalize a 3-D vector. Returns { x, y, z } (same shape as cross3).
@@ -85,7 +93,7 @@ let normalizeGensymCounter = 0;
 // name avoids a "duplicate let binding name" throw if normalize3 is called
 // more than once inside one function (e.g. normalizing two vectors).
 function normalize3(x, y, z, fx = num(0), fy = num(1), fz = num(0)) {
-    const lenName = `__exprforgeMathNrmLen${normalizeGensymCounter++}`;
+    const lenName = `efMathNrmLen${normalizeGensymCounter++}`;
     return {
         x: letIn(lenName, len3(x, y, z), safeDiv(x, v(lenName), fx)),
         y: safeDiv(y, v(lenName), fy),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "exprforge",
-  "version": "0.2.0",
-  "description": "Author a math expression once as an AST, emit identical-behavior implementations in JS, TypeScript, Python, C#, Lua, QB64, C, Java, Go, and Rust.",
+  "version": "0.3.0",
+  "description": "Author a math expression once as an AST (or readable infix text via expr/fn), emit identical-behavior implementations in JS, TypeScript, Python, C#, Lua, QB64, C, Java, Go, Rust, Perl, PHP, Julia, Fortran, Zig, Scheme, and COBOL, plus a native evaluator and its own readable syntax printer.",
   "main": "index.js",
   "type": "commonjs",
   "exports": {
@@ -13,6 +13,9 @@
     "index.js",
     "ast.js",
     "util.js",
+    "expr.js",
+    "fn.js",
+    "evaluate.js",
     "build.js",
     "emitters/",
     "samples/",

package/samples/math-demo.js

@@ -10,17 +10,21 @@
 const { v, num, outputs } = require("../ast.js");
 const { safeDiv, dot3, len3, cross3, normalize3, clamp } = require("../math/index.js");
 
-const MATH_DEMO_PARAMS = ["ax", "ay", "az", "bx", "by", "bz", "t", "lo", "hi"];
+// "byy", not "by": BY is a reserved COBOL keyword (BY REFERENCE/BY VALUE/
+// BY CONTENT) -- confirmed against a real compiler ("syntax error,
+// unexpected BY") that it can't be used as a data-item name there, same
+// kind of unavoidable per-language collision as "len"/"mag" below.
+const MATH_DEMO_PARAMS = ["ax", "ay", "az", "bx", "byy", "bz", "t", "lo", "hi"];
 
-const cross = cross3(v("ax"), v("ay"), v("az"), v("bx"), v("by"), v("bz"));
+const cross = cross3(v("ax"), v("ay"), v("az"), v("bx"), v("byy"), v("bz"));
 const normA = normalize3(v("ax"), v("ay"), v("az"));
-const normB = normalize3(v("bx"), v("by"), v("bz"));
+const normB = normalize3(v("bx"), v("byy"), v("bz"));
 
 const MathDemo = {
     name: "MathDemo",
     params: MATH_DEMO_PARAMS,
     body: outputs({
-        dot: dot3(v("ax"), v("ay"), v("az"), v("bx"), v("by"), v("bz")),
+        dot: dot3(v("ax"), v("ay"), v("az"), v("bx"), v("byy"), v("bz")),
         // "mag", not "len": LEN is a reserved QB64 builtin (string/array
         // length) -- see test/conformance.test.js's normalizeXAst comment.
         mag: len3(v("ax"), v("ay"), v("az")),