openscad-cpp-evaluator 0.38.1__tar.gz → 0.40.0__tar.gz

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/CLAUDE.md

@@ -1128,6 +1128,20 @@ vector and `oscEqual` is order-sensitive):
 `vnf` is the `[vertices, faces]` 2-list BOSL2 functions actually take.
 `polyhedron()` and `polygon()` also accept the object directly, and will accept
 *any* object carrying the right keys, not just one `render()` produced.
+`polyhedron()` additionally accepts the bare `[vertices, faces]` 2-list, so a
+BOSL2 VNF goes straight in — all four of these are the same call:
+
+```openscad
+polyhedron(obj);                        // the object
+polyhedron(obj.vnf);                    // the 2-list
+polyhedron(obj.vertices, obj.faces);    // the halves
+polyhedron(spheroid(d=30));             // any BOSL2 VNF
+```
+
+The 2-list form is only considered when `faces` was not given separately, so the
+two-argument call can never be reinterpreted. The discriminator is BOSL2's own
+`is_vnf` test — a VNF's second element is a list of *lists*, where a plain points
+list has a point (bare numbers) there.
 
 ### Things that will bite
 

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/include/openscad_cpp_evaluator/function_builtins.hpp

@@ -41,7 +41,8 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
 // evaluated exactly once (resolving into a CallArgs first and then
 // re-evaluating from the raw list here would run every argument expression
 // twice -- wrong for anything with a side effect, e.g. rands()).
-Value builtinObject(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx);
+Value builtinObject(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx,
+                     const oscad::ASTNode& node);
 
 // The shared merge core builtinObject wraps: given ALREADY-EVALUATED
 // (name-or-nullopt, Value) pairs in exact call-site order, merges them the
@@ -52,6 +53,7 @@ Value builtinObject(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Argu
 // logic against its own already-evaluated (argNames[i], args[i]) pairs
 // (already in call-site order by construction -- see CallSite::argNames)
 // without re-deriving the merge rules or touching raw AST nodes.
-Value mergeObjectArgs(const std::vector<std::pair<std::optional<std::string>, Value>>& evaluated);
+Value mergeObjectArgs(Evaluator& ev, const std::vector<std::pair<std::optional<std::string>, Value>>& evaluated,
+                       const oscad::Position* pos);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/include/openscad_cpp_evaluator/value.hpp

@@ -355,6 +355,20 @@ private:
 // it, keeping expandIterable() itself free of any Evaluator/echo coupling.
 using RangeTooManyFn = std::function<void(size_t count)>;
 
+// Called when a range's step points AWAY from its end -- begin > end with a
+// positive step, or begin < end with a negative step. Such a range is
+// naturally empty, and the reference warns rather than iterating zero times
+// in silence. `stepPositive` picks which of its two messages applies; use
+// rangeDirectionWarning() to build the text.
+//
+// Separate from RangeTooManyFn for the same reason that one exists: it
+// keeps expandIterable() free of any Evaluator/echo coupling.
+using RangeDirectionFn = std::function<void(bool stepPositive)>;
+
+// The reference's own wording, quoted verbatim, for a range whose step
+// points away from its end. Shared so the five call sites cannot drift.
+std::string rangeDirectionWarning(bool stepPositive);
+
 // Converts a for()/intersection_for() loop assignment's evaluated RHS into
 // the sequence of values to iterate: undef -> empty, range -> a LAZY
 // sequence (matching OscRange's own start/step/end iteration, half-open
@@ -380,7 +394,8 @@ using RangeTooManyFn = std::function<void(size_t count)>;
 // one with a live consumer (BelfrySCAD) that surfaced it. The count is
 // computed in closed form (not IterableValues::size()'s O(n) walk) so a
 // legitimate huge-but-under-the-limit range never pays an eager pass.
-IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany = nullptr);
+IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany = nullptr,
+                               const RangeDirectionFn& onWrongDirection = nullptr);
 
 // `each <body>`'s own flatten-one-level rule, shared by the AST interpreter
 // (evalListLiteral/evalListElement's ListCompEach handling, expr_eval.cpp)

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/builtins/control.cpp

