get rid of the "_sneaky" hack. Wasn't worth it, because to make it work in the empty case required an Effect(Constant()) anyway.

Author: radix

effect/fold.py

@@ -1,6 +1,6 @@
 from functools import reduce
 
-_sneaky = object()
+from effect import Constant, Effect
 
 
 def fold_effect(f, initial, effects):
@@ -19,15 +19,6 @@ def fold_effect(f, initial, effects):
     """
 
     def folder(acc, element):
-        # A bit of a hack here. We could just wrap `initial` in a
-        # Effect(Constant()), but to simplify testing we avoid the additional
-        # Effect by "sneaking" it in this way.
+        return acc.on(lambda r: element.on(lambda r2: f(r, r2)))
 
-        # This way people can use SequenceDispatcher and not get anything
-        # unexpected.
-        if acc is _sneaky:
-            return element.on(lambda r: f(initial, r))
-        else:
-            return acc.on(lambda r: element.on(lambda r2: f(r, r2)))
-
-    return reduce(folder, effects, _sneaky)
+    return reduce(folder, effects, Effect(Constant(initial)))

effect/test_fold.py

@@ -1,12 +1,13 @@
 
 import operator
 
-from effect import Effect, sync_perform
+from effect import ComposedDispatcher, Effect, base_dispatcher, sync_perform
 from effect.fold import fold_effect
 from effect.testing import SequenceDispatcher
 
 
 def test_fold_effect():
+    """Behaves like foldM."""
     effs = [Effect('a'), Effect('b'), Effect('c')]
 
     dispatcher = SequenceDispatcher([
@@ -17,5 +18,16 @@ def test_fold_effect():
     eff = fold_effect(operator.add, 'Nil', effs)
 
     with dispatcher.consume():
-        result = sync_perform(dispatcher, eff)
+        result = sync_perform(
+            ComposedDispatcher([dispatcher, base_dispatcher]),
+            eff)
     assert result == 'NilEiBeeCee'
+
+
+def test_fold_effect_empty():
+    """
+    Returns an Effect resulting in the initial value when there are no effects.
+    """
+    eff = fold_effect(operator.add, 0, [])
+    result = sync_perform(base_dispatcher, eff)
+    assert result == 0