Numeric tower: (float x) narrows to 32-bit float precision

float.cljc asserts (float r/min-double) equals (float 0.0) because
the value underflows the 32-bit float range, and (float r/max-double)
/ (float ##Inf) / (float ##-Inf) all throw because they exceed it.
mino had (float x) as an identity-on-floats / cast-on-numbers --
no precision narrowing, no range check.

Update prim_float: range-check against [-FLT_MAX, FLT_MAX] (NaN
exempt, passes through; Inf and overflow throw eval/type MTY001),
then narrow precision via (double)(float)d which routes through
the hardware float-cast.

Internal suite 1476 / 7087 / 0. float.cljc 15/0/4 -> 19/0/0.

Partial of the Group C.2 plan: narrows the cast contract without
introducing a distinct MINO_FLOAT32 value type. (float? x) /
(double? x) distinctions remain a JVM-only divergence.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: leifericf

CHANGELOG.md

@@ -27,7 +27,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 100
-#define MINO_VERSION_PATCH 30
+#define MINO_VERSION_PATCH 31
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".

src/mino.h

@@ -10,6 +10,7 @@
 #include <stdio.h>
 #include <errno.h>
 #include <limits.h>
+#include <float.h>
 
 /* Integer-overflow-safe arithmetic helpers. GCC >= 5 and Clang >= 3.9
  * expose __builtin_*_overflow; MSVC and older compilers fall back to
@@ -1711,20 +1712,34 @@ mino_val_t *prim_byte(mino_state_t *S, mino_val_t *args, mino_env_t *env)
 mino_val_t *prim_float(mino_state_t *S, mino_val_t *args, mino_env_t *env)
 {
     mino_val_t *v;
+    double      d;
     (void)env;
     if (!mino_is_cons(args) || mino_is_cons(args->as.cons.cdr)) {
         return prim_throw_classified(S, "eval/arity", "MAR001", "float requires one argument");
     }
     v = args->as.cons.car;
-    if (v != NULL && v->type == MINO_FLOAT) return v;
-    if (v != NULL && v->type == MINO_INT) return mino_float(S, (double)v->as.i);
-    if (v != NULL && v->type == MINO_BIGINT)
-        return mino_float(S, mino_bigint_to_double(v));
-    if (v != NULL && v->type == MINO_RATIO)
-        return mino_float(S, mino_ratio_to_double(v));
-    if (v != NULL && v->type == MINO_BIGDEC)
-        return mino_float(S, mino_bigdec_to_double(v));
-    return prim_throw_classified(S, "eval/type", "MTY001", "float: expected a number");
+    if (v == NULL) {
+        return prim_throw_classified(S, "eval/type", "MTY001", "float: expected a number");
+    }
+    if (v->type == MINO_FLOAT)  d = v->as.f;
+    else if (v->type == MINO_INT)    d = (double)v->as.i;
+    else if (v->type == MINO_BIGINT) d = mino_bigint_to_double(v);
+    else if (v->type == MINO_RATIO)  d = mino_ratio_to_double(v);
+    else if (v->type == MINO_BIGDEC) d = mino_bigdec_to_double(v);
+    else
+        return prim_throw_classified(S, "eval/type", "MTY001", "float: expected a number");
+    /* mino has only one float tier (double), but the `float` cast
+     * narrows the contract to the 32-bit float range: values outside
+     * [-FLT_MAX, FLT_MAX] (including +/- infinity) throw, and
+     * underflow rounds toward zero. NaN passes through. */
+    if (d == d) {
+        if (d > FLT_MAX || d < -FLT_MAX) {
+            return prim_throw_classified(S, "eval/type", "MTY001",
+                                         "float: value out of float range");
+        }
+        d = (double)(float)d;
+    }
+    return mino_float(S, d);
 }
 
 mino_val_t *prim_parse_long(mino_state_t *S, mino_val_t *args, mino_env_t *env)

src/prim/numeric.c

@@ -100,7 +100,13 @@
   (is (= 3 (int 3.7)))
   (is (= 5 (int 5)))
   (is (= 5.0 (float 5)))
-  (is (= 3.14 (float 3.14))))
+  ;; (float x) narrows to 32-bit float precision then widens back to
+  ;; double; values that fit exactly round-trip cleanly. 3.14 is not
+  ;; representable in float32 and rounds to the nearest float and back.
+  (is (= (float 3.14) (double (float 3.14))))
+  (is (NaN? (float ##NaN)))
+  (is (thrown? (float ##Inf)))
+  (is (thrown? (float ##-Inf))))
 
 (deftest integer-overflow-strict-and-primed
   ;; Plain +/-/*/inc/dec throw on long overflow (matching JVM Clojure's