Make raisef more pythonic; support also raise ... from ...

Technologicat · Technologicat · commit 52a34d901262 · 2020-03-01T13:05:30.000+02:00
See #30. Now all that's left is to drop support for the old-style parameters when v0.15.0 hits.
diff --git a/doc/features.md b/doc/features.md
@@ -2745,12 +2745,19 @@ Inspired by *Function application with $* in [LYAH: Higher Order Functions](http
 
 ### ``raisef``: ``raise`` as a function
 
+*Changed in v0.14.2.* The parameters of `raisef` now more closely match what would be passed to `raise`. See examples below. Old-style parameters are now deprecated, and support for them will be dropped in v0.15.0.
+
 Raise an exception from an expression position:
 
 ```python
 from unpythonic import raisef
 
-f = lambda x: raisef(RuntimeError, "I'm in ur lambda raising exceptions")
+# plain `raise ...`
+f = lambda x: raisef(RuntimeError("I'm in ur lambda raising exceptions"))
+
+# `raise ... from ...`
+exc = TypeError("oof")
+g = lambda x: raisef(RuntimeError("I'm in ur lambda raising exceptions"), cause=exc)
 ```
 
 
diff --git a/unpythonic/misc.py b/unpythonic/misc.py
@@ -208,28 +208,48 @@ def applyfrozenargsto(f):
         return maybe_force_args(force(f), *args, **kwargs)
     return applyfrozenargsto
 
-def raisef(exctype, *args, **kwargs):
+def raisef(exc, *args, cause=None, **kwargs):
     """``raise`` as a function, to make it possible for lambdas to raise exceptions.
 
     Example::
 
-        raisef(ValueError, "message")
+        raisef(ValueError("message"))
 
     is (almost) equivalent to::
 
         raise ValueError("message")
 
     Parameters:
-        exctype: type
+        exc: exception instance, or exception class
+            The object to raise. This is whatever you would give as the argument to `raise`.
+            Both instances (e.g. `ValueError("oof")`) and classes (e.g. `StopIteration`)
+            can be used as `exc`.
+
+        cause: exception instance, or `None`
+            If `exc` was triggered as a direct consequence of another exception,
+            and you would like to `raise ... from ...`, pass that other exception
+            instance as `cause`. The default `None` performs a plain `raise ...`.
+
+    *Changed in v0.14.2.* The parameters have changed to match `raise` itself as closely
+    as possible. Old-style parameters are still supported, but are now deprecated. Support
+    for them will be dropped in v0.15.0. The old-style parameters are:
+
+        exc: type
             The object type to raise as an exception.
 
         *args: anything
-            Passed on to the constructor of exctype.
+            Passed on to the constructor of exc.
 
         **kwargs: anything
-            Passed on to the constructor of exctype.
+            Passed on to the constructor of exc.
     """
-    raise exctype(*args, **kwargs)
+    if args or kwargs:  # old-style parameters
+        raise exc(*args, **kwargs)
+
+    if cause:
+        raise exc from cause
+    else:
+        raise exc
 
 def pack(*args):
     """Multi-argument constructor for tuples.
diff --git a/unpythonic/test/test_misc.py b/unpythonic/test/test_misc.py
@@ -93,6 +93,26 @@ def mul3(a, b, c):
     m = (f(3) for f in [lambda x: 2 * x, lambda x: x**2, lambda x: x**(1 / 2)])
     assert tuple(m) == (6, 9, 3**(1 / 2))
 
+    # raisef: raise an exception from an expression position
+    l = lambda: raisef(ValueError("all ok"))  # the argument works the same as in `raise ...`
+    try:
+        l()
+    except ValueError as err:
+        assert err.__cause__ is None  # like plain `raise ...`, no cause set (default behavior)
+    else:
+        assert False
+
+    # using the `cause` parameter, raisef can also perform a `raise ... from ...`
+    exc = TypeError("oof")
+    l = lambda: raisef(ValueError("all ok"), cause=exc)
+    try:
+        l()
+    except ValueError as err:
+        assert err.__cause__ is exc  # cause specified, like `raise ... from ...`
+    else:
+        assert False
+
+    # raisef with old-style parameters (as of v0.14.2, deprecated, will be dropped in v0.15.0)
     l = lambda: raisef(ValueError, "all ok")
     try:
         l()
