fix(vm): combinations on lazy iterators skipped tail combinations 🔢

[timfennis]

What

CombinationsIter's pivot algorithm gave incorrect results for lazy sources (any iterator that buffers on demand, e.g. the output of .enumerate(), .map(), .filter(), etc.).

Reproducer

print([1, 2, 3, 4].combinations(2).list());
// [(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)]    ← correct

print([1, 2, 3, 4].enumerate().combinations(2).list());
// [((0,1),(1,2)),((0,1),(2,3)),((1,2),(2,3)),((1,2),(3,4)),((2,3),(3,4))]
//                                ^ ((0,1),(3,4)) is missing and combinations are out of lex order

Eager sources (a list directly) were unaffected. Lazy sources missed combinations whose rightmost index landed in the not-yet-pulled tail.

Cause

CombinationsIter keeps a growing buffer of pulled elements and a list of indices into that buffer. To produce the next combination it picks the rightmost index that can still advance within the current buffer:

let pivot = match (0..k).rev().find(|&i| self.indices[i] < pool_len - k + i) { ... };

For an eager source, pool_len is the final size and the check is correct. For a lazy source, pool_len is "what's been pulled so far". When indices[k-1] reaches the end of the current buffer, the algorithm decides "no room to advance the rightmost index" and falls back to advancing an earlier index — even though one more pull would have unlocked it.

The existing code did try to pull more, but only in the fallback pivot = None branch, which only fires when every index is at its current-pool maximum. In our trace above the algorithm picks pivot = 0 before reaching that fallback.

Fix

Pull indices[k - 1] + 1 worth of buffer before computing the pivot. If the source still has elements, pool_len grows and the rightmost index pivots as expected. If the source is exhausted the buffer stays put and the existing pivot logic correctly falls back to an earlier index.

Tests

• New tests/functional/programs/900_bugs/bug0021_combinations_lazy_source.ndc covering the original 4-element case, the larger k = 3 case, and the eager-source baseline.
• All 287 existing functional tests pass.

🤖 Generated with Claude Code