rayon-rs/rayon · error

overflow

Error message

overflow

What it means

Arithmetic overflow panic raised by Intersperse::len when computing the total length of the interspersed parallel iterator. For a base iterator of length len > 0 the output length is len + (len - 1) (one separator between each pair of items); on 64-bit targets this overflows usize only for astronomically large len, but on 32-bit or smaller targets a base length above roughly 2^31 items triggers checked_add to return None and expect panics with "overflow". It is a size-limit guard: the input at fault is an IndexedParallelIterator whose len plus len-1 exceeds usize::MAX.

Solutions

1. Don't intersperse into iterators with length near usize::MAX/2
2. Bound the base iterator length before interspersing
3. Insert the separator with an unindexed approach (map+enumerate+flat_map) to avoid the exact-len path

Example fix

// before
(0..usize::MAX).step_by(2).intersperse(0).par_bridge();
// after
(0..usize::MAX / 4).step_by(2).intersperse(0).collect::<Vec<_>>();

fn intersperse_fits(n: usize) -> bool {
    n == 0 || n.checked_add(n - 1).is_some()
}

When it happens

Trigger: `intersperse(iter, sep)` where the base iterator's exact length `n` satisfies `2n - 1 > usize::MAX` (roughly n > usize::MAX/2), then running indexed parallel operations.

Common situations: Interspersing a separator into iterators over near-max-size ranges (e.g. `(0..usize::MAX).step_by(2)`) in synthetic workloads.

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/69f7cb42fd58fcbe. Report an issue: GitHub.

Appendix: source

Thrown at src/iter/intersperse.rs:67

    }
}

impl<I> IndexedParallelIterator for Intersperse<I>
where
    I: IndexedParallelIterator<Item: Clone>,
{
    fn drive<C>(self, consumer: C) -> C::Result
    where
        C: Consumer<Self::Item>,
    {
        let consumer1 = IntersperseConsumer::new(consumer, self.item);
        self.base.drive(consumer1)
    }

    fn len(&self) -> usize {
        let len = self.base.len();
        if len > 0 {
            len.checked_add(len - 1).expect("overflow")
        } else {
            0
        }
    }

    fn with_producer<CB>(self, callback: CB) -> CB::Output
    where
        CB: ProducerCallback<Self::Item>,
    {
        let len = self.len();
        return self.base.with_producer(Callback {
            callback,
            item: self.item,
            len,
        });

        struct Callback<CB, T> {
            callback: CB,

View on GitHub (pinned to ee0a00bdb1)