change effect to use Except instances instead of exc_info tuples.

This means that effect now only supports Python 3 and above.

Author: radix

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "C:\\Users\\radix\\.virtualenvs\\effect\\Scripts\\python.exe"
+}

docs/source/intro.rst

@@ -47,7 +47,7 @@ the ``on`` method:
     def greet():
         return get_user_name().on(
             success=lambda r: Effect(Print("Hello,", r)),
-            error=lambda exc_info: Effect(Print("There was an error!", exc_info[1])))
+            error=lambda exc: Effect(Print("There was an error!", exc)))
 
 
 (Here we assume another intent, ``Print``, which shows some text to the user.)

effect/_base.py

@@ -2,13 +2,10 @@
 from __future__ import print_function, absolute_import
 
 import sys
-
 from functools import partial
 
 import attr
 
-import six
-
 from ._continuation import trampoline
 
 
@@ -34,8 +31,7 @@ def on(self, success=None, error=None):
         The result of the Effect will be passed to the first callback. Any
         callbacks added afterwards will receive the result of the previous
         callback. Normal return values are passed on to the next ``success``
-        callback, and exceptions are passed to the next ``error`` callback
-        as a ``sys.exc_info()`` tuple.
+        callback, and exceptions are passed to the next ``error`` callback.
 
         If a callback returns an :obj:`Effect`, the result of that
         :obj:`Effect` will be passed to the next callback.
@@ -62,7 +58,7 @@ def succeed(self, result):
 
     def fail(self, result):
         """
-        Indicate that the effect has failed. result must be an exc_info tuple.
+        Indicate that the effect has failed. result must be an exception.
         """
         self._cont((True, result))
 
@@ -71,13 +67,13 @@ def guard(f, *args, **kwargs):
     """
     Run a function.
 
-    Return (is_error, result), where is_error is a boolean indicating whether
-    it raised an exception. In that case result will be ``sys.exc_info()``.
+    Return (is_error, result), where ``is_error`` is a boolean indicating whether
+    it raised an exception. In that case, ``result`` will be an exception.
     """
     try:
         return (False, f(*args, **kwargs))
-    except:
-        return (True, sys.exc_info())
+    except Exception as e:
+        return (True, e)
 
 
 class NoPerformerFoundError(Exception):
@@ -110,7 +106,7 @@ def perform(dispatcher, effect):
     or return another Effect, which will be recursively performed, such that
     the result of the returned Effect becomes the result passed to the next
     callback. In the case of exceptions, the next error-callback will be called
-    with a ``sys.exc_info()``-style tuple.
+    with the exception instance.
 
     :returns: None
 
@@ -123,9 +119,8 @@ def perform(dispatcher, effect):
        passed three arguments, not two: the dispatcher, the intent, and a
        "box". The box is an object that lets the performer provide the result,
        optionally asynchronously. To provide the result, use
-       ``box.succeed(result)`` or ``box.fail(exc_info)``, where ``exc_info`` is
-       a ``sys.exc_info()``-style tuple. Decorators like :func:`sync_performer`
-       simply abstract this away.
+       ``box.succeed(result)`` or ``box.fail(exc)``, where ``exc`` is
+       an exception. Decorators like :func:`sync_performer` simply abstract this away.
     """
     def _run_callbacks(bouncer, chain, result):
         is_error, value = result
@@ -156,8 +151,7 @@ def _perform(bouncer, effect):
                     effect.intent,
                     _Box(partial(bouncer.bounce,
                                  _run_callbacks, effect.callbacks)))
-        except:
-            e = sys.exc_info()
+        except Exception as e:
             _run_callbacks(bouncer, effect.callbacks, (True, e))
 
     trampoline(_perform, effect)
@@ -168,27 +162,25 @@ 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!"))
+                           lambda exc: "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)
+    def catcher(error):
+        if isinstance(error, exc_type):
+            return callable(error)
+        raise error
     return catcher
 
 
-def raise_(exception, tb=None):
-    """Simple convenience function to allow raising exceptions from lambdas.
-
-    This is slightly more convenient than ``six.reraise`` because it takes an
-    exception instance instead of needing the type separate from the instance.
+def raise_(exception):
+    """Simple convenience function to allow raising exceptions as an expression,
+    useful in lambdas.
 
     :param exception: An exception *instance* (not an exception type).
 
-    - ``raise_(exc)`` is the same as ``raise exc``.
-    - ``raise_(exc, tb)`` is the same as ``raise type(exc), exc, tb``.
+    ``raise_(exc)`` is the same as ``raise exc``.
     """
-    six.reraise(type(exception), exception, tb)
+    raise exception
+

effect/_intents.py

@@ -77,7 +77,7 @@ def parallel_all_errors(effects):
     :param effects: Effects which should be performed in parallel.
     :return: An Effect that results in a list of ``(is_error, result)`` tuples,
         where ``is_error`` is True if the child effect raised an exception, in
