exprforge 0.2.0 → 0.3.0

package/emitters/fortran.js

@@ -0,0 +1,169 @@
+// exprforge/emitters/fortran.js
+const Emitter = require("./base.js");
+
+// Fortran keywords/statement words plus every intrinsic this emitter's own
+// calls table uses -- same role as QB64_RESERVED in emitters/qb64.js.
+// Fortran is case-insensitive, so names are checked lowercased. Not
+// exhaustive (Fortran has no fixed reserved-word list at all -- context
+// determines meaning), but covers the words a generated variable/parameter/
+// function name could plausibly collide with in practice.
+const FORTRAN_RESERVED = new Set([
+    "program", "subroutine", "function", "end", "implicit", "none",
+    "real", "integer", "double", "precision", "complex", "logical", "character",
+    "dimension", "intent", "in", "out", "inout", "result", "kind",
+    "if", "then", "else", "elseif", "endif", "do", "while", "continue", "exit", "cycle",
+    "select", "case", "where", "forall", "goto", "stop", "return", "call",
+    "contains", "module", "use", "interface", "type", "class",
+    "print", "write", "read", "format", "data", "parameter", "common", "equivalence",
+    "allocate", "deallocate", "pointer", "target", "public", "private",
+    "elemental", "pure", "recursive", "merge",
+    "sqrt", "abs", "sin", "cos", "tan", "asin", "acos", "atan", "atan2",
+    "log", "log10", "exp", "floor", "ceiling", "anint", "aint", "nint",
+    "min", "max", "hypot", "sign", "mod", "len", "len_trim", "trim", "index",
+]);
+
+function checkReservedNames(names) {
+    for (const name of names) {
+        if (FORTRAN_RESERVED.has(name.toLowerCase())) {
+            throw new Error(
+                `emitter for .f90: "${name}" is a reserved Fortran keyword/intrinsic and can't be used as a ` +
+                `function/variable/parameter name -- rename it (see FORTRAN_RESERVED in emitters/fortran.js)`,
+            );
+        }
+    }
+}
+
+function fn1(name) {
+    return ([x]) => `${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `${name}(${a}, ${b})`;
+}
+
+// Fortran free-form source has a real, standards-mandated 132-character
+// line limit -- confirmed the hard way (a real compiler, "Line truncated
+// ... [-Werror=line-truncation]") on samples/catmull-rom.js's one-line
+// polynomial, which a different gfortran build/version apparently let
+// through as a non-fatal warning during development, masking this until a
+// stricter compiler caught it for real. A trailing `&` continues a
+// statement onto the next line (confirmed against a real compiler) -- long
+// lines get broken at word boundaries well under the actual limit.
+function wrapLine(line, maxWidth = 100) {
+    if (line.length <= maxWidth) return line;
+    const words = line.split(" ");
+    const wrapped = [];
+    let current = "";
+    for (const word of words) {
+        if (current && current.length + 1 + word.length > maxWidth) {
+            wrapped.push(`${current} &`);
+            current = `        ${word}`;
+        } else {
+            current = current ? `${current} ${word}` : word;
+        }
+    }
+    if (current) wrapped.push(current);
+    return wrapped.join("\n");
+}
+
+const emitter = new Emitter({
+    ext: "f90",
+    // Fortran's D exponent marker (not E) forces a literal to be
+    // double-precision regardless of context -- same reasoning as QB64's #
+    // suffix/D marker (see qb64.js). Without it, a plain "3.14159" literal
+    // is parsed as single precision FIRST, then widened -- silently losing
+    // precision before it ever reaches a real(8) variable. Every literal
+    // gets this, not just ones already in scientific notation.
+    formatNumber: (v) => {
+        const s = String(v);
+        if (/e/i.test(s)) return s.replace(/e/i, "D");
+        return s.includes(".") ? `${s}D0` : `${s}.0D0`;
+    },
+    calls: {
+        sqrt: fn1("SQRT"), abs: fn1("ABS"), sin: fn1("SIN"), cos: fn1("COS"), tan: fn1("TAN"),
+        asin: fn1("ASIN"), acos: fn1("ACOS"), atan: fn1("ATAN"), atan2: fn2("ATAN2"),
+        log: fn1("LOG"), log10: fn1("LOG10"), exp: fn1("EXP"),
+        pow: ([x, y]) => `(${x} ** ${y})`,
+        min: fn2("MIN"), max: fn2("MAX"),
+        // HYPOT is an F2008 intrinsic -- no need to derive it by hand.
+        hypot: fn2("HYPOT"),
+        // ANINT/AINT already return a REAL of the same kind as their
+        // argument (confirmed: real(8) in, real(8) out) -- unlike
+        // FLOOR/CEILING below, no conversion needed. ANINT rounds ties
+        // away from zero, matching every other target here.
+        round: fn1("ANINT"),
+        trunc: fn1("AINT"),
+        // FLOOR/CEILING return the default INTEGER kind, not REAL --
+        // REAL(..., 8) converts back to double, matching this project's
+        // float64-only model everywhere else (same reasoning as Python's
+        // float(math.floor(...))).
+        floor: ([x]) => `REAL(FLOOR(${x}), 8)`,
+        ceil: ([x]) => `REAL(CEILING(${x}), 8)`,
+        // No LOG2 intrinsic -- derive it.
+        log2: ([x]) => `(LOG(${x}) / LOG(2.0D0))`,
+        // The native SIGN(A, B) intrinsic ("magnitude of A, sign of B") is
+        // NOT this project's sign(x) -- confirmed against a real compiler
+        // that SIGN(1.0D0, 0.0D0) returns 1.0D0, not 0.0D0 (IEEE 754
+        // treats +0.0 as positive-signed). Built from MERGE instead, same
+        // zero-aware construction as every other emitter here that can't
+        // trust its language's native sign function at exactly zero (see
+        // Go's/Rust's sign() history in this project).
+        sign: ([x]) => `MERGE(1.0D0, MERGE(-1.0D0, 0.0D0, (${x}) < 0.0D0), (${x}) > 0.0D0)`,
+    },
+    // Fortran has no ternary operator, but MERGE(TSOURCE, FSOURCE, MASK) is
+    // exactly an expression-level conditional value-select -- confirmed
+    // against a real compiler to behave like this project's select(), down
+    // to evaluating both TSOURCE and FSOURCE regardless of MASK (elemental
+    // intrinsics don't short-circuit), which matches select()'s own
+    // "both branches always evaluated" contract (see ast.js) instead of
+    // fighting it.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        return `MERGE(${thenStr}, ${elseStr}, (${L}) ${condNode.op} (${R}))`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        checkReservedNames([fn.name, ...fn.params, ...letBindings.map((b) => b.name)]);
+        const params = fn.params.join(", ");
+        const paramDecl = fn.params.length ? wrapLine(`    real(8), intent(in) :: ${fn.params.join(", ")}`) + "\n" : "";
+        const letDecl = letBindings.length
+            ? wrapLine(`    real(8) :: ${letBindings.map((b) => b.name).join(", ")}`) + "\n"
+            : "";
+        const letsBlock = letBindings.map(({ name, valueStr }) => wrapLine(`    ${name} = ${valueStr}`)).join("\n");
+        return `! AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               wrapLine(`real(8) function ${fn.name}(${params})`) + "\n" +
+               `    implicit none\n` +
+               paramDecl +
+               letDecl +
+               (letsBlock ? letsBlock + "\n" : "") +
+               wrapLine(`    ${fn.name} = ${body}`) + "\n" +
+               `end function ${fn.name}\n`;
+    },
+    // Multiple named outputs from one call: a subroutine with the outputs
+    // as trailing intent(out) parameters -- the same by-reference idiom
+    // QB64's SUB uses (see qb64.js), Fortran's closest equivalent since it
+    // has no native struct/tuple return either.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const outputNames = Object.keys(outputStrs);
+        checkReservedNames([fn.name, ...fn.params, ...outputNames, ...letBindings.map((b) => b.name)]);
+        const allParams = [...fn.params, ...outputNames].join(", ");
+        const paramDecl = fn.params.length ? wrapLine(`    real(8), intent(in) :: ${fn.params.join(", ")}`) + "\n" : "";
+        const outDecl = wrapLine(`    real(8), intent(out) :: ${outputNames.join(", ")}`) + "\n";
+        const letDecl = letBindings.length
+            ? wrapLine(`    real(8) :: ${letBindings.map((b) => b.name).join(", ")}`) + "\n"
+            : "";
+        const letsBlock = letBindings.map(({ name, valueStr }) => wrapLine(`    ${name} = ${valueStr}`)).join("\n");
+        const assigns = outputNames.map((n) => wrapLine(`    ${n} = ${outputStrs[n]}`)).join("\n");
+        return `! AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               wrapLine(`subroutine ${fn.name}(${allParams})`) + "\n" +
+               `    implicit none\n` +
+               paramDecl +
+               outDecl +
+               letDecl +
+               (letsBlock ? letsBlock + "\n" : "") +
+               `${assigns}\n` +
+               `end subroutine ${fn.name}\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/julia.js

