Add error-handling support to fold_effect

Author: radix

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,7 +38,11 @@ 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,11 +1,19 @@
 
 import operator
 
-from effect import ComposedDispatcher, Effect, base_dispatcher, sync_perform
-from effect.fold import fold_effect
+from pytest import raises
+
+from effect import (
+    ComposedDispatcher, Effect, Error,
+    base_dispatcher, sync_perform)
+from effect.fold import FoldError, fold_effect
 from effect.testing import SequenceDispatcher
 
 
+def _disp(dispatcher):
+    return ComposedDispatcher([dispatcher, base_dispatcher])
+
+
 def test_fold_effect():
     """Behaves like foldM."""
     effs = [Effect('a'), Effect('b'), Effect('c')]
@@ -18,9 +26,7 @@ def test_fold_effect():
     eff = fold_effect(operator.add, 'Nil', effs)
 
     with dispatcher.consume():
-        result = sync_perform(
-            ComposedDispatcher([dispatcher, base_dispatcher]),
-            eff)
+        result = sync_perform(_disp(dispatcher), eff)
     assert result == 'NilEiBeeCee'
 
 
@@ -31,3 +37,24 @@ def test_fold_effect_empty():
     eff = fold_effect(operator.add, 0, [])
     result = sync_perform(base_dispatcher, eff)
     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'