Factor-out constant expressions

1 files changed, 6 insertions, 14 deletions

diff --git a/Lib/collections.py b/Lib/collections.py
index 79f6696..0322669 100644
--- a/Lib/collections.py
+++ b/Lib/collections.py
@@ -47,47 +47,39 @@ class OrderedDict(dict, MutableMapping):
             self.__map = {}
         self.update(*args, **kwds)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key, value, PREV=0, NEXT=1, dict_setitem=dict.__setitem__):
         'od.__setitem__(i, y) <==> od[i]=y'
         # Setting a new item creates a new link which goes at the end of the linked
         # list, and the inherited dictionary is updated with the new key/value pair.
         if key not in self:
-            PREV = 0
-            NEXT = 1
             root = self.__root
             last = root[PREV]
             last[NEXT] = root[PREV] = self.__map[key] = [last, root, key]
-        dict.__setitem__(self, key, value)
+        dict_setitem(self, key, value)
 
-    def __delitem__(self, key):
+    def __delitem__(self, key, PREV=0, NEXT=1, dict_delitem=dict.__delitem__):
         'od.__delitem__(y) <==> del od[y]'
         # Deleting an existing item uses self.__map to find the link which is
         # then removed by updating the links in the predecessor and successor nodes.
-        dict.__delitem__(self, key)
-        PREV = 0
-        NEXT = 1
+        dict_delitem(self, key)
         link = self.__map.pop(key)
         link_prev = link[PREV]
         link_next = link[NEXT]
         link_prev[NEXT] = link_next
         link_next[PREV] = link_prev
 
-    def __iter__(self):
+    def __iter__(self, NEXT=1, KEY=2):
         'od.__iter__() <==> iter(od)'
         # Traverse the linked list in order.
-        NEXT = 1
-        KEY = 2
         root = self.__root
         curr = root[NEXT]
         while curr is not root:
             yield curr[KEY]
             curr = curr[NEXT]
 
-    def __reversed__(self):
+    def __reversed__(self, PREV=0, KEY=2):
         'od.__reversed__() <==> reversed(od)'
         # Traverse the linked list in reverse order.
-        PREV = 0
-        KEY = 2
         root = self.__root
         curr = root[PREV]
         while curr is not root: