RustPython
diff --git a/‎crates/vm/src/stdlib/_collections.rs‎
Lines changed: 10 additions & 4 deletions b/‎crates/vm/src/stdlib/_collections.rs‎
Lines changed: 10 additions & 4 deletions
diff --git a/‎extra_tests/snippets/stdlib_collections_deque.py‎
Lines changed: 43 additions & 0 deletions b/‎extra_tests/snippets/stdlib_collections_deque.py‎
Lines changed: 43 additions & 0 deletions
@@ -77,6 +77,10 @@ mod _collections {
         fn borrow_deque_mut(&self) -> PyRwLockWriteGuard<'_, VecDeque<PyObjectRef>> {
             self.deque.write()
         }
+
+        fn is_over_maxlen(&self, deque: &VecDeque<PyObjectRef>) -> bool {
+            self.maxlen.is_some_and(|maxlen| deque.len() > maxlen)
+        }
     }
 
     #[pyclass(
@@ -96,20 +100,22 @@ mod _collections {
         fn append(&self, obj: PyObjectRef) {
             self.state.fetch_add(1);
             let mut deque = self.borrow_deque_mut();
-            if self.maxlen == Some(deque.len()) {
+            deque.push_back(obj);
+            // Trim after pushing, so that a `maxlen` of zero drops what just
+            // arrived instead of popping from an empty deque and keeping it.
+            if self.is_over_maxlen(&deque) {
                 deque.pop_front();
             }
-            deque.push_back(obj);
         }
 
         #[pymethod]
         fn appendleft(&self, obj: PyObjectRef) {
             self.state.fetch_add(1);
             let mut deque = self.borrow_deque_mut();
-            if self.maxlen == Some(deque.len()) {
+            deque.push_front(obj);
+            if self.is_over_maxlen(&deque) {
                 deque.pop_back();
             }
-            deque.push_front(obj);
         }
 
         #[pymethod]
 
@@ -108,3 +108,46 @@ class D(deque):
     # until the allocator gives up, so it is left out of this check.
     with assert_raises(MemoryError):
         deque([0]) * sys.maxsize
+
+
+# maxlen=0 keeps nothing, whichever end the item arrives at.
+d = deque(maxlen=0)
+d.append(1)
+d.appendleft(2)
+assert list(d) == []
+assert len(d) == 0
+assert d.maxlen == 0
+
+d = deque(maxlen=0)
+d.extend("abc")
+d.extendleft("abc")
+d += "abc"
+assert list(d) == []
+
+assert list(deque("abc", maxlen=0)) == []
+assert list(deque("ab", maxlen=0) * 3) == []
+assert list(deque("ab", maxlen=0) + deque("cd")) == []
+
+d = deque("abc", maxlen=0)
+d.rotate(1)
+assert list(d) == []
+
+assert_raises(IndexError, deque(maxlen=0).insert, 0, 1)
+
+
+# A bounded deque still drops from the far end, and only once it is full.
+d = deque(maxlen=1)
+d.append(1)
+assert list(d) == [1]
+d.append(2)
+assert list(d) == [2]
+d.appendleft(3)
+assert list(d) == [3]
+
+d = deque("ab", maxlen=3)
+d.append("c")
+assert list(d) == ["a", "b", "c"]
+d.append("d")
+assert list(d) == ["b", "c", "d"]
+d.appendleft("z")
+assert list(d) == ["z", "b", "c"]
Original file line number	Diff line number	Diff line change
`@@ -77,6 +77,10 @@ mod _collections {`
`77`	`77`	`fn borrow_deque_mut(&self) -> PyRwLockWriteGuard<'_, VecDeque<PyObjectRef>> {`
`78`	`78`	`self.deque.write()`
`79`	`79`	`}`
	`80`	`+`
	`81`	`+ fn is_over_maxlen(&self, deque: &VecDeque<PyObjectRef>) -> bool {`
	`82`	`+ self.maxlen.is_some_and(\|maxlen\| deque.len() > maxlen)`
	`83`	`+ }`
`80`	`84`	`}`
`81`	`85`
`82`	`86`	`#[pyclass(`
`@@ -96,20 +100,22 @@ mod _collections {`
`96`	`100`	`fn append(&self, obj: PyObjectRef) {`
`97`	`101`	`self.state.fetch_add(1);`
`98`	`102`	`let mut deque = self.borrow_deque_mut();`
`99`		`- if self.maxlen == Some(deque.len()) {`
	`103`	`+ deque.push_back(obj);`
	`104`	+ // Trim after pushing, so that a `maxlen` of zero drops what just
	`105`	`+ // arrived instead of popping from an empty deque and keeping it.`
	`106`	`+ if self.is_over_maxlen(&deque) {`
`100`	`107`	`deque.pop_front();`
`101`	`108`	`}`
`102`		`- deque.push_back(obj);`
`103`	`109`	`}`
`104`	`110`
`105`	`111`	`#[pymethod]`
`106`	`112`	`fn appendleft(&self, obj: PyObjectRef) {`
`107`	`113`	`self.state.fetch_add(1);`
`108`	`114`	`let mut deque = self.borrow_deque_mut();`
`109`		`- if self.maxlen == Some(deque.len()) {`
	`115`	`+ deque.push_front(obj);`
	`116`	`+ if self.is_over_maxlen(&deque) {`
`110`	`117`	`deque.pop_back();`
`111`	`118`	`}`
`112`		`- deque.push_front(obj);`
`113`	`119`	`}`
`114`	`120`
`115`	`121`	`#[pymethod]`