Stop asking an iterator how long it is to walk it

`PyIter::iter` and `PyIter::into_iter` asked for a length hint and reported what asking raised. Nothing spent the answer: it reached `PyIterIter` for a `size_hint()` that every caller either loops past or drops, since collecting into a `Result` reports no lower bound. 23 operations answered for an iterator whose `__length_hint__` raises, where they had been raising it: `set`, `frozenset` and the nine `set` methods that take an iterable, `dict.fromkeys` and the dict view operators, `array` and `array.extend`, `all`, `any`, `sum`, `io.writelines`, `math.fsum`, `math.prod`, and `csv.writerow` and `writerows`. Over a generator, `set()` drops 16% of its instructions and `all()` 23%. `str.join` and `bytes.join` do ask, reaching their elements through `PySequence_Fast()`, which fills a list from the iterator. They take `iter_sized()`, which is now the only way to ask. `iter_without_hint` is gone, its callers being what `iter` already does. Assisted-by: Claude
youknowone · Aug 19, 2026 · Aug 17, 2026 · Aug 17, 2026 · Aug 17, 2026 · Aug 17, 2026
commit 3613b897c058f5c40ce74525423dd7e537097f1e
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
@@ -240,7 +240,7 @@ impl PyDict {
                 }
             })?;
             elem_iter
-                .into_iter::<PyObjectRef>(vm)?
+                .into_iter::<PyObjectRef>(vm)
                 .collect::<PyResult<Vec<_>>>()
         })()
         .map_err(|exc| Self::add_update_sequence_note(exc, index, vm))?;
