openscad-cpp-evaluator 1.1.0__tar.gz → 1.3.0__tar.gz

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.1.0
+Version: 1.3.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

openscad_cpp_evaluator-1.3.0/include/openscad_cpp_evaluator/format_closure.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+
+namespace oscad {
+class FunctionLiteral;
+}
+
+namespace oscadeval {
+
+// A function literal spelled the way the reference spells it when a script
+// does `str(f)` or `echo(f)`: its own source, re-printed from the AST with
+// every binary operator and ternary parenthesised.
+//
+// Deliberately not the parser's ASTNode::toString(), which is
+// precedence-minimal and which 94 places inside the parser depend on. See
+// format_closure.cpp for where each rule came from.
+std::string formatFunctionLiteral(const oscad::FunctionLiteral& fn);
+
+} // namespace oscadeval

openscad_cpp_evaluator-1.3.0/include/openscad_cpp_evaluator/osc_range.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <cmath>
+
+namespace oscadeval {
+
+// `[start:step:end]` -- a plain 3-slot struct, not an expanded list. Mirrors
+// the Python reference's OscRange object exactly: echoed as
+// "[start : step : end]", only expanded to a list when iterated (for/list
+// comprehension/intersection_for).
+struct OscRange {
+    double start = 0.0;
+    double step = 1.0;
+    double end = 0.0;
+
+    // Yields nothing: a zero step, a direction that disagrees with the
+    // bounds, or a NaN anywhere in it.
+    bool isEmpty() const {
+        if (std::isnan(start) || std::isnan(step) || std::isnan(end)) return true;
+        if (step == 0.0) return true;
+        return (end - start) / step < -1e-10;
+    }
+
+    // Two EMPTY ranges are equal whatever their bounds -- the reference
+    // compares element counts first, so `[5:1:0] == [10:1:0]` is true, and
+    // so is `[0:nan:inf] == [5:1:0]`. Only if both yield something does it
+    // compare start/step/end.
+    //
+    // This is not a NaN rule, though a NaN range is caught by it: checked
+    // against the reference, `nan == nan` is false and `[nan] == [nan]` is
+    // false, so nothing else treats NaN as equal to itself. Ranges are
+    // special because emptiness is.
+    //
+    // It matters well beyond range comparison: BOSL2 defines
+    // `is_nan(x) = (x != x)`, so a self-unequal range made typeof() answer
+    // "nan" for one, where the reference says "invalid".
+    friend bool operator==(const OscRange& a, const OscRange& b) {
+        const bool ae = a.isEmpty(), be = b.isEmpty();
+        if (ae || be) return ae && be;
+        return a.start == b.start && a.step == b.step && a.end == b.end;
+    }
+};
+
+} // namespace oscadeval

openscad_cpp_evaluator-1.3.0/include/openscad_cpp_evaluator/utf8.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+// A string is a sequence of CHARACTERS to a script, not of bytes. The
+// reference reports len("aé—z") as 4, indexes s[1] to "é", and iterates the
+// same four characters -- while a std::string holds 8 bytes for that. These
+// three are what keeps the two views apart.
+//
+// Storage stays UTF-8. Indexing therefore scans, which is O(n) per index and
+// so O(n^2) over a loop -- BOSL2's _str_count_leading is exactly that loop.
+// The saving grace is that a pure-ASCII string needs no scan at all: byte i
+// IS character i, and every function here takes that path first. Only a
+// string that actually holds non-ASCII pays, and those are short in
+// practice.
+
+// True when every byte is < 0x80, so byte offsets and character offsets are
+// the same thing.
+bool utf8IsAscii(const std::string& s);
+
+// Characters, not bytes. Counts lead bytes, so a malformed sequence counts
+// the same way the reference's own decoder would rather than throwing.
+size_t utf8Length(const std::string& s);
+
+// The i-th character as its own string; empty if i is past the end. Empty is
+// distinguishable from a real result because a character is never zero-length.
+std::string utf8CharAt(const std::string& s, size_t i);
+
+// Every character as its own string.
+std::vector<std::string> utf8Chars(const std::string& s);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.1.0"
+version = "1.3.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.3.0}/src/CMakeLists.txt

