- avoid hashing altogether (and revert hashability changes)

- add a handy `catch` function for error handling of specific types

Author: radix

effect/__init__.py

@@ -9,7 +9,7 @@
 
 from __future__ import absolute_import
 
-from ._base import Effect, perform, NoPerformerFoundError
+from ._base import Effect, perform, NoPerformerFoundError, catch
 from ._sync import (
     NotSynchronousError,
     sync_perform,
@@ -28,4 +28,5 @@
     "Constant", "Error", "FirstError", "Func",
     "base_dispatcher",
     "TypeDispatcher", "ComposedDispatcher",
+    "catch",
 ]

effect/_base.py

@@ -7,6 +7,8 @@
 
 from characteristic import attributes
 
+import six
+
 from ._continuation import trampoline
 
 
@@ -26,7 +28,7 @@ def __init__(self, intent, callbacks=None):
         """
         self.intent = intent
         if callbacks is None:
-            callbacks = ()
+            callbacks = []
         self.callbacks = callbacks
 
     def on(self, success=None, error=None):
@@ -44,7 +46,7 @@ def on(self, success=None, error=None):
         :obj:`Effect` will be passed to the next callback.
         """
         return Effect(self.intent,
-                      callbacks=self.callbacks + ((success, error),))
+                      callbacks=self.callbacks + [(success, error)])
 
 
 class _Box(object):
@@ -149,3 +151,20 @@ def _perform(bouncer, effect):
             _run_callbacks(bouncer, effect.callbacks, (True, e))
 
     trampoline(_perform, effect)
+
+
+def catch(exc_type, callable):
+    """
+    A helper for handling errors of a specific type.
+
+        eff.on(error=catch(SpecificException,
+                           lambda exc_info: "got an error!"))
+
+    If any exception other than a ``SpecificException`` is thrown, it will be
+    ignored by this handler and propogate further down the chain of callbacks.
+    """
+    def catcher(exc_info):
+        if isinstance(exc_info[1], exc_type):
+            return callable(exc_info)
+        six.reraise(*exc_info)
+    return catcher

effect/_intents.py

@@ -45,7 +45,7 @@ def __init__(self, effects):
         """
         :param effects: Effects which should be performed in parallel.
         """
-        self.effects = tuple(effects)
+        self.effects = effects
 
 
 def parallel(effects):

effect/test_base.py

@@ -288,14 +288,3 @@ def get_stack(_):
         perform(func_dispatcher, eff)
         boxes[0].succeed('foo')
         self.assertEqual(calls[0], calls[1])
-
-
-class HashTests(TestCase):
-    """Tests for hashing of effects."""
-
-    def test_hashable(self):
-        """
-        Effects are hashable, despite the fact that the callbacks are stored as
-        a list.
-        """
-        hash(Effect(None))

effect/test_intents.py

@@ -10,7 +10,6 @@
     Constant, perform_constant,
     Error, perform_error,
     Func, perform_func,
-    parallel,
     FirstError)
 
 
@@ -59,7 +58,3 @@ def test_first_error_str(self):
         self.assertEqual(
             str(fe),
             '(index=150) ValueError: foo')
-
-    def test_hashable(self):
-        """ParallelIntents are hashable."""
-        hash(parallel([Effect(None), Effect(None)]))

effect/test_testing.py

@@ -164,7 +164,7 @@ def test_non_test_intent(self):
         eff = ESConstant("foo").on(success=lambda r: bare_effect)
         result_eff = resolve_stubs(base_dispatcher, eff)
         self.assertIs(result_eff.intent, bare_effect.intent)
-        self.assertEqual(result_eff.callbacks, ())
+        self.assertEqual(result_eff.callbacks, [])
 
     def test_type_error(self):
         """

effect/testing.py

@@ -190,5 +190,6 @@ def __init__(self, mapping):
         self.mapping = mapping
 
     def __call__(self, intent):
-        if intent in self.mapping:
-            return sync_performer(lambda d, i: self.mapping[intent])
+        for k, v in self.mapping.iteritems():
+            if k == intent:
+                return sync_performer(lambda d, i: v)