diff --git a/Lib/collections.py b/Lib/collections.py
index 9120ab6..78b4115 100644
--- a/Lib/collections.py
+++ b/Lib/collections.py
@@ -13,6 +13,7 @@
 import heapq as _heapq
 from weakref import proxy as _proxy
 from itertools import repeat as _repeat, chain as _chain, starmap as _starmap
+from reprlib import recursive_repr as _recursive_repr
 
 ################################################################################
 ### OrderedDict
@@ -43,7 +44,6 @@
         '''
         if len(args) > 1:
             raise TypeError('expected at most 1 arguments, got %d' % len(args))
-        self.__in_repr = False              # detects recursive repr
         try:
             self.__root
         except AttributeError:
@@ -97,10 +97,10 @@
     def __reduce__(self):
         'Return state information for pickling'
         items = [[k, self[k]] for k in self]
-        tmp = self.__map, self.__root, self.__in_repr
-        del self.__map, self.__root, self.__in_repr
+        tmp = self.__map, self.__root
+        del self.__map, self.__root
         inst_dict = vars(self).copy()
-        self.__map, self.__root, self.__in_repr = tmp
+        self.__map, self.__root = tmp
         if inst_dict:
             return (self.__class__, (items,), inst_dict)
         return self.__class__, (items,)
@@ -167,18 +167,12 @@
     items = MutableMapping.items
     __ne__ = MutableMapping.__ne__
 
+    @_recursive_repr()
     def __repr__(self):
         'od.__repr__() <==> repr(od)'
         if not self:
             return '%s()' % (self.__class__.__name__,)
-        if self.__in_repr:
-            return '...'
-        self.__in_repr = True
-        try:
-            result = '%s(%r)' % (self.__class__.__name__, list(self.items()))
-        finally:
-            self.__in_repr = False
-        return result
+        return '%s(%r)' % (self.__class__.__name__, list(self.items()))
 
     def copy(self):
         'od.copy() -> a shallow copy of od'
diff --git a/Lib/reprlib.py b/Lib/reprlib.py
index 9893c71..c44c75c 100644
--- a/Lib/reprlib.py
+++ b/Lib/reprlib.py
@@ -1,9 +1,38 @@
 """Redo the builtin repr() (representation) but with limits on most sizes."""
 
-__all__ = ["Repr","repr"]
+__all__ = ["Repr", "repr", "recursive_repr"]
 
 import builtins
 from itertools import islice
+try:
+    from _thread import get_ident
+except AttributeError:
+    from _dummy_thread import get_ident
+
+def recursive_repr(fillvalue='...'):
+    'Decorator to make a repr function return fillvalue for a recursive call'
+
+    def decorating_function(user_function):
+        repr_running = set()
+
+        def wrapper(self):
+            key = id(self), get_ident()
+            if key in repr_running:
+                return fillvalue
+            repr_running.add(key)
+            try:
+                result = user_function(self)
+            finally:
+                repr_running.discard(key)
+            return result
+
+        # Can't use functools.wraps() here because of bootstrap issues
+        wrapper.__module__ = getattr(user_function, '__module__')
+        wrapper.__doc__ = getattr(user_function, '__doc__')
+        wrapper.__name__ = getattr(user_function, '__name__')
+        return wrapper
+
+    return decorating_function
 
 class Repr:
 
diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py
index 0e799f6..4271482 100644
--- a/Lib/test/test_reprlib.py
+++ b/Lib/test/test_reprlib.py
@@ -11,6 +11,7 @@
 from test.support import run_unittest
 from reprlib import repr as r # Don't shadow builtin repr
 from reprlib import Repr
+from reprlib import recursive_repr
 
 
 def nestedTuple(nesting):
@@ -301,10 +302,38 @@
     def __repr__(self):
         raise Exception("This should be caught by Repr.repr_instance")
 
+class MyContainer:
+    'Helper class for TestRecursiveRepr'
+    def __init__(self, values):
+        self.values = list(values)
+    def append(self, value):
+        self.values.append(value)
+    @recursive_repr()
+    def __repr__(self):
+        return '<' + ', '.join(map(str, self.values)) + '>'
+
+class MyContainer2(MyContainer):
+    @recursive_repr('+++')
+    def __repr__(self):
+        return '<' + ', '.join(map(str, self.values)) + '>'
+
+class TestRecursiveRepr(unittest.TestCase):
+    def test_recursive_repr(self):
+        m = MyContainer(list('abcde'))
+        m.append(m)
+        m.append('x')
+        m.append(m)
+        self.assertEqual(repr(m), '<a, b, c, d, e, ..., x, ...>')
+        m = MyContainer2(list('abcde'))
+        m.append(m)
+        m.append('x')
+        m.append(m)
+        self.assertEqual(repr(m), '<a, b, c, d, e, +++, x, +++>')
 
 def test_main():
     run_unittest(ReprTests)
     run_unittest(LongReprTest)
+    run_unittest(TestRecursiveRepr)
 
 
 if __name__ == "__main__":