@@ -1,5 +1,7 @@
 add_library(openscad_cpp_evaluator STATIC
   value.cpp
+  utf8.cpp
+  format_closure.cpp
   eval_error.cpp
   eval_context.cpp
   expr_eval.cpp

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.3.0}/src/builtins/booleans.cpp

@@ -214,7 +214,15 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;
 
     std::vector<ColoredBody> allBg, allHi, allSo, allDo;
-    std::optional<ColoredBody> csgResult;
+    // Two accumulators, one per dimension. union() may legitimately carry
+    // both -- `translate(...) { part(); text("label"); }` is how a docs
+    // figure annotates a 3D part, and the reference draws both -- and a
+    // single optional that switched between body and section is exactly
+    // what used to be dereferenced empty when a group changed dimension
+    // part-way. difference and intersection still see one dimension only:
+    // applyDimensionRules drops the mismatch before it gets here, so for
+    // them just one of these is ever populated.
+    std::optional<ColoredBody> res3d, res2d;
     size_t idx = 0;
 
     size_t stmtIndex = 0;
@@ -273,50 +281,56 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             // discards while no positive operand has been established yet;
             // union just skips the empty contributor and keeps going.
             if (op == "intersection") {
-                csgResult.reset();
+                res3d.reset();
+                res2d.reset();
                 break;
             }
-            if (op == "difference" && !csgResult) break;
+            if (op == "difference" && !res3d && !res2d) break;
             continue;
         }
 
+        // Each dimension accumulates on its own, so a statement holding
+        // both contributes to both rather than the 2D half falling off the
+        // end of an if/else.
         if (!bodies3d.empty()) {
             manifold::Manifold grp = *bodies3d.front().body;
             for (size_t i = 1; i < bodies3d.size(); ++i) grp = grp + *bodies3d[i].body;
-            if (!csgResult) {
+            if (!res3d) {
                 ColoredBody cb;
                 cb.body = std::move(grp);
                 cb.color = bodies3d.front().color;
-                csgResult = std::move(cb);
+                res3d = std::move(cb);
             } else if (op == "union") {
-                csgResult->body = *csgResult->body + grp;
+                res3d->body = *res3d->body + grp;
             } else if (op == "difference") {
-                csgResult->body = *csgResult->body - grp;
+                res3d->body = *res3d->body - grp;
             } else if (op == "intersection") {
-                csgResult->body = *csgResult->body ^ grp;
+                res3d->body = *res3d->body ^ grp;
             }
-        } else {
+        }
+        if (!sections2d.empty()) {
             manifold::CrossSection grp = *sections2d.front().section;
             for (size_t i = 1; i < sections2d.size(); ++i) grp = grp + *sections2d[i].section;
-            if (!csgResult) {
+            if (!res2d) {
                 ColoredBody cb;
                 cb.section = std::move(grp);
                 cb.color = sections2d.front().color;
-                csgResult = std::move(cb);
+                res2d = std::move(cb);
             } else if (op == "union") {
-                csgResult->section = *csgResult->section + grp;
+                res2d->section = *res2d->section + grp;
             } else if (op == "difference") {
-                csgResult->section = *csgResult->section - grp;
+                res2d->section = *res2d->section - grp;
             } else if (op == "intersection") {
-                csgResult->section = *csgResult->section ^ grp;
+                res2d->section = *res2d->section ^ grp;
             }
         }
     }
 
-    if (csgResult && csgResult->body) attachTriColors(ev, *csgResult);
+    if (res3d && res3d->body) attachTriColors(ev, *res3d);
 
     std::vector<ColoredBody> result;
-    if (csgResult) result.push_back(std::move(*csgResult));
+    if (res3d) result.push_back(std::move(*res3d));
+    if (res2d) result.push_back(std::move(*res2d));
     result.insert(result.end(), allBg.begin(), allBg.end());
     result.insert(result.end(), allHi.begin(), allHi.end());
     result.insert(result.end(), allSo.begin(), allSo.end());

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.3.0}/src/builtins/function_builtins.cpp

@@ -6,6 +6,7 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/segments.hpp"
 #include "openscad_cpp_evaluator/text_metrics.hpp"
