rayon-rs/rayon · error

overflow

Error message

overflow

What it means

`Interleave`'s `len()` adds the lengths of both inner iterators with `checked_add` and panics with "overflow" when the sum exceeds usize::MAX. The interleaved parallel iterator's exact length is unrepresentable.

Solutions

1. Avoid interleaving iterators whose combined length approaches usize::MAX
2. Cap the source ranges before interleaving
3. Convert one side to a bounded collection to keep lengths small

Example fix

// before
huge_a.interleave(huge_b).collect::<Vec<_>>();
// after
let n = huge_a.len();
assert!(n <= usize::MAX - huge_b.len(), "combined length overflows");
huge_a.interleave(huge_b).collect::<Vec<_>>();

fn interleave_fits(a: usize, b: usize) -> bool { a.checked_add(b).is_some() }

When it happens

Trigger: `interleave(a, b)` where `a.len() + b.len()` overflows usize, then calling indexed parallel ops that consult `len()` (directly or via `opt_len`).

Common situations: Interleaving two huge exact-size iterators (e.g. step_by over near-max ranges) in stress tests or adversarial inputs.

Related errors

• overflow
• overflow
• FIFO is empty
• range start should be <= length
• range end should be <= length

AI-assisted analysis of rayon-rs/rayon@ee0a00bdb1 (2026-09-07). Data as JSON: /api/errors/5a1089d16813a90f. Report an issue: GitHub.

Appendix: source

Thrown at src/iter/interleave.rs:55

    fn opt_len(&self) -> Option<usize> {
        Some(self.len())
    }
}

impl<I, J> IndexedParallelIterator for Interleave<I, J>
where
    I: IndexedParallelIterator,
    J: IndexedParallelIterator<Item = I::Item>,
{
    fn drive<C>(self, consumer: C) -> C::Result
    where
        C: Consumer<Self::Item>,
    {
        bridge(self, consumer)
    }

    fn len(&self) -> usize {
        self.i.len().checked_add(self.j.len()).expect("overflow")
    }

    fn with_producer<CB>(self, callback: CB) -> CB::Output
    where
        CB: ProducerCallback<Self::Item>,
    {
        let (i_len, j_len) = (self.i.len(), self.j.len());
        return self.i.with_producer(CallbackI {
            callback,
            i_len,
            j_len,
            i_next: false,
            j: self.j,
        });

        struct CallbackI<CB, J> {
            callback: CB,
            i_len: usize,

View on GitHub (pinned to ee0a00bdb1)