@@ -257,7 +257,7 @@ impl PyDict {
         let iter = seq2.get_iter(vm)?;
         let dict = &self.entries;
 
-        for (index, element) in iter.iter_without_hint::<PyObjectRef>(vm)?.enumerate() {
+        for (index, element) in iter.iter::<PyObjectRef>(vm)?.enumerate() {
             let (key, value) = Self::update_sequence_pair(element?, index, vm)?;
 
             if !override_existing && dict.contains(vm, &*key)? {

diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
@@ -39,7 +39,7 @@ fn iter_search(
 ) -> PyResult<usize> {
     let mut count = 0;
     let iter = obj.get_iter(vm)?;
-    for element in iter.iter_without_hint::<PyObjectRef>(vm)? {
+    for element in iter.iter::<PyObjectRef>(vm)? {
         if vm.bool_eq(item, &*element?)? {
             match flag {
                 SearchType::Index => return Ok(count),

diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
@@ -1174,7 +1174,9 @@ impl PyStr {
         iterable: ArgIterable<PyStrRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyStrRef> {
-        let iter = iterable.iter(vm)?;
+        // `PyUnicode_Join()` reaches its elements through `PySequence_Fast()`,
+        // which fills a list from the iterator and so asks it how long it is.
+        let iter = iterable.iter_sized(vm)?;
         let joined = match iter.exactly_one() {
             Ok(first) => {
                 let first = first?;

diff --git a/crates/vm/src/bytes_inner.rs b/crates/vm/src/bytes_inner.rs
@@ -629,7 +629,8 @@ impl PyBytesInner {
     }
 
     pub fn join(&self, iterable: ArgIterable<Self>, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-        let iter = iterable.iter(vm)?;
+        // `PySequence_Fast()`, as in `PyUnicode_Join()`.
+        let iter = iterable.iter_sized(vm)?;
         self.elements.py_join(iter)
     }
 

diff --git a/crates/vm/src/function/protocol.rs b/crates/vm/src/function/protocol.rs
@@ -91,16 +91,30 @@ impl<T> ArgIterable<T> {
         &self.iterable
     }
 
-    /// Returns an iterator over this sequence of objects.
+    /// This object's iterator.
     ///
     /// This operation may fail if an exception is raised while invoking the
     /// `__iter__` method of the iterable object.
-    pub fn iter<'a>(&self, vm: &'a VirtualMachine) -> PyResult<PyIterIter<'a, T>> {
-        let iter = PyIter::new(match self.iter_fn {
+    fn get_iter(&self, vm: &VirtualMachine) -> PyResult<PyIter> {
+        Ok(PyIter::new(match self.iter_fn {
             Some(f) => f(self.iterable.clone(), vm)?,
             None => PySequenceIterator::new(self.iterable.clone(), vm)?.into_pyobject(vm),
-        });
-        iter.into_iter(vm)
+        }))
+    }
+
+    /// Returns an iterator over this sequence of objects. See [`PyIter::iter`]
+    /// for why it does not ask how long the iterator is.
+    ///
+    /// This operation may fail if an exception is raised while invoking the
+    /// `__iter__` method of the iterable object.
+    pub fn iter<'a>(&self, vm: &'a VirtualMachine) -> PyResult<PyIterIter<'a, T>> {
+        Ok(self.get_iter(vm)?.into_iter(vm))
+    }
+
+    /// [`Self::iter`] for a caller that fills a sized container from the
+    /// iterator, the way `PySequence_Fast()` does.
+    pub fn iter_sized<'a>(&self, vm: &'a VirtualMachine) -> PyResult<PyIterIter<'a, T>> {
+        self.get_iter(vm)?.into_iter_sized(vm)
     }
 }
 

diff --git a/crates/vm/src/protocol/iter.rs b/crates/vm/src/protocol/iter.rs
@@ -56,25 +56,31 @@ where
         iternext(self.0.borrow(), vm)
     }
 
+    /// Walks the iterator without asking it how long it is. Almost nothing
+    /// asks: a loop over an iterator takes no room up front, so what the
+    /// object would have answered -- slowly, or by raising -- never runs.
     pub fn iter<'a, 'b, U>(
         &'b self,
         vm: &'a VirtualMachine,
-    ) -> PyResult<PyIterIter<'a, U, &'b PyObject>> {
-        let length_hint = vm.length_hint_opt(self.as_ref().to_owned())?;
-        Ok(PyIterIter::new(vm, self.0.borrow(), length_hint))
-    }
-
-    pub fn iter_without_hint<'a, 'b, U>(
-        &'b self,
-        vm: &'a VirtualMachine,
     ) -> PyResult<PyIterIter<'a, U, &'b PyObject>> {
         Ok(PyIterIter::new(vm, self.0.borrow(), None))
     }
 }
 
 impl PyIter<PyObjectRef> {
-    /// Returns an iterator over this sequence of objects.
-    pub fn into_iter<U>(self, vm: &VirtualMachine) -> PyResult<PyIterIter<'_, U, PyObjectRef>> {
+    /// Returns an iterator over this sequence of objects. See [`Self::iter`]
+    /// for why it does not ask how long the iterator is.
+    pub fn into_iter<U>(self, vm: &VirtualMachine) -> PyIterIter<'_, U, PyObjectRef> {
+        PyIterIter::new(vm, self.0, None)
+    }
+
+    /// [`Self::into_iter`] for a caller that fills a sized container from the
+    /// iterator, the way `PySequence_Fast()` does. It asks how much room that
+    /// takes and answers with whatever asking raised.
+    pub fn into_iter_sized<U>(
+        self,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyIterIter<'_, U, PyObjectRef>> {
         let length_hint = vm.length_hint_opt(self.as_object().to_owned())?;
         Ok(PyIterIter::new(vm, self.0, length_hint))
     }

diff --git a/crates/vm/src/stdlib/_functools.rs b/crates/vm/src/stdlib/_functools.rs
@@ -32,7 +32,7 @@ mod _functools {
             iterator,
             initial,
         } = args;
-        let mut iter = iterator.iter_without_hint(vm)?;
+        let mut iter = iterator.iter(vm)?;
         // OptionalOption distinguishes between:
         // - Missing: no argument provided → use first element from iterator
         // - Present(None): explicitly passed None → use None as initial value

diff --git a/crates/vm/src/stdlib/_operator.rs b/crates/vm/src/stdlib/_operator.rs
@@ -178,7 +178,7 @@ mod _operator {
     #[pyfunction(name = "countOf")]
     fn count_of(a: PyIter, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
         let mut count: usize = 0;
-        for element in a.iter_without_hint::<PyObjectRef>(vm)? {
+        for element in a.iter::<PyObjectRef>(vm)? {
             let element = element?;
             if element.is(&b) || vm.bool_eq(&b, &element)? {
                 count += 1;
@@ -199,7 +199,7 @@ mod _operator {
 
     #[pyfunction(name = "indexOf")]
     fn index_of(a: PyIter, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-        for (index, element) in a.iter_without_hint::<PyObjectRef>(vm)?.enumerate() {
+        for (index, element) in a.iter::<PyObjectRef>(vm)?.enumerate() {
             let element = element?;
             if element.is(&b) || vm.bool_eq(&b, &element)? {
                 return Ok(index);

diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
@@ -2135,7 +2135,7 @@ pub(crate) fn envobj_to_dict(
     }
     let keys = vm.call_method(obj, "keys", ())?;
     let dict = vm.ctx.new_dict();
-    for key in keys.get_iter(vm)?.into_iter::<PyObjectRef>(vm)? {
+    for key in keys.get_iter(vm)?.into_iter::<PyObjectRef>(vm) {
         let key = key?;
         let val = obj.get_item(&*key, vm)?;
         dict.set_item(&*key, val, vm)?;

diff --git a/extra_tests/snippets/builtin_iter.py b/extra_tests/snippets/builtin_iter.py
@@ -69,3 +69,65 @@ def __len__(self):
 assert seq_it.__length_hint__() == 3
 next(seq_it)
 assert seq_it.__length_hint__() == 2
+
+
+# Walking an iterator takes no room up front, so nothing on the way asks it how
+# long it is. Only join does, reaching its elements through PySequence_Fast(),
+# which fills a list from the iterator.
+import array
+import collections
+import io
+import math
+
+
+class LoudIterator:
+    def __init__(self, seq):
+        self.i = iter(seq)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self.i)
+
+    def __length_hint__(self):
+        raise NotImplementedError("iterator hint")
+
+
+def handing(seq=(1, 2, 3)):
+    class Handing:
+        def __iter__(self):
+            return LoudIterator(seq)
+
+    return Handing()
+
+
+assert set(handing()) == {1, 2, 3}
+assert frozenset(handing()) == frozenset({1, 2, 3})
+assert {1}.difference(handing()) == set()
+assert {1}.intersection(handing()) == {1}
+assert {1}.symmetric_difference(handing()) == {2, 3}
+assert {1}.issubset(handing())
+assert not {9}.issuperset(handing())
+assert dict.fromkeys(handing()) == {1: None, 2: None, 3: None}
+assert array.array("b", handing()) == array.array("b", [1, 2, 3])
+assert all(handing()) and any(handing())
+assert sum(handing()) == 6
+assert math.fsum(handing()) == 6.0
+assert math.prod(handing()) == 6
+assert collections.deque(handing()) == collections.deque([1, 2, 3])
+assert tuple(handing()) == (1, 2, 3)
+assert list(handing()) == [1, 2, 3]
+assert min(handing()) == 1
+assert bytes(handing()) == b"\x01\x02\x03"
+assert bytearray(handing()) == bytearray(b"\x01\x02\x03")
+io.StringIO().writelines(handing(("a", "b")))
+
+# join asks, and answers with what asking raised.
+for empty in ("", b""):
+    try:
+        empty.join(handing((empty.__class__(),)))
+    except NotImplementedError:
+        pass
+    else:
+        raise AssertionError(f"{empty.__class__.__name__}.join did not ask")