moonbitlang / core / 6883

89%

push

github

fix(range): compute Float/Double iter elements as from + k * step

@range.iter built each Float/Double element by adding step to the
previous one, so rounding error accumulated: 0.0 to 1.0 by 0.1 yielded
11 elements and inclusive=true never reached 1.0.

The sealed Step trait gains one hidden method, enumerate, the body of
iter. Its default is the old accumulating loop, so the integral types
keep exactly their previous code (and no element counter). Float and
Double override it with their own counter loop computing element k as
from + k * step (in Double, rounded for Float); the two loops differ
only in that line.

For Double, when k * step overflows although the element is finite
(from=-1e308, step=1e308 reaches 1e308 at k = 2), the element is
computed as (from * 0.5 + k * (step * 0.5)) * 2.0, which rounds exactly
like the unbounded-exponent from + k * step; a quickcheck pins this
against the same range scaled down by 2^-64. From element 2^53 on, where
the Double counter saturates, Double falls back to repeated addition.

The existing strict-progress check is unchanged, so the elements stay
strictly monotonic and a sub-precision step still stops.

Codex review (ultra, 4 rounds): round 1 found k * step overflow dropping
elements; round 2 found the prev + step overflow fallback carrying error
past `to`; round 3 approved; round 4 approved the refactor from two
hidden trait methods to one:
> Approved. The refactor preserves counter initialization and increment
> order, fallback and overflow behavior, and the old `prev` -> current `i`
> relationship. Bounds, inclusive checks, and progress logic match across
> the loops.

Signed-off-by: Codex CLI <codex@openai.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

45 of 46 new or added lines in 1 file covered. (97.83%)

16683 of 18653 relevant lines covered (89.44%)

331852.54 hits per line