+#include "openscad_cpp_evaluator/utf8.hpp"
 
 #include "openscad_cpp_parser/ast/ast_node.hpp"
 
@@ -613,10 +614,24 @@ Value builtinRands(double minv, double maxv, double nArg, const Value& seedArg)
 // a sequence of characters -- a `search(["a"], "abc")` vector needle sees
 // that same string as an empty table, not as characters.
 Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position* pos) {
-    const Value matchArg = getArg(args, 0, "match", Value{});
-    const Value tableArg = getArg(args, 1, "vector", Value{});
-    const double nrRaw = toDoubleLenient(getArg(args, 2, "num_returns", Value{1.0}));
-    const double icRaw = toDoubleLenient(getArg(args, 3, "index_col", Value{0.0}));
+    // The reference's own documented parameter names. These used to be
+    // "match"/"vector"/"num_returns"/"index_col", which are not names
+    // OpenSCAD ever documented, so a script written against the manual --
+    // BOSL2's in_list(), which passes num_returns_per_match and
+    // index_col_num -- bound neither and silently got the defaults.
+    //
+    // Worth knowing, though deliberately NOT copied: the reference ignores
+    // these names altogether and binds search() purely by position.
+    // `search(zzz=m, qqq=t, www=1, eee=1)` returns the right answer there,
+    // while the correct names in the wrong order return the wrong one.
+    // CallArgs keeps positional and named arguments apart and does not
+    // record where a named one was written, so matching that would mean
+    // changing how every call collects its arguments -- for a quirk no
+    // script relies on deliberately.
+    const Value matchArg = getArg(args, 0, "match_value", Value{});
+    const Value tableArg = getArg(args, 1, "string_or_vector", Value{});
+    const double nrRaw = toDoubleLenient(getArg(args, 2, "num_returns_per_match", Value{1.0}));
+    const double icRaw = toDoubleLenient(getArg(args, 3, "index_col_num", Value{0.0}));
     // Both are `unsigned int` in the reference, so a negative argument wraps
     // to a huge positive rather than meaning "unlimited"/"column 0".
     const unsigned numReturns = static_cast<unsigned>(static_cast<long long>(nrRaw));
@@ -654,11 +669,17 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
     if (const std::string* needle = std::get_if<std::string>(&matchArg)) {
         std::vector<Value> out;
         if (const std::string* hay = std::get_if<std::string>(&tableArg)) {
-            for (size_t i = 0; i < needle->size(); ++i) {
+            // Both sides walked as CHARACTERS, and the indices reported are
+            // character indices. Comparing bytes made a multi-byte needle
+            // search once per byte -- search("é", "aé—z") answered [1, 2]
+            // where the reference answers [1].
+            const std::vector<std::string> needleChars = utf8Chars(*needle);
+            const std::vector<std::string> hayChars = utf8Chars(*hay);
+            for (size_t i = 0; i < needleChars.size(); ++i) {
                 unsigned matchCount = 0;
                 std::vector<Value> resultvec;
-                for (size_t j = 0; j < hay->size(); ++j) {
-                    if ((*needle)[i] != (*hay)[j]) continue;
+                for (size_t j = 0; j < hayChars.size(); ++j) {
+                    if (needleChars[i] != hayChars[j]) continue;
                     ++matchCount;
                     if (numReturns == 1) {
                         out.push_back(num(j));
@@ -675,7 +696,10 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
         // with more than index_col elements. A single bad entry aborts the
         // WHOLE call with an empty result, not just that row -- which is
         // why `search("a", ["a","b"])` is [] and not [0].
-        for (size_t i = 0; i < needle->size(); ++i) {
+        // Character-wise here too: a needle character is what gets looked
+        // up in each row, so a multi-byte one must not be split.
+        const std::vector<std::string> needleChars = utf8Chars(*needle);
+        for (size_t i = 0; i < needleChars.size(); ++i) {
             unsigned matchCount = 0;
             std::vector<Value> resultvec;
             for (size_t j = 0; j < table.size(); ++j) {
@@ -689,7 +713,10 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
                 }
                 const std::string* entry = std::get_if<std::string>(&entryVec[indexCol]);
                 // A type mismatch just doesn't match, exactly as `==` would.
-                if (!entry || entry->empty() || (*entry)[0] != (*needle)[i]) continue;
+                // First CHARACTER of the entry against the needle character:
+                // comparing first bytes made "é" and any other character
+                // sharing a lead byte look equal.
+                if (!entry || entry->empty() || utf8CharAt(*entry, 0) != needleChars[i]) continue;
                 ++matchCount;
                 if (numReturns == 1) {
                     out.push_back(num(j));
@@ -1367,7 +1394,8 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
         case BuiltinFnId::Len: {
             const Value x = getArg(args, 0, "x", Value{});
             if (const ListPtr* l = std::get_if<ListPtr>(&x); l && *l) return Value{static_cast<double>((*l)->items.size())};
-            if (const std::string* s = std::get_if<std::string>(&x)) return Value{static_cast<double>(s->size())};
+            // Characters, not bytes: the reference reports len("aé—z") as 4.
+            if (const std::string* s = std::get_if<std::string>(&x)) return Value{static_cast<double>(utf8Length(*s))};
             if (const ObjectPtr* o = std::get_if<ObjectPtr>(&x); o && *o) return Value{static_cast<double>((*o)->items.size())};
             return Value{};
         }

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.3.0}/src/csg_generate.cpp

@@ -129,6 +129,20 @@ enum class DimRule {
     None,    // no dimension diagnostics at all
 };
 
+// Nodes that hand their children on as a list instead of combining them
+// into one result, so a mixed 2D/3D list reaches nothing that has to pick a
+// single dimension. generateTransform and generateColor map over the
+// bodies; generateCsg's union keeps a 3D and a 2D accumulator side by side.
+//
+// difference and intersection are deliberately absent: subtracting or
+// intersecting across dimensions has no meaning, and they still collapse to
+// one result. hull and minkowski likewise build a single hull.
+bool keepsMixedDimensions(const std::string& kind) {
+    return kind == "union" || kind == "color" || kind == "translate" ||
+           kind == "rotate" || kind == "scale" || kind == "mirror" ||
+           kind == "multmatrix" || kind == "resize";
+}
+
 DimRule dimRuleFor(const std::string& kind) {
     if (kind == "linear_extrude" || kind == "rotate_extrude" || kind == "offset") return DimRule::Only2D;
     if (kind == "projection") return DimRule::Only3D;
@@ -168,7 +182,11 @@ void Evaluator::applyDimensionRules(CSGNode& node) {
     std::vector<CSGNode*> kids;
     kids.reserve(node.children.size());
     for (const std::unique_ptr<CSGNode>& c : node.children) kids.push_back(c.get());
-    applyDimensionRulesTo(kids, static_cast<int>(rule));
+    // Only a Group-rule node can keep a mix. linear_extrude and friends take
+    // one dimension by definition, so a wrong-dimension child there is still
+    // dropped with its warning.
+    const bool keepMixed = rule == DimRule::Group && keepsMixedDimensions(node.kind);
+    applyDimensionRulesTo(kids, static_cast<int>(rule), keepMixed);
 }
 
 // `keepMixed` warns about a mixed group but drops nothing -- the top level's
@@ -199,7 +217,12 @@ void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int
                 continue;
             }
             const oscad::Position* pos = child->node ? &child->node->position() : nullptr;
-            if (rule == DimRule::Group && !warnedMixing) {
+            // Silent when both are kept: the reference says nothing for
+            // `cube(1); square(4);`, `translate(...) { ... }` or `union()
+            // { ... }` -- checked by running it -- and a warning here would
+            // fail any docs example that legitimately draws a 2D annotation
+            // beside a 3D part.
+            if (rule == DimRule::Group && !keepMixed && !warnedMixing) {
                 warn("Mixing 2D and 3D objects is not supported", pos);
                 warnedMixing = true;
             }

{openscad_cpp_evaluator-1.1.0 → openscad_cpp_evaluator-1.3.0}/src/expr_eval.cpp

@@ -1,4 +1,5 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/utf8.hpp"
 
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/eval_error.hpp"
@@ -803,8 +804,13 @@ Value Evaluator::applyIndexAccess(const Value& obj, const Value& idx) {
     if (const std::string* s = std::get_if<std::string>(&obj)) {
         if (const double* d = std::get_if<double>(&idx)) {
             const int i = static_cast<int>(*d);
-            if (i < 0 || static_cast<size_t>(i) >= s->size()) return Value{};
-            return Value{std::string(1, (*s)[static_cast<size_t>(i)])};
+            if (i < 0) return Value{};
+            // The i-th CHARACTER. Taking byte i split a multi-byte one and
+            // handed back half of it, which then failed to decode at the
+            // boundary -- an error, not merely a wrong answer.
+            std::string ch = utf8CharAt(*s, static_cast<size_t>(i));
+            if (ch.empty()) return Value{};
+            return Value{std::move(ch)};
         }
         return Value{};
     }

openscad_cpp_evaluator-1.3.0/src/format_closure.cpp

@@ -0,0 +1,217 @@
+// Printing a function literal back out as source, the way the reference
+// spells it when you `str()` or `echo()` one.
+//
+// Neither existing printer would do. The parser's own ASTNode::toString()
+// is precedence-MINIMAL -- it drops any parenthesis the grammar does not
+// need -- and 94 places inside the parser depend on that spelling. The
+// reference is the opposite: it parenthesises every binary operator and
+// every ternary whether or not precedence requires it, so `f(a + b)` comes
+// back as `f((a + b))`.
+//
+// BOSL2's fnliterals tests compare these strings exactly (61 of them), so
+// this has to agree with the reference character for character. Every rule
+// below was read off the reference by echoing the shape and copying what it
+// printed -- see test_format_closure.cpp, which carries the same shapes as
+// cases.
+#include "openscad_cpp_evaluator/format_closure.hpp"
+
+#include <string>
+
+#include "openscad_cpp_parser/ast.hpp"
+
+namespace oscadeval {
+namespace {
+
+using oscad::ASTNode;
+using oscad::NodeKind;
+
+std::string fmt(const ASTNode& n);
+
+// `(a + b)`, always. The reference parenthesises a binary operator
+// unconditionally -- nesting one inside another gives `((a + b) + c)`, and
+// even a call argument gets them: `f((a + b))`.
+//
+// Templated on the node type rather than casting every operator to one of
+// them. The binary classes are generated by a single macro so they do share
+// a layout, but they are distinct types with no common binary base, and
+// casting a MultiplicationOp to an AdditionOp would be undefined however
+// reliably it happens to work.
+template <typename T>
+std::string binary(const ASTNode& n, const char* op) {
+    const auto& e = static_cast<const T&>(n);
+    return "(" + fmt(*e.left) + " " + op + " " + fmt(*e.right) + ")";
+}
+
+// `-x`, not `(-x)`. A unary operator is never parenthesised itself, though
+// its operand still follows the rules: `-(a + b)`.
+template <typename T>
+std::string unary(const ASTNode& n, const char* op) {
+    const auto& e = static_cast<const T&>(n);
+    return std::string(op) + fmt(*e.expr);
+}
+
+template <typename Seq>
+std::string join(const Seq& items, const char* sep) {
+    std::string out;
+    for (size_t i = 0; i < items.size(); ++i) {
+        if (i) out += sep;
+        out += fmt(*items[i]);
+    }
+    return out;
+}
+
+// A list-comprehension body is wrapped, on top of whatever the body itself
+// prints: `[for(i = [0 : a]) ((i + 1))]`, and `(i)` for a bare identifier.
+// A plain vector element is NOT wrapped -- `[1, (2 + 3), a]` -- so the
+// parentheses belong to for/if/each rather than to the vector.
+std::string wrapped(const ASTNode& n) { return "(" + fmt(n) + ")"; }
+
+std::string fmt(const ASTNode& n) {
+    switch (n.kind()) {
+    case NodeKind::Identifier:
+        return static_cast<const oscad::Identifier&>(n).name;
+    case NodeKind::StringLiteral:
+    case NodeKind::NumberLiteral:
+    case NodeKind::BooleanLiteral:
+    case NodeKind::UndefinedLiteral:
+        // The parser already spells these the way the reference does,
+        // escaping and number formatting included.
+        return n.toString();
+
+    case NodeKind::RangeLiteral: {
+        const auto& r = static_cast<const oscad::RangeLiteral&>(n);
+        // implicitStep, not just `step != nullptr`: the parser fills in a
+        // step of 1 for `[0:a]`, and printing it back gives `[0 : 1 : a]`
+        // where the reference says `[0 : a]`. The flag is there to tell the
+        // two apart.
+        std::string s = "[" + fmt(*r.start) + " : ";
+        if (r.step && !r.implicitStep) s += fmt(*r.step) + " : ";
+        return s + fmt(*r.end) + "]";
+    }
+
+    case NodeKind::UnaryMinusOp: return unary<oscad::UnaryMinusOp>(n, "-");
+    case NodeKind::LogicalNotOp: return unary<oscad::LogicalNotOp>(n, "!");
+    case NodeKind::BitwiseNotOp: return unary<oscad::BitwiseNotOp>(n, "~");
+
+    case NodeKind::AdditionOp:            return binary<oscad::AdditionOp>(n, "+");
+    case NodeKind::SubtractionOp:         return binary<oscad::SubtractionOp>(n, "-");
+    case NodeKind::MultiplicationOp:      return binary<oscad::MultiplicationOp>(n, "*");
+    case NodeKind::DivisionOp:            return binary<oscad::DivisionOp>(n, "/");
+    case NodeKind::ModuloOp:              return binary<oscad::ModuloOp>(n, "%");
+    case NodeKind::ExponentOp:            return binary<oscad::ExponentOp>(n, "^");
+    case NodeKind::BitwiseAndOp:          return binary<oscad::BitwiseAndOp>(n, "&");
+    case NodeKind::BitwiseOrOp:           return binary<oscad::BitwiseOrOp>(n, "|");
+    case NodeKind::BitwiseShiftLeftOp:    return binary<oscad::BitwiseShiftLeftOp>(n, "<<");
+    case NodeKind::BitwiseShiftRightOp:   return binary<oscad::BitwiseShiftRightOp>(n, ">>");
+    case NodeKind::LogicalAndOp:          return binary<oscad::LogicalAndOp>(n, "&&");
+    case NodeKind::LogicalOrOp:           return binary<oscad::LogicalOrOp>(n, "||");
+    case NodeKind::EqualityOp:            return binary<oscad::EqualityOp>(n, "==");
+    case NodeKind::InequalityOp:          return binary<oscad::InequalityOp>(n, "!=");
+    case NodeKind::GreaterThanOp:         return binary<oscad::GreaterThanOp>(n, ">");
+    case NodeKind::GreaterThanOrEqualOp:  return binary<oscad::GreaterThanOrEqualOp>(n, ">=");
+    case NodeKind::LessThanOp:            return binary<oscad::LessThanOp>(n, "<");
+    case NodeKind::LessThanOrEqualOp:     return binary<oscad::LessThanOrEqualOp>(n, "<=");
+
+    case NodeKind::TernaryOp: {
+        const auto& t = static_cast<const oscad::TernaryOp&>(n);
+        return "(" + fmt(*t.condition) + " ? " + fmt(*t.trueExpr) + " : " + fmt(*t.falseExpr) + ")";
+    }
+
+    case NodeKind::PrimaryCall: {
+        const auto& c = static_cast<const oscad::PrimaryCall&>(n);
+        return fmt(*c.left) + "(" + join(c.arguments, ", ") + ")";
+    }
+    case NodeKind::PrimaryIndex: {
+        const auto& i = static_cast<const oscad::PrimaryIndex&>(n);
+        return fmt(*i.left) + "[" + fmt(*i.index) + "]";
+    }
+    case NodeKind::PrimaryMember: {
+        const auto& m = static_cast<const oscad::PrimaryMember&>(n);
+        return fmt(*m.left) + "." + m.member->name;
+    }
+
+    case NodeKind::PositionalArgument:
+        return fmt(*static_cast<const oscad::PositionalArgument&>(n).expr);
+    case NodeKind::NamedArgument: {
+        const auto& a = static_cast<const oscad::NamedArgument&>(n);
+        return a.name->name + " = " + fmt(*a.expr);
+    }
+    case NodeKind::Assignment: {
+        const auto& a = static_cast<const oscad::Assignment&>(n);
+        return a.name->name + " = " + fmt(*a.expr);
+    }
+    case NodeKind::ParameterDeclaration: {
+        const auto& p = static_cast<const oscad::ParameterDeclaration&>(n);
+        return p.defaultValue ? p.name->name + " = " + fmt(*p.defaultValue) : p.name->name;
+    }
+
+    case NodeKind::FunctionLiteral: {
+        const auto& f = static_cast<const oscad::FunctionLiteral&>(n);
+        return "function(" + join(f.parameters, ", ") + ") " + fmt(*f.body);
+    }
+    case NodeKind::LetOp: {
+        const auto& l = static_cast<const oscad::LetOp&>(n);
+        // Body bare: `let(c = (a + b)) c`. What looks like a wrapped body
+        // in `let(a = 1) (a + x)` is the binary parenthesising itself.
+        return "let(" + join(l.assignments, ", ") + ") " + fmt(*l.body);
+    }
+    case NodeKind::EchoOp: {
+        const auto& e = static_cast<const oscad::EchoOp&>(n);
+        return "echo(" + join(e.arguments, ", ") + ") " + fmt(*e.body);
+    }
+    case NodeKind::AssertOp: {
+        const auto& a = static_cast<const oscad::AssertOp&>(n);
+        return "assert(" + join(a.arguments, ", ") + ") " + fmt(*a.body);
+    }
+
+    case NodeKind::ListComprehension: {
+        const auto& c = static_cast<const oscad::ListComprehension&>(n);
+        return "[" + join(c.elements, ", ") + "]";
+    }
+    case NodeKind::ListCompFor: {
+        const auto& f = static_cast<const oscad::ListCompFor&>(n);
+        return "for(" + join(f.assignments, ", ") + ") " + wrapped(*f.body);
+    }
+    case NodeKind::ListCompCFor: {
+        const auto& f = static_cast<const oscad::ListCompCFor&>(n);
+        // The odd one out: no space after the semicolons, and the body is
+        // NOT wrapped -- `[for(i = 0;(i < a);i = (i + 1)) i]`.
+        return "for(" + join(f.inits, ", ") + ";" + fmt(*f.condition) + ";" +
+               join(f.incrs, ", ") + ") " + fmt(*f.body);
+    }
+    case NodeKind::ListCompIf: {
+        const auto& i = static_cast<const oscad::ListCompIf&>(n);
+        return "if(" + fmt(*i.condition) + ") " + wrapped(*i.trueExpr);
+    }
+    case NodeKind::ListCompIfElse: {
+        const auto& i = static_cast<const oscad::ListCompIfElse&>(n);
+        return "if(" + fmt(*i.condition) + ") " + wrapped(*i.trueExpr) +
+               " else " + wrapped(*i.falseExpr);
+    }
+    case NodeKind::ListCompEach: {
+        const auto& e = static_cast<const oscad::ListCompEach&>(n);
+        return "each " + wrapped(*e.body);
+    }
+    case NodeKind::ListCompLet: {
+        const auto& l = static_cast<const oscad::ListCompLet&>(n);
+        return "let(" + join(l.assignments, ", ") + ") " + fmt(*l.body);
+    }
+
+    case NodeKind::CommentedExpr:
+        // Comments are not part of what the reference prints.
+        return fmt(*static_cast<const oscad::CommentedExpr&>(n).expr);
+
+    default:
+        // Anything not reachable from inside a function literal's body --
+        // statements, module instantiations, include directives. Falling
+        // back to the parser's own spelling is closer than an empty string,
+        // and the value here is diagnostic rather than compared.
+        return n.toString();
+    }
+}
+
+} // namespace
+
+std::string formatFunctionLiteral(const oscad::FunctionLiteral& fn) { return fmt(fn); }
+
+} // namespace oscadeval