Test that Fold methods are recursion safe (#677)

* Test that fold methods are recursion safe

* Fixes grammar in fold docstrings

* Fixes docs for fold, refactors tests

Author: timqsh

returns/iterables.py

@@ -25,7 +25,7 @@ class AbstractFold(object):
     .. rubric:: Implementation
 
     ``AbstractFold`` and ``Fold`` types are special.
-    They have duoble definition for all method: public and protected ones.
+    They have double definition for each method: public and protected ones.
     Why?
 
     Because you cannot override ``@kinded`` method due to a ``mypy`` bug.
@@ -36,8 +36,8 @@ class AbstractFold(object):
 
     We have chosen the second way! Here's how it works:
 
-    1. Public methods are ``@kinded`` for better typing and cannot be overriden
-    2. Protected methods are unkinded and can be overriden in subtyping
+    1. Public methods are ``@kinded`` for better typing and cannot be overridden
+    2. Protected methods are unkinded and can be overridden in subtyping
 
     Now, if you need to make a change into our implementation,
     then you can subclass ``Fold`` or ``AbstractFold`` and then
@@ -179,7 +179,7 @@ def collect_all(
         not just any ``ApplicativeN`` like :meth:`~AbstractFold.collect`.
 
         Strategy to extract all successful values
-        even if there are failued values.
+        even if there are failed values.
 
         If there's at least one successful value
         and any amount of failed values,

tests/test_iterables/test_fold/test_collect.py

@@ -1,3 +1,4 @@
+import sys
 from typing import Iterable, List, Sequence, Tuple
 
 import pytest
@@ -200,3 +201,11 @@ async def test_fold_collect_future_result(subtests):
             assert await Fold.collect(
                 iterable, sequence.from_value(()),
             ) == await sequence
+
+
+def test_fold_collect_recursion_limit():
+    """Ensures that ``.collect`` method is recurion safe."""
+    limit = sys.getrecursionlimit() + 1
+    iterable = (IO(1) for _ in range(limit))
+    expected = IO((1,) * limit)
+    assert Fold.collect(iterable, IO(())) == expected

tests/test_iterables/test_fold/test_collect_all.py

@@ -1,3 +1,4 @@
+import sys
 from typing import Iterable, List, Sequence, Tuple
 
 import pytest
@@ -158,3 +159,11 @@ async def test_collect_all_future_result(subtests):
             assert await Fold.collect_all(
                 iterable, sequence.from_value(()),
             ) == await sequence
+
+
+def test_fold_collect_recursion_limit():
+    """Ensures that ``.collect_all`` method is recurion safe."""
+    limit = sys.getrecursionlimit() + 1
+    iterable = (Success(1) for _ in range(limit))
+    expected = Success((1,) * limit)
+    assert Fold.collect_all(iterable, Success(())) == expected

tests/test_iterables/test_fold/test_loop.py

@@ -1,3 +1,4 @@
+import sys
 from typing import Iterable, List, Tuple
 
 import pytest
@@ -216,3 +217,10 @@ async def test_fold_collect_future_result(subtests):
             assert await Fold.loop(
                 iterable, sequence.from_value(10), _sum_two,
             ) == await sequence
+
+
+def test_fold_loop_recursion_limit():
+    """Ensures that ``.loop`` method is recurion safe."""
+    limit = sys.getrecursionlimit() + 1
+    iterable = (IO(1) for _ in range(limit))
+    assert Fold.loop(iterable, IO(0), _sum_two) == IO(limit)