Merge branch 'foldE' into sequence

Conflicts:
	effect/test_fold.py

Author: radix

docs/source/api/effect.fold.rst

@@ -0,0 +1,7 @@
+effect.fold module
+==================
+
+.. automodule:: effect.fold
+    :members:
+    :undoc-members:
+    :show-inheritance:

docs/source/api/effect.rst

@@ -8,6 +8,7 @@ Submodules
 
    effect.async
    effect.do
+   effect.fold
    effect.ref
    effect.retry
    effect.testing

effect/fold.py

@@ -1,8 +1,28 @@
+import traceback
 from functools import reduce
 
 from effect import Constant, Effect
 
 
+class FoldError(Exception):
+    """
+    Raised when one of the Effects passed to :func:`fold_effect` fails.
+
+    :ivar accumulator: The data accumulated so far, before the failing Effect.
+    :ivar wrapped_exception: The exc_info tuple representing the original
+        exception raised by the failing Effect.
+    """
+    def __init__(self, accumulator, wrapped_exception):
+        self.accumulator = accumulator
+        self.wrapped_exception = wrapped_exception
+
+    def __str__(self):
+        tb_lines = traceback.format_tb(self.wrapped_exception[2])
+        tb = ''.join(tb_lines)
+        return "FoldError(%r, %r) -> ORIGINAL TRACEBACK FOLLOWS\n%s" % (
+            self.accumulator, self.wrapped_exception, tb)
+
+
 def fold_effect(f, initial, effects):
     """
     Fold over effects.
@@ -18,8 +38,12 @@ def fold_effect(f, initial, effects):
     :param effects: sequence of Effects.
     """
 
+    def failed(acc, e):
+        raise FoldError(acc, e)
+
     def folder(acc, element):
-        return acc.on(lambda r: element.on(lambda r2: f(r, r2)))
+        return acc.on(lambda r: element.on(lambda r2: f(r, r2),
+                                           error=lambda e: failed(r, e)))
 
     return reduce(folder, effects, Effect(Constant(initial)))
 

effect/test_fold.py

@@ -1,8 +1,12 @@
 
 import operator
 
-from effect import ComposedDispatcher, Effect, base_dispatcher, sync_perform
-from effect.fold import fold_effect, sequence
+from pytest import raises
+
+from effect import (
+    ComposedDispatcher, Effect, Error,
+    base_dispatcher, sync_perform)
+from effect.fold import FoldError, fold_effect, sequence
 from effect.testing import SequenceDispatcher
 
 
@@ -34,6 +38,27 @@ def test_fold_effect_empty():
     assert result == 0
 
 
+def test_fold_effect_errors():
+    """
+    When one of the effects in the folding list fails, a FoldError is raised
+    with the accumulator so far.
+    """
+    effs = [Effect('a'), Effect(Error(ZeroDivisionError('foo'))), Effect('c')]
+
+    dispatcher = SequenceDispatcher([
+        ('a', lambda i: 'Ei'),
+    ])
+
+    eff = fold_effect(operator.add, 'Nil', effs)
+
+    with dispatcher.consume():
+        with raises(FoldError) as excinfo:
+            sync_perform(_disp(dispatcher), eff)
+    assert excinfo.value.accumulator == 'NilEi'
+    assert excinfo.value.wrapped_exception[0] is ZeroDivisionError
+    assert str(excinfo.value.wrapped_exception[1]) == 'foo'
+
+
 def test_sequence():
     """Collects each Effectful result into a list."""
     effs = [Effect('a'), Effect('b'), Effect('c')]