@@ -0,0 +1,67 @@
+// exprforge/emitters/julia.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `${name}(${a}, ${b})`;
+}
+
+const emitter = new Emitter({
+    ext: "jl",
+    // Julia accepts JS-style numeric literal syntax directly, including
+    // exponential notation ("1e-9") -- no suffix or conversion needed.
+    formatNumber: (v) => String(v),
+    calls: {
+        // All 22 are Julia Base functions -- no import, no derivation, no
+        // wrapping needed for any of them, unlike every other target here.
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), atan2: fn2("atan"),
+        log: fn1("log"), log2: fn1("log2"), log10: fn1("log10"), exp: fn1("exp"),
+        pow: ([x, y]) => `(${x} ^ ${y})`,
+        floor: fn1("floor"), ceil: fn1("ceil"), trunc: fn1("trunc"),
+        min: fn2("min"), max: fn2("max"), hypot: fn2("hypot"),
+        // Julia's round() defaults to round-half-to-even (banker's
+        // rounding), not the round-half-away-from-zero every other target
+        // here uses -- RoundNearestTiesAway asks for that explicitly.
+        // Doesn't affect the conformance suite either way (it deliberately
+        // avoids exact .5 boundaries, see test/conformance.test.js), but
+        // this is the genuinely-matching behavior, not just the
+        // untested-so-it-doesn't-matter one.
+        round: ([x]) => `round(${x}, RoundNearestTiesAway)`,
+        // Julia does have sign(), and sign(0.0) == 0.0 -- matches every
+        // other target's zero-aware convention already, so no need to
+        // build this one by hand (unlike most other emitters here).
+        sign: fn1("sign"),
+    },
+    // Julia's ?: is exactly base.js's default ternary -- no override needed.
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    ${name} = ${valueStr}`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `# AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `function ${fn.name}(${params})\n` +
+               letsBlock +
+               `    return ${body}\n` +
+               `end\n`;
+    },
+    // Multiple named outputs from one call: Julia's native named tuple
+    // (`(rx=..., ry=...)`, dot access at the call site) -- the same idiom
+    // C#'s emitter uses, and needs no wrapper type declared up front.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    ${name} = ${valueStr}`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const returnExpr = outputNames.map((n) => `${n}=${outputStrs[n]}`).join(", ");
+        return `# AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `function ${fn.name}(${params})\n` +
+               letsBlock +
+               `    return (${returnExpr})\n` +
+               `end\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/perl.js