-        which case ``result`` will be an exc_info tuple. If ``is_error`` is
+        which case ``result`` will be the exception. If ``is_error`` is
         False, then ``result`` will just be the result as provided by the child
         effect.
     """
@@ -93,12 +93,12 @@ class FirstError(Exception):
     One of the effects in a :obj:`ParallelEffects` resulted in an error. This
     represents the first such error that occurred.
     """
-    exc_info = attr.ib()
+    exception = attr.ib()
     index = attr.ib()
 
     def __str__(self):
         return '(index=%s) %s: %s' % (
-            self.index, self.exc_info[0].__name__, self.exc_info[1])
+            self.index, type(self.exception).__name__, self.exception)
 
 
 @attr.s

effect/_sync.py

@@ -31,7 +31,7 @@ def sync_perform(dispatcher, effect):
     if successes:
         return successes[0]
     elif errors:
-        six.reraise(*errors[0])
+        raise errors[0]
     else:
         raise NotSynchronousError("Performing %r was not synchronous!"
                                   % (effect,))
@@ -70,6 +70,6 @@ def sync_wrapper(*args, **kwargs):
         pass_args = args[:-1]
         try:
             box.succeed(f(*pass_args, **kwargs))
-        except:
-            box.fail(sys.exc_info())
+        except Exception as e:
+            box.fail(e)
     return sync_wrapper

effect/_test_utils.py

@@ -5,7 +5,7 @@
 
 import attr
 
-from testtools.matchers import Equals
+from testtools.matchers import Equals, Mismatch
 
 
 @attr.s
@@ -20,35 +20,39 @@ def describe(self):
                 + ''.join(self.got_tb)
                 + "\nbut it doesn't.")
 
+@attr.s
+class MatchesException(object):
+    expected = attr.ib()
+
+    def match(self, other):
+        expected_type = type(self.expected)
+        if type(other) is not expected_type:
+            return Mismatch('{} is not a {}'.format(other, expected_type))
+        if other.args != self.expected.args:
+            return Mismatch('{} has different arguments: {}.'.format(
+                    other.args, self.expected.args))
+
 
 @attr.s
 class MatchesReraisedExcInfo(object):
 
     expected = attr.ib()
 
     def match(self, actual):
-        valcheck = Equals(self.expected[1]).match(actual[1])
+        valcheck = Equals(self.expected.args).match(actual.args)
         if valcheck is not None:
             return valcheck
-        typecheck = Equals(self.expected[0]).match(actual[0])
+        typecheck = Equals(type(self.expected)).match(type(actual))
         if typecheck is not None:
             return typecheck
-        expected = traceback.format_exception(*self.expected)
-        new = traceback.format_exception(*actual)
+        expected = list(traceback.TracebackException.from_exception(self.expected).format())
+        new = list(traceback.TracebackException.from_exception(actual).format())
         tail_equals = lambda a, b: a == b[-len(a):]
         if not tail_equals(expected[1:], new[1:]):
             return ReraisedTracebackMismatch(expected_tb=expected,
                                              got_tb=new)
 
 
-def get_exc_info(exception):
-    """Get an exc_info tuple based on an exception instance."""
-    try:
-        raise exception
-    except:
-        return sys.exc_info()
-
-
 def raise_(e):
     """Raise an exception instance. Exists so you can raise in a lambda."""
     raise e

effect/do.py

@@ -95,7 +95,7 @@ def foo():
 def _do(result, generator, is_error):
     try:
         if is_error:
-            val = generator.throw(*result)
+            val = generator.throw(result)
         else:
             val = generator.send(result)
     except StopIteration as stop:
@@ -104,8 +104,7 @@ def _do(result, generator, is_error):
         # case where some other code is raising StopIteration up through this
         # generator, in which case we shouldn't really treat it like a function
         # return -- it could quite easily hide bugs.
-        tb = sys.exc_info()[2]
-        if tb.tb_next:
+        if stop.__traceback__.tb_next:
             raise
         else:
             # Python 3 allows you to use `return val` in a generator, which

effect/fold.py

@@ -9,15 +9,14 @@ 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.
+    :ivar wrapped_exception: 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_exception(*self.wrapped_exception)
+        tb_lines = traceback.TracebackException.from_exception(self.wrapped_exception).format()
         tb = ''.join(tb_lines)
         st = (
             "<FoldError after accumulating %r> Original traceback follows:\n%s"

effect/parallel_async.py

@@ -28,9 +28,7 @@ def succeed(index, result):
             box.succeed(results)
 
     def fail(index, result):
-        box.fail((FirstError,
-                  FirstError(exc_info=result, index=index),
-                  result[2]))
+        box.fail(FirstError(exception=result, index=index))
 
     for index, effect in enumerate(effects):
         perform(

effect/retry.py

@@ -14,15 +14,15 @@ def retry(effect, should_retry):
     will fail with the most recent error from func.
 
     :param effect.Effect effect: Any effect.
-    :param should_retry: A function which should take an exc_info tuple as an
+    :param should_retry: A function which should take an exception as an
         argument and return an effect of bool.
     """
 
     def maybe_retry(error, retry_allowed):
         if retry_allowed:
             return try_()
         else:
-            six.reraise(*error)
+            raise error
 
     def try_():
         return effect.on(