EQDispatcher pretty much requires that everything be hashable

Author: radix

effect/_base.py

@@ -26,7 +26,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 +44,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):

effect/_intents.py

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

effect/test_base.py

@@ -288,3 +288,14 @@ 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,6 +10,7 @@
     Constant, perform_constant,
     Error, perform_error,
     Func, perform_func,
+    parallel,
     FirstError)
 
 
@@ -58,3 +59,7 @@ 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):
         """