@@ -0,0 +1,95 @@
+// exprforge/emitters/perl.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `${name}(${x})`;
+}
+
+function posix1(name) {
+    return ([x]) => `POSIX::${name}(${x})`;
+}
+
+// Every scalar variable reference in Perl needs a leading `$` -- unlike
+// every other emitter here, base.js's default "var" case (bare
+// `node.name`) is wrong for every single reference, not just declarations.
+// Emitter is a real class (see base.js), so this overrides just the one
+// case and defers to the base class for everything else, instead of
+// needing a new config hook shared by every other emitter.
+class PerlEmitter extends Emitter {
+    emitExpr(node) {
+        if (node.type === "var") return `$${node.name}`;
+        return super.emitExpr(node);
+    }
+}
+
+const emitter = new PerlEmitter({
+    ext: "pl",
+    // Perl accepts JS-style numeric literal syntax directly, including
+    // exponential notation ("1e-9") -- no suffix or conversion needed.
+    formatNumber: (v) => String(v),
+    calls: {
+        // Core builtins -- no module needed.
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"),
+        exp: fn1("exp"), log: fn1("log"), atan2: ([a, b]) => `atan2(${a}, ${b})`,
+        pow: ([x, y]) => `(${x} ** ${y})`,
+        // Everything else Perl core doesn't have is in the POSIX module --
+        // called fully-qualified (POSIX::name) rather than imported, so
+        // there's no import list to keep in sync with this table and no
+        // risk of a POSIX symbol shadowing a core builtin of the same name.
+        tan: posix1("tan"), asin: posix1("asin"), acos: posix1("acos"), atan: posix1("atan"),
+        log10: posix1("log10"), floor: posix1("floor"), ceil: posix1("ceil"),
+        round: posix1("round"), trunc: posix1("trunc"),
+        hypot: ([a, b]) => `POSIX::hypot(${a}, ${b})`,
+        // No log2 anywhere in core or POSIX -- derive it.
+        log2: ([x]) => `(log(${x}) / log(2))`,
+        // List::Util, same fully-qualified convention as POSIX above.
+        min: ([a, b]) => `List::Util::min(${a}, ${b})`,
+        max: ([a, b]) => `List::Util::max(${a}, ${b})`,
+        // No sign() anywhere in core, POSIX, or List::Util -- build it
+        // directly. Zero-aware by construction (see Go's/Rust's sign()
+        // history in this project for what happens when it isn't).
+        sign: ([x]) => `(${x} > 0 ? 1.0 : (${x} < 0 ? -1.0 : 0.0))`,
+    },
+    // Perl's ?: is exactly base.js's default ternary -- no override needed.
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.length ? `    my (${fn.params.map((p) => `$${p}`).join(", ")}) = @_;\n` : "";
+        const lets = letBindings.map(({ name, valueStr }) => `    my $${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `# AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `use strict;\n` +
+               `use warnings;\n` +
+               `use POSIX ();\n` +
+               `use List::Util ();\n\n` +
+               `sub ${fn.name} {\n` +
+               params +
+               letsBlock +
+               `    return ${body};\n` +
+               `}\n\n` +
+               `1;\n`;
+    },
+    // Multiple named outputs from one call: a plain hash ref (`{ rx => ...,
+    // ry => ... }`), Perl's lightest-weight named-record idiom -- no
+    // package/class needed just to carry a few doubles back to the caller.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.length ? `    my (${fn.params.map((p) => `$${p}`).join(", ")}) = @_;\n` : "";
+        const lets = letBindings.map(({ name, valueStr }) => `    my $${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const fields = outputNames.map((n) => `        ${n} => ${outputStrs[n]},`).join("\n");
+        return `# AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `use strict;\n` +
+               `use warnings;\n` +
+               `use POSIX ();\n` +
+               `use List::Util ();\n\n` +
+               `sub ${fn.name} {\n` +
+               params +
+               letsBlock +
+               `    return {\n` +
+               fields + "\n" +
+               `    };\n` +
+               `}\n\n` +
+               `1;\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/php.js

@@ -0,0 +1,79 @@
+// exprforge/emitters/php.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `${name}(${a}, ${b})`;
+}
+
+// Every variable reference in PHP needs a leading `$` -- unlike every other
+// emitter here, base.js's default "var" case (bare `node.name`) is wrong
+// for every single reference, not just declarations. Same fix as Perl's
+// emitter: override just the one case, defer to the base class otherwise.
+class PhpEmitter extends Emitter {
+    emitExpr(node) {
+        if (node.type === "var") return `$${node.name}`;
+        return super.emitExpr(node);
+    }
+}
+
+const emitter = new PhpEmitter({
+    ext: "php",
+    // PHP accepts JS-style numeric literal syntax directly, including
+    // exponential notation ("1e-9") -- no suffix or conversion needed.
+    formatNumber: (v) => String(v),
+    calls: {
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), atan2: fn2("atan2"),
+        log: fn1("log"), log10: fn1("log10"), exp: fn1("exp"), pow: fn2("pow"),
+        floor: fn1("floor"), ceil: fn1("ceil"), round: fn1("round"),
+        min: fn2("min"), max: fn2("max"), hypot: fn2("hypot"),
+        // log() takes an optional base argument -- covers log2 without a
+        // separate function (PHP has no log2() of its own).
+        log2: ([x]) => `log(${x}, 2)`,
+        // No trunc() anywhere in PHP core. floor for non-negatives, ceil
+        // for negatives -- avoids an (int) cast, which would silently
+        // misbehave outside PHP's platform integer range.
+        trunc: ([x]) => `(${x} >= 0 ? floor(${x}) : ceil(${x}))`,
+        // No sign() either -- build it directly. Zero-aware by construction
+        // (see Go's/Rust's sign() history in this project for what happens
+        // when it isn't).
+        sign: ([x]) => `(${x} > 0 ? 1.0 : (${x} < 0 ? -1.0 : 0.0))`,
+    },
+    // PHP's ?: is exactly base.js's default ternary -- no override needed.
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.map((p) => `$${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    $${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `<?php\n` +
+               `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n\n` +
+               `function ${fn.name}(${params}) {\n` +
+               letsBlock +
+               `    return ${body};\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: a plain associative array
+    // (`['rx' => ..., 'ry' => ...]`), PHP's lightest-weight named-record
+    // idiom -- no class needed just to carry a few doubles back to the
+    // caller.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.map((p) => `$${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    $${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const fields = outputNames.map((n) => `        '${n}' => ${outputStrs[n]},`).join("\n");
+        return `<?php\n` +
+               `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n\n` +
+               `function ${fn.name}(${params}) {\n` +
+               letsBlock +
+               `    return [\n` +
+               fields + "\n" +
+               `    ];\n` +
+               `}\n`;
+    },
+});
+
+module.exports = emitter;

package/emitters/registry.js

@@ -12,4 +12,12 @@ module.exports = {
     csharp: require("./csharp.js"),
     python: require("./python.js"),
     lua: require("./lua.js"),
+    perl: require("./perl.js"),
+    php: require("./php.js"),
+    julia: require("./julia.js"),
+    fortran: require("./fortran.js"),
+    zig: require("./zig.js"),
+    scheme: require("./scheme.js"),
+    cobol: require("./cobol.js"),
+    expr: require("./exprsyntax.js"),
 };

package/emitters/scheme.js

@@ -0,0 +1,154 @@
+// exprforge/emitters/scheme.js
+//
+// Targets Guile (R7RS-ish Scheme) specifically -- see
+// test/conformance.test.js for the exact `guile3.0` invocation this is
+// verified against. Prefix notation throughout: this project's "bin" node
+// is the one thing every OTHER emitter can handle via base.js's default
+// infix `(${L} ${op} ${R})` -- Scheme is the one target here where even
+// `+`/`-`/`*`/`/` themselves need to move into the operator position, so
+// this overrides emitExpr's "bin" case specifically (Emitter is a real
+// class -- see base.js -- so this is a small subclass, not a new shared
+// hook every other emitter would have to ignore).
+const Emitter = require("./base.js");
+
+// Guile special forms plus the procedure names this emitter's own calls
+// table depends on -- same role as QB64_RESERVED in emitters/qb64.js.
+// Scheme technically allows shadowing a procedure name like `sqrt` with a
+// local binding, but doing so would break every OTHER call in the same
+// scope that still expects it to mean the real one, so it's guarded here
+// same as a true syntactic keyword.
+const SCHEME_RESERVED = new Set([
+    "define", "lambda", "let", "let*", "letrec", "letrec*", "if", "cond", "case",
+    "and", "or", "not", "begin", "set!", "quote", "quasiquote", "unquote", "do",
+    "delay", "values", "call-with-values", "else", "define-record-type",
+    "sqrt", "abs", "sin", "cos", "tan", "asin", "acos", "atan", "exp", "log",
+    "expt", "floor", "ceiling", "round", "truncate", "min", "max",
+]);
+
+function checkReservedNames(names) {
+    for (const name of names) {
+        if (SCHEME_RESERVED.has(name)) {
+            throw new Error(
+                `emitter for .scm: "${name}" is a reserved Scheme special form/procedure name and can't be used ` +
+                `as a function/variable/parameter name -- rename it (see SCHEME_RESERVED in emitters/scheme.js)`,
+            );
+        }
+    }
+}
+
+class SchemeEmitter extends Emitter {
+    emitExpr(node) {
+        if (node.type === "bin") {
+            // ast.js's op set (+ - * /) is already valid Scheme procedure-
+            // position syntax verbatim -- no translation table needed,
+            // just moving it from infix to prefix position.
+            return `(${node.op} ${this.emitExpr(node.left)} ${this.emitExpr(node.right)})`;
+        }
+        return super.emitExpr(node);
+    }
+}
+
+function fn1(name) {
+    return ([x]) => `(${name} ${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `(${name} ${a} ${b})`;
+}
+
+const emitter = new SchemeEmitter({
+    ext: "scm",
+    // Guile accepts JS-style numeric literal syntax directly, including
+    // exponential notation ("1e-9") -- no conversion needed for the digits
+    // themselves. But a bare integer literal like "2" is EXACT in Scheme's
+    // reader syntax, and exact arithmetic that never happens to touch an
+    // inexact (float) operand stays exact -- confirmed a real compiler
+    // prints (/ 1 3) as the fraction "1/3", not "0.333...". Every literal
+    // this project emits is meant to behave as an IEEE double like every
+    // other target, so any literal with neither a decimal point nor an
+    // exponent marker gets ".0" appended, forcing inexactness by literal
+    // syntax alone -- not relying on some other operand in the same
+    // expression happening to already be inexact.
+    formatNumber: (v) => {
+        const s = String(v);
+        return /[.e]/i.test(s) ? s : `${s}.0`;
+    },
+    calls: {
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), exp: fn1("exp"), log: fn1("log"),
+        // expt is Scheme's exponentiation procedure -- there's no infix **.
+        pow: fn2("expt"),
+        // R7RS's 2-argument atan IS atan2 -- no separate name for it.
+        atan2: fn2("atan"),
+        // No log2/log10 procedure in R7RS or Guile's core -- derive both.
+        log2: ([x]) => `(/ (log ${x}) (log 2.0))`,
+        log10: ([x]) => `(/ (log ${x}) (log 10.0))`,
+        floor: fn1("floor"), ceil: fn1("ceiling"),
+        // Guile's round is round-half-to-even (banker's rounding), not the
+        // round-half-away-from-zero most other targets here use -- same
+        // already-documented, already-avoided-in-tests divergence as
+        // Lua's/Julia's round(), not a new one (see
+        // test/conformance.test.js's kitchen-sink comment).
+        round: fn1("round"),
+        trunc: fn1("truncate"),
+        min: fn2("min"), max: fn2("max"),
+        // No hypot procedure -- derive it directly.
+        hypot: ([a, b]) => `(sqrt (+ (* ${a} ${a}) (* ${b} ${b})))`,
+        // No sign procedure either -- build it directly. Zero-aware by
+        // construction (see Go's/Rust's sign() history in this project for
+        // what happens when it isn't).
+        sign: ([x]) => `(if (> ${x} 0.0) 1.0 (if (< ${x} 0.0) -1.0 0.0))`,
+    },
+    // Scheme's `if` already IS an expression (no separate statement form),
+    // so this is the most direct emitSelect override of any target here --
+    // just prefix notation for the comparison, same as every "bin" node.
+    // "!=" needs `(not (= ...))`: R7RS has no single-procedure not-equal.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        const condExpr =
+            condNode.op === "!=" ? `(not (= ${L} ${R}))` : `(${condNode.op === "==" ? "=" : condNode.op} ${L} ${R})`;
+        return `(if ${condExpr} ${thenStr} ${elseStr})`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        checkReservedNames([fn.name, ...fn.params, ...letBindings.map((b) => b.name)]);
+        const params = fn.params.join(" ");
+        // let* (not let): each binding can see every earlier one, matching
+        // the dependency order collectLets already produced -- exactly
+        // what our flat, ordered bindings list needs, no extra nesting.
+        if (letBindings.length === 0) {
+            return `;; AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+                   `(define (${fn.name} ${params})\n` +
+                   `  ${body})\n`;
+        }
+        const lets = letBindings.map(({ name, valueStr }) => `         (${name} ${valueStr})`).join("\n");
+        return `;; AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `(define (${fn.name} ${params})\n` +
+               `  (let* (${lets.trimStart()})\n` +
+               `    ${body}))\n`;
+    },
+    // Multiple named outputs from one call: Scheme's native (values ...)
+    // -- same idea as Lua's native multiple return, positional rather than
+    // named, so a leading comment documents field order (matching Lua's
+    // convention here) since Scheme's values have no names at the call
+    // site.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const outputNames = Object.keys(outputStrs);
+        checkReservedNames([fn.name, ...fn.params, ...outputNames, ...letBindings.map((b) => b.name)]);
+        const params = fn.params.join(" ");
+        const returnExpr = `(values ${outputNames.map((n) => outputStrs[n]).join(" ")})`;
+        const header =
+            `;; AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+            `;; Returns (values ${outputNames.join(" ")}).\n`;
+        if (letBindings.length === 0) {
+            return header + `(define (${fn.name} ${params})\n` + `  ${returnExpr})\n`;
+        }
+        const lets = letBindings.map(({ name, valueStr }) => `         (${name} ${valueStr})`).join("\n");
+        return header +
+               `(define (${fn.name} ${params})\n` +
+               `  (let* (${lets.trimStart()})\n` +
+               `    ${returnExpr}))\n`;
+    },
+});
+
+module.exports = emitter;