with-precision: accept JVM RoundingMode symbols

The clojuredocs canon for with-precision passes the rounding mode
as a bare java.math.RoundingMode enum symbol (UP, HALF_UP, ...).
mino's macro previously inlined that symbol into the *math-context*
binding, where it then tripped "unbound symbol" at runtime. Fold
the eight enum symbols to their keyword equivalents at expand time,
and reject other bare symbols at macro time so user typos surface
clearly. The native :keyword surface keeps working unchanged.

Caught by the external clojure-test-suite driver: with_precision.cljc
errored on load because every assertion writes the JVM symbol form.

Author: leifericf

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v0.422.3 — `with-precision` Accepts JVM Rounding Symbols
+
+The `with-precision` macro now accepts the JVM `RoundingMode` enum
+constants (`UP`, `DOWN`, `CEILING`, `FLOOR`, `HALF_UP`, `HALF_DOWN`,
+`HALF_EVEN`, `UNNECESSARY`) as bare symbols, in addition to mino's
+native keyword surface (`:up`, `:down`, ...). The macro folds the
+symbol form to the corresponding keyword at expand time. Unknown
+symbols surface a clear macro-time error rather than the misleading
+runtime "unbound symbol" message. Canon `(with-precision N :rounding
+HALF_UP ...)` examples from clojuredocs.org now paste through unchanged.
+
+Caught by the external `clojure-test-suite` driver: `with_precision.cljc`
+errored on load because every assertion writes the JVM symbol form.
+
 ## v0.422.2 — `long` Coercion Stays Fixnum
 
 Fixes `(long x)` silently promoting to `:bigint` when the coerced

src/core.clj

@@ -3049,14 +3049,37 @@
    call."
   nil)
 
+(def ^:private rounding-symbol->keyword
+  ;; JVM RoundingMode enum constants → mino's :keyword surface. Lets
+  ;; canonical clojuredocs-shaped examples (which write the mode as a
+  ;; bare symbol, e.g. (with-precision 1 :rounding HALF_UP ...)) paste
+  ;; through without translation.
+  '{UP          :up
+    DOWN        :down
+    CEILING     :ceiling
+    FLOOR       :floor
+    HALF_UP     :half-up
+    HALF_DOWN   :half-down
+    HALF_EVEN   :half-even
+    UNNECESSARY :unnecessary})
+
 (defmacro with-precision
   "Sets *math-context* to {:precision precision :rounding-mode mode}
   around body. The keyword :rounding takes the next form as a
   rounding-mode keyword (e.g. (with-precision 5 :rounding :half-up
-  (/ 1M 3M))). Without :rounding, the mode defaults to :half-up."
+  (/ 1M 3M))) or as a JVM RoundingMode enum symbol (e.g. HALF_UP,
+  CEILING). Without :rounding, the mode defaults to :half-up."
   [precision & body]
   (let [has-rounding? (and (seq body) (= :rounding (first body)))
-        mode          (if has-rounding? (second body) :half-up)
+        raw-mode      (if has-rounding? (second body) :half-up)
+        mode          (if (symbol? raw-mode)
+                        (or (rounding-symbol->keyword raw-mode)
+                            (throw (str "with-precision: unknown rounding mode "
+                                        raw-mode
+                                        " (expected UP, DOWN, CEILING, FLOOR, "
+                                        "HALF_UP, HALF_DOWN, HALF_EVEN, "
+                                        "or UNNECESSARY)")))
+                        raw-mode)
         actual-body   (if has-rounding? (drop 2 body) body)]
     `(binding [*math-context* {:precision ~precision
                                :rounding-mode ~mode}]

src/mino.h

@@ -47,7 +47,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 422
-#define MINO_VERSION_PATCH 2
+#define MINO_VERSION_PATCH 3
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".

tests/numeric_edges_test.clj

@@ -127,6 +127,25 @@
   ;; classified) so user typos surface immediately.
   (is (thrown? (with-precision 5 :rounding :bogus-mode (/ 1M 3M)))))
 
+(deftest with-precision-jvm-symbol-modes
+  ;; ClojureDocs / canonical JVM examples pass the rounding mode as a
+  ;; bare java.math.RoundingMode enum symbol (UP, HALF_UP, ...). mino
+  ;; accepts these in addition to its native keyword surface so canon
+  ;; examples paste through unchanged. Verification goes through /
+  ;; since bigdec division is the path that consumes *math-context*.
+  (is (= 0.3M (with-precision 1 :rounding HALF_UP   (/ 25M 100M))))
+  (is (= 0.2M (with-precision 1 :rounding HALF_DOWN (/ 25M 100M))))
+  (is (= 0.2M (with-precision 1 :rounding DOWN      (/ 25M 100M))))
+  (is (= 0.3M (with-precision 1 :rounding UP        (/ 25M 100M))))
+  (is (= 0.2M (with-precision 1 :rounding FLOOR     (/ 25M 100M))))
+  (is (= 0.3M (with-precision 1 :rounding CEILING   (/ 25M 100M))))
+  (is (= 0.12M (with-precision 2 :rounding HALF_EVEN (/ 125M 1000M))))
+  (is (thrown? (with-precision 5 :rounding UNNECESSARY (/ 1M 3M))))
+  (is (= 0.5M  (with-precision 5 :rounding UNNECESSARY (/ 1M 2M))))
+  ;; A symbol that isn't a RoundingMode enum constant is rejected at
+  ;; macroexpansion, not deferred to a runtime "unbound symbol".
+  (is (thrown? (eval '(with-precision 5 :rounding NOT_A_MODE (/ 1M 3M))))))
+
 (deftest no-math-context-still-exact-or-throws
   ;; Outside with-precision, the historical exact-or-throw behavior is
   ;; preserved. (/ 1M 3M) is non-terminating → throws.