@@ -128,6 +128,8 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
         const oscad::Position* pos = &assign->position();
         IterableValues iter = expandIterable(values, [&](size_t count) {
             ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
+        }, [&](bool stepPositive) {
+            ev.warn(rangeDirectionWarning(stepPositive), pos);
         });
         for (const Value& val : iter) {
             EvalContext childCtx = parentCtx.childCtx(nullptr, std::nullopt, ctx.childrenNodes, ctx.childrenCallerCtx);

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/builtins/function_builtins.cpp

@@ -454,7 +454,33 @@ bool isBuiltinFunctionName(const std::string& name) {
     return names.count(name) > 0;
 }
 
-Value mergeObjectArgs(const std::vector<std::pair<std::optional<std::string>, Value>>& evaluated) {
+// object(...) argument merging, matching the reference's own semantics and
+// diagnostics (Builtins.cc's builtin_object).
+//
+// An unnamed argument is either another object (its keys are merged in) or
+// a LIST of entries, where each entry is:
+//   [key, value]  -- set (or overwrite) that key
+//   [key]         -- DELETE that key
+//
+// The single-element delete form is the part that is easy to miss. Deleting
+// removes the key outright rather than blanking it, so a later re-set
+// appends at the end: object(a, [["b"], ["b", 99]]) puts b last, while
+// object(a, [["b", 99], ["b"]]) has no b at all. That ordering is
+// observable -- ValueObject is insertion-ordered and oscEqual is
+// order-sensitive.
+//
+// Deleting a key that is not there is a silent no-op, as it is upstream.
+// Every malformed entry warns and abandons the whole call (returning undef),
+// stopping at the first one. The warning text is quoted verbatim from the
+// reference, including its own inconsistent spacing -- the "not a list"
+// case really does put spaces inside the parens where the others do not,
+// and the "unnamed argument" case really does end with a trailing space.
+Value mergeObjectArgs(Evaluator& ev, const std::vector<std::pair<std::optional<std::string>, Value>>& evaluated,
+                       const oscad::Position* pos) {
+    static const char* kEntryRules =
+        " In an unnamed list, entries must be [key,value] to set or [key] to delete."
+        " The key must be <string>.";
+
     std::vector<std::pair<std::string, Value>> result;
     const auto setKey = [&](const std::string& k, const Value& v) {
         for (auto& [ek, ev2] : result) {
@@ -465,30 +491,79 @@ Value mergeObjectArgs(const std::vector<std::pair<std::optional<std::string>, Va
         }
         result.emplace_back(k, v);
     };
-    for (const auto& [name, v] : evaluated) {
+    const auto deleteKey = [&](const std::string& k) {
+        for (auto it = result.begin(); it != result.end(); ++it) {
+            if (it->first == k) {
+                result.erase(it);
+                return;
+            }
+        }
+        // Deleting an absent key is deliberately silent.
+    };
+
+    for (size_t argIdx = 0; argIdx < evaluated.size(); ++argIdx) {
+        const auto& [name, v] = evaluated[argIdx];
         if (name) {
             setKey(*name, v);
             continue;
         }
+        const std::string argPrefix = "object(Argument " + std::to_string(argIdx) + " ";
         if (const ObjectPtr* o = std::get_if<ObjectPtr>(&v); o && *o) {
             for (const auto& [k, kv] : (*o)->items) setKey(k, kv);
-        } else if (const ListPtr* l = std::get_if<ListPtr>(&v); l && *l) {
-            for (const Value& entry : (*l)->items) {
-                const ListPtr* pair = std::get_if<ListPtr>(&entry);
-                if (pair && *pair && (*pair)->items.size() == 2 && std::holds_alternative<std::string>((*pair)->items[0])) {
-                    setKey(std::get<std::string>((*pair)->items[0]), (*pair)->items[1]);
-                } else {
-                    return Value{};
-                }
-            }
-        } else if (!std::holds_alternative<std::monostate>(v)) {
+            continue;
+        }
+        const ListPtr* l = std::get_if<ListPtr>(&v);
+        if (!l || !*l) {
+            // undef is accepted and contributes nothing, as upstream.
+            if (std::holds_alternative<std::monostate>(v)) continue;
+            ev.warn(argPrefix + "<" + oscTypeName(v) + ">) An unnamed argument must be either <object> or"
+                                 " <list>, it is <" + oscTypeName(v) + ">. ",
+                    pos);
             return Value{};
         }
+        for (size_t elemIdx = 0; elemIdx < (*l)->items.size(); ++elemIdx) {
+            const Value& entry = (*l)->items[elemIdx];
+            const std::string where = "[Element " + std::to_string(elemIdx) + " ";
+            const ListPtr* pair = std::get_if<ListPtr>(&entry);
+            if (!pair || !*pair) {
+                // Note the spaces inside the parens: upstream's own quirk.
+                ev.warn("object( Argument " + std::to_string(argIdx) + " " + where + "<" + oscTypeName(entry) +
+                            ">] ) Entry type is not a list, it is <" + oscTypeName(entry) + ">." + kEntryRules,
+                        pos);
+                return Value{};
+            }
+            const size_t n = (*pair)->items.size();
+            if (n == 0) {
+                ev.warn(argPrefix + where + "[]]) Entry is empty." + kEntryRules, pos);
+                return Value{};
+            }
+            if (n > 2) {
+                ev.warn(argPrefix + where + "[...]]) Entry length is " + std::to_string(n) +
+                            ", must be 1 [key] or 2 [key,value]." + kEntryRules,
+                        pos);
+                return Value{};
+            }
+            const Value& key = (*pair)->items[0];
+            if (!std::holds_alternative<std::string>(key)) {
+                const std::string shape = n == 2 ? "[<" + oscTypeName(key) + ">,value]"
+                                                  : "[<" + oscTypeName(key) + ">]";
+                ev.warn(argPrefix + where + shape + "]) The key of the entry is not <string> but <" +
+                            oscTypeName(key) + ">." + kEntryRules,
+                        pos);
+                return Value{};
+            }
+            if (n == 2) {
+                setKey(std::get<std::string>(key), (*pair)->items[1]);
+            } else {
+                deleteKey(std::get<std::string>(key));
+            }
+        }
     }
     return Value{std::make_shared<const ValueObject>(ValueObject{std::move(result)})};
 }
 
-Value builtinObject(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx) {
+Value builtinObject(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Argument>>& arguments, EvalContext& ctx,
+                     const oscad::ASTNode& node) {
     std::vector<std::pair<std::optional<std::string>, Value>> evaluated;
     evaluated.reserve(arguments.size());
     for (const auto& argPtr : arguments) {
@@ -499,7 +574,7 @@ Value builtinObject(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Argu
         }
         evaluated.emplace_back(std::move(name), std::move(v));
     }
-    return mergeObjectArgs(evaluated);
+    return mergeObjectArgs(ev, evaluated, &node.position());
 }
 
 namespace {
@@ -877,7 +952,12 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
                 }
                 if (const OscRange* r = std::get_if<OscRange>(&c)) {
                     std::string out;
-                    for (const Value& item : expandIterable(Value{*r})) out += encode(item);
+                    // The reference warns here too -- chr([70:1:65]) is
+                    // as much a typo as for(i=[70:1:65]) would be.
+                    const IterableValues seq = expandIterable(Value{*r}, nullptr, [&](bool stepPositive) {
+                        ev.warn(rangeDirectionWarning(stepPositive), &node.position());
+                    });
+                    for (const Value& item : seq) out += encode(item);
                     return out;
                 }
                 return {};

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/builtins/primitives_3d.cpp

@@ -630,6 +630,37 @@ CSGParams resolvePolyhedron(Evaluator& ev, const oscad::ModularCall& node, EvalC
         facesArg = std::move(newFaces);
     }
 
+    // polyhedron(vnf) -- BOSL2's [vertices, faces] 2-list, which is what
+    // every BOSL2 function passes around and what obj.vnf holds. Only
+    // considered when `faces` was not given separately, so the two-argument
+    // form always wins and can never be reinterpreted.
+    //
+    // The discriminator is BOSL2's own is_vnf test: a VNF's second element
+    // is a list of FACES, i.e. a list of lists. A plain points list of
+    // length 2 has a point there instead -- bare numbers, not lists -- and
+    // is left alone. (Two points cannot describe a polyhedron anyway, so
+    // nothing legitimate is being taken over.)
+    if (isUndef(facesArg)) {
+        if (const ListPtr* outer = std::get_if<ListPtr>(&pointsArg); outer && *outer &&
+            (*outer)->items.size() == 2) {
+            const ListPtr* maybeVerts = std::get_if<ListPtr>(&(*outer)->items[0]);
+            const ListPtr* maybeFaces = std::get_if<ListPtr>(&(*outer)->items[1]);
+            const bool facesAreLists =
+                maybeFaces && *maybeFaces && !(*maybeFaces)->items.empty() &&
+                std::holds_alternative<ListPtr>((*maybeFaces)->items[0]);
+            const bool vertsArePoints =
+                maybeVerts && *maybeVerts && !(*maybeVerts)->items.empty() &&
+                std::holds_alternative<ListPtr>((*maybeVerts)->items[0]);
+            if (facesAreLists && vertsArePoints) {
+                // Copy before assigning: both borrow into pointsArg's list.
+                Value newPoints = (*outer)->items[0];
+                Value newFaces = (*outer)->items[1];
+                pointsArg = std::move(newPoints);
+                facesArg = std::move(newFaces);
+            }
+        }
+    }
+
     const ListPtr* pointsList = std::get_if<ListPtr>(&pointsArg);
     const ListPtr* facesList = std::get_if<ListPtr>(&facesArg);
     if (!pointsList || !*pointsList || !facesList || !*facesList) {

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/bytecode_vm.cpp

@@ -740,6 +740,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     il.values = expandIterable(v, [&](size_t count) {
                         ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")",
                                 ins.pos);
+                    }, [&](bool stepPositive) {
+                        ev.warn(rangeDirectionWarning(stepPositive), ins.pos);
                     });
                     il.index = 0;
                     il.total = il.values.size();
@@ -787,7 +789,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         std::vector<std::pair<std::optional<std::string>, Value>> pairs;
                         pairs.reserve(argCount);
                         for (size_t i = 0; i < argCount; ++i) pairs.emplace_back(site.argNames[i], std::move(args[i]));
-                        f.stack.push_back(mergeObjectArgs(pairs));
+                        f.stack.push_back(mergeObjectArgs(ev, pairs, &site.callNode->position()));
                         ++f.pc;
                     } else if (site.isBuiltin) {
                         CallArgs callArgs = buildCallArgs(site, args, argCount);
@@ -1464,6 +1466,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     il.values = expandIterable(v, [&](size_t count) {
                         ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")",
                                 ins.pos);
+                    }, [&](bool stepPositive) {
+                        ev.warn(rangeDirectionWarning(stepPositive), ins.pos);
                     });
                     il.index = 0;
                     il.total = il.values.size();

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/expr_eval.cpp

@@ -177,6 +177,8 @@ void Evaluator::evalListElement(const oscad::ASTNode& elem, EvalContext& ctx, st
                 const oscad::Position* pos = &assign->position();
                 IterableValues iter = expandIterable(values, [&](size_t count) {
                     warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
+                }, [&](bool stepPositive) {
+                    warn(rangeDirectionWarning(stepPositive), pos);
                 });
                 for (const Value& val : iter) {
                     EvalContext childCtx = parentCtx.letChildCtx();

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/stmt_eval.cpp

@@ -112,6 +112,8 @@ void Evaluator::evalFor(const oscad::ModularFor& node, EvalContext& ctx) {
         const oscad::Position* pos = &assign->position();
         IterableValues iter = expandIterable(values, [&](size_t count) {
             warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
+        }, [&](bool stepPositive) {
+            warn(rangeDirectionWarning(stepPositive), pos);
         });
         for (const Value& val : iter) {
             EvalContext childCtx = parentCtx.childCtx(nullptr, std::nullopt, ctx.childrenNodes, ctx.childrenCallerCtx);

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/user_calls.cpp

@@ -886,7 +886,7 @@ Value Evaluator::evalFunctionCall(const oscad::PrimaryCall& node, EvalContext& c
             // call-site interleaved order (see builtinObject's own
             // comment) -- called directly, before resolveArgs, so
             // arguments aren't evaluated twice.
-            if (leftId->name == "object") return builtinObject(*this, node.arguments, ctx);
+            if (leftId->name == "object") return builtinObject(*this, node.arguments, ctx, node);
             CallArgs args = resolveArgs(*this, node.arguments, ctx);
             return evalBuiltinFunction(*this, leftId->name, args, node);
         }
@@ -984,7 +984,6 @@ std::optional<Evaluator::ChildrenForward> Evaluator::prepareChildrenForward(cons
     // filtered statement may produce 0 bodies, which would shift every
     // subsequent body-index lookup, so the Nth statement is evaluated
     // directly instead.
-    const int idx = static_cast<int>(toDoubleLenient(idxArg));
     std::vector<const oscad::ASTNode*> geoNodes;
     for (const oscad::ASTNode* c : *ctx.childrenNodes) {
         if (c->kind() != oscad::NodeKind::Assignment && c->kind() != oscad::NodeKind::ModuleDeclaration &&
@@ -992,8 +991,59 @@ std::optional<Evaluator::ChildrenForward> Evaluator::prepareChildrenForward(cons
             geoNodes.push_back(c);
         }
     }
-    if (idx < 0 || static_cast<size_t>(idx) >= geoNodes.size()) return std::nullopt;
-    return ChildrenForward{std::move(evalCtx), {geoNodes[static_cast<size_t>(idx)]}};
+
+    // The argument is a number, a VECTOR of numbers, or a RANGE --
+    // children([3:1:5]) is children(3); children(4); children(5), and
+    // children([3:-1:1]) is 3, 2, 1 in that order. Only a plain number was
+    // handled before, and toDoubleLenient collapses a list or a range to 0,
+    // so every vector/range form silently rendered child 0 instead.
+    //
+    // Ranges go through expandIterable, the same path a for-loop uses, so
+    // step direction, fractional steps and naturally-empty ranges all
+    // behave identically in both places rather than growing a second
+    // interpretation here.
+    std::vector<Value> indexValues;
+    if (std::holds_alternative<double>(idxArg)) {
+        indexValues.push_back(idxArg);
+    } else if (std::holds_alternative<ListPtr>(idxArg) || std::holds_alternative<OscRange>(idxArg)) {
+        const IterableValues iter = expandIterable(idxArg, nullptr, [&](bool stepPositive) {
+            warn(rangeDirectionWarning(stepPositive), currentWarnEntry());
+        });
+        for (const Value& v : iter) indexValues.push_back(v);
+    } else {
+        warn("Bad parameter type (" + fmtValue(idxArg) +
+                 ") for children, only accept: empty, number, vector, range.",
+             currentWarnEntry());
+        return std::nullopt;
+    }
+
+    // Order is preserved and duplicates are kept: children([2,2,2]) really
+    // does evaluate child 2 three times, and the order shows through in the
+    // CSG tree even though a union usually hides it.
+    std::vector<const oscad::ASTNode*> picked;
+    picked.reserve(indexValues.size());
+    for (const Value& v : indexValues) {
+        if (!std::holds_alternative<double>(v)) {
+            warn("Bad parameter type (" + fmtValue(v) +
+                     ") for children, only accept: empty, number, vector, range.",
+                 currentWarnEntry());
+            return std::nullopt;
+        }
+        // Truncates, matching the reference: children([1.7]) is child 1.
+        const long long idx = static_cast<long long>(std::get<double>(v));
+        if (idx < 0 || static_cast<size_t>(idx) >= geoNodes.size()) {
+            // An out-of-range index is skipped, not fatal -- children([0,99])
+            // still draws child 0. Warned about either way; this used to
+            // return silently.
+            warn("Children index (" + fmtValue(v) + ") out of bounds (" +
+                     std::to_string(geoNodes.size()) + " children)",
+                 currentWarnEntry());
+            continue;
+        }
+        picked.push_back(geoNodes[static_cast<size_t>(idx)]);
+    }
+    if (picked.empty()) return std::nullopt;
+    return ChildrenForward{std::move(evalCtx), std::move(picked)};
 }
 
 void Evaluator::builtinChildren(const CallArgs& args, EvalContext& ctx) {

{openscad_cpp_evaluator-0.38.1 → openscad_cpp_evaluator-0.40.0}/src/value.cpp

@@ -490,13 +490,30 @@ std::optional<size_t> rangeElementCount(const OscRange& r) {
     return static_cast<size_t>(std::floor(n + 1e-10)) + 1;
 }
 
-IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany) {
+std::string rangeDirectionWarning(bool stepPositive) {
+    return stepPositive ? "begin is greater than the end, but step is positive"
+                        : "begin is smaller than the end, but step is negative";
+}
+
+IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany,
+                               const RangeDirectionFn& onWrongDirection) {
     if (std::holds_alternative<std::monostate>(v)) return IterableValues{};
     if (const OscRange* r = std::get_if<OscRange>(&v)) {
         if (const std::optional<size_t> count = rangeElementCount(*r); count && *count >= 1'000'000) {
             if (onTooMany) onTooMany(*count);
             return IterableValues{};
         }
+        // A step pointing away from the end yields nothing. That is almost
+        // always a typo -- [1:0] where [1:-1:0] was meant -- so the
+        // reference says so rather than silently running zero times.
+        //
+        // A zero step is deliberately NOT reported here: it is a different
+        // failure (the reference calls it "too many elements") and shares
+        // rangeElementCount's nullopt with this case only by coincidence.
+        if (onWrongDirection && r->step != 0.0) {
+            const double n = (r->end - r->start) / r->step;
+            if (n < -1e-10) onWrongDirection(r->step > 0.0);
+        }
         // Lazy -- IterableValues itself reproduces this exact
         // termination condition (a zero step is naturally empty: neither
         // `x <= end` nor `x >= end` branch ever fires for it) without