youknowone · Sep 27, 2026 · Sep 27, 2026
diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
@@ -351,7 +351,7 @@ impl PySetInner {
     }
 
     pub(super) fn difference(&self, other: ArgIterable, vm: &VirtualMachine) -> PyResult<Self> {
-        let set = self.copy();
+        let set = self.clone();
         if let Some(elements) = Self::cached_hashes(other.as_object(), vm) {
             for (item, hash) in elements {
                 set.content.delete_if_exists_known_hash(vm, &*item, hash)?;
@@ -384,8 +384,10 @@ impl PySetInner {
         // We want to remove duplicates in other
         let other_set = Self::from_iter(other.iter(vm)?, vm)?;
 
-        for item in other_set.elements() {
-            new_inner.content.delete_or_insert(vm, &item, ())?
+        for (item, hash) in other_set.content.keys_with_hashes() {
+            new_inner
+                .content
+                .delete_or_insert_known_hash(vm, &item, hash, ())?;
         }
 
         Ok(new_inner)
@@ -547,9 +549,8 @@ impl PySetInner {
                 }
                 continue;
             }
-            let items = iterable.iter(vm)?.collect::<Result<Vec<_>, _>>()?;
-            for item in items {
-                self.content.delete_if_exists(vm, &*item)?;
+            for item in iterable.iter(vm)? {
+                self.content.delete_if_exists(vm, &*item?)?;
             }
         }
         Ok(())
@@ -571,8 +572,9 @@ impl PySetInner {
             }
             // We want to remove duplicates in iterable
             let iterable_set = Self::from_iter(iterable.iter(vm)?, vm)?;
-            for item in iterable_set.elements() {
-                self.content.delete_or_insert(vm, &item, ())?;
+            for (item, hash) in iterable_set.content.keys_with_hashes() {
+                self.content
+                    .delete_or_insert_known_hash(vm, &item, hash, ())?;
             }
         }
         Ok(())
@@ -824,6 +826,7 @@ impl PySet {
             Ok(PyArithmeticValue::Implemented(Self {
                 inner: other
                     .as_inner()
+                    .copy()
                     .difference(ArgIterable::try_from_object(vm, zelf.into())?, vm)?,
             }))
         } else {
@@ -1353,6 +1356,7 @@ impl PyFrozenSet {
             Ok(PyArithmeticValue::Implemented(Self {
                 inner: other
                     .as_inner()
+                    .copy()
                     .difference(ArgIterable::try_from_object(vm, zelf.into())?, vm)?,
                 ..Default::default()
             }))

diff --git a/crates/vm/src/dict_inner.rs b/crates/vm/src/dict_inner.rs
@@ -866,18 +866,8 @@ impl<T: Clone> Dict<T> {
         Ok(removed.map(|entry| entry.value))
     }
 
-    pub(crate) fn delete_or_insert(
-        &self,
-        vm: &VirtualMachine,
-        key: &PyObject,
-        value: T,
-    ) -> PyResult<()> {
-        let hash = key.key_hash(vm)?;
-        self.delete_or_insert_known_hash(vm, key, hash, value)
-    }
-
-    /// [`Self::delete_or_insert`] with a known hash. Same contract as
-    /// [`Self::insert_known_hash`].
+    /// Delete an existing key or insert a missing key using its known hash.
+    /// Same contract as [`Self::insert_known_hash`].
     pub(crate) fn delete_or_insert_known_hash(
         &self,
         vm: &VirtualMachine,

diff --git a/extra_tests/snippets/builtin_set.py b/extra_tests/snippets/builtin_set.py
@@ -612,3 +612,42 @@ def __iter__(self):
     stored_target |= stored_target
     assert len(stored_target) == 2
 RemainingHashKey.blocked = False
+
+
+# Difference folds and reflected subtraction leave both operands unchanged.
+for left_type in (set, frozenset):
+    for right_type in (set, frozenset):
+        left = left_type([1, 2, 3])
+        right = right_type([2])
+        assert left.difference(right, [3]) == {1}
+        assert right.__rsub__(left) == {1, 3}
+        assert left == {1, 2, 3}
+        assert right == {2}
+
+
+# The temporary set deduplicates input without hashing its keys a second time.
+for set_type in (set, frozenset):
+    present = StoredHashKey(10)
+    added = StoredHashKey(11)
+    source = set_type([present])
+    present.hash_count = 0
+    result = source.symmetric_difference([present, added, added])
+    assert list(result) == [added]
+    assert list(source) == [present]
+    assert (present.hash_count, added.hash_count) == (1, 2)
+    if set_type is set:
+        present.hash_count = added.hash_count = 0
+        source.symmetric_difference_update([present, added, added])
+        assert list(source) == [added]
+        assert (present.hash_count, added.hash_count) == (1, 2)
+
+
+# Streaming removal retains progress if the input iterator later raises.
+source = {0, 1, 2}
+assert_raises(ValueError, source.difference_update, matched_then_error())
+assert source == {0, 2}
+source = {1, 2}
+assert_raises(RuntimeError, source.difference_update, iter(source))
+assert len(source) == 1
+source.difference_update(source)
+assert source == set()