Merge pull request #52 from python-effect/sequence

add a `sequence` function based on `fold_effect`

Author: radix

effect/fold.py

@@ -57,3 +57,20 @@ def folder(acc, element):
                                            error=lambda e: failed(r, e)))
 
     return reduce(folder, effects, Effect(Constant(initial)))
+
+
+def sequence(effects):
+    """
+    Perform each Effect serially, collecting their results into a list.
+
+    :raises: :obj:`FoldError` with the list accumulated so far when an effect
+        fails.
+    """
+    # Could be: folder = lambda acc, el: acc + [el]
+    # But, for peformance:
+    l = []
+
+    def folder(acc, el):
+        l.append(el)
+        return l
+    return fold_effect(folder, l, effects)

effect/test_fold.py

@@ -6,7 +6,7 @@
 from effect import (
     ComposedDispatcher, Effect, Error,
     base_dispatcher, sync_perform)
-from effect.fold import FoldError, fold_effect
+from effect.fold import FoldError, fold_effect, sequence
 from effect.testing import SequenceDispatcher
 
 
@@ -62,3 +62,44 @@ def test_fold_effect_errors():
     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')]
+    dispatcher = SequenceDispatcher([
+        ('a', lambda i: 'Ei'),
+        ('b', lambda i: 'Bee'),
+        ('c', lambda i: 'Cee'),
+    ])
+    eff = sequence(effs)
+
+    with dispatcher.consume():
+        result = sync_perform(_base_and(dispatcher), eff)
+    assert result == ['Ei', 'Bee', 'Cee']
+
+
+def test_sequence_empty():
+    """Returns an empty list when there are no Effects."""
+    assert sync_perform(base_dispatcher, sequence([])) == []
+
+
+def test_sequence_error():
+    """
+    Allows :obj:`FoldError` to be raised when an Effect fails. The list
+    accumulated so far is the `accumulator` value in the :obj:`FoldError`.
+    """
+    effs = [Effect('a'), Effect(Error(ZeroDivisionError('foo'))), Effect('c')]
+
+    dispatcher = SequenceDispatcher([
+        ('a', lambda i: 'Ei'),
+    ])
+
+    eff = sequence(effs)
+
+    with dispatcher.consume():
+        with raises(FoldError) as excinfo:
+            sync_perform(_base_and(dispatcher), eff)
+    assert excinfo.value.accumulator == ['Ei']
+    assert excinfo.value.wrapped_exception[0] is ZeroDivisionError
+    assert str(excinfo.value.wrapped_exception[1]) == 'foo'