Add a draft of tryf (handle exceptions in an expression position)

Technologicat · Technologicat · commit 14b0de003582 · 2020-08-12T13:07:08.000+03:00
diff --git a/unpythonic/misc.py b/unpythonic/misc.py
@@ -31,6 +31,7 @@
 
 from .regutil import register_decorator
 from .lazyutil import passthrough_lazy_args, maybe_force_args, force
+from .arity import arity_includes, UnknownArity
 
 # Only the single-argument form (just f) of the "call" decorator is supported by unpythonic.syntax.util.sort_lambda_decorators.
 #
@@ -252,6 +253,75 @@ def raisef(exc, *args, cause=None, **kwargs):
     else:
         raise exc
 
+def tryf(body, *handlers, elsef=None, finallyf=None):
+    """``try``/``except``/``finally`` as a function.
+
+    This allows lambdas to handle exceptions.
+
+    ``body`` is a thunk (0-argument function) that represents
+    the body of the ``try`` block.
+
+    ``handlers`` is ``((excspec, handler), ...)``, where
+                 ``excspec`` is either an exception type,
+                             or a tuple of exception types.
+                 ``handler`` is a 0-argument or 1-argument
+                             function. If it takes an
+                             argument, it gets the exception
+                             instance.
+
+                 Handlers are tried in the order specified.
+
+    ``elsef`` is a thunk that represents the ``else`` block.
+
+    ``finallyf`` is a thunk that represents the ``finally`` block.
+
+    Upon normal completion, the return value of ``tryf`` is
+    the return value of ``elsef`` if that was specified, otherwise
+    the return value of ``body``.
+
+    If an exception was caught by one of the handlers, the return
+    value of ``tryf`` is the return value of the exception handler
+    that ran.
+
+    If you need to share variables between ``body`` and ``finallyf``
+    (which is likely, given what a ``finally`` block is intended
+    to do), consider wrapping the ``tryf`` in a ``let`` and
+    storing your variables there.
+    """
+    def takes_arg(f):
+        try:
+            if arity_includes(f, 1):
+                return True
+        except UnknownArity:
+            pass
+        return False
+
+    try:
+        ret = body()
+    except BaseException as e:
+        for excspec, handler in handlers:
+            if isinstance(excspec, tuple):  # tuple of exception types
+                if not all(issubclass(t, BaseException) for t in excspec):
+                    raise ValueError("All elements of a tuple excspec must be exception types")
+                if any(isinstance(e, t) for t in excspec):
+                    if takes_arg(handler):
+                        return handler(e)
+                    return handler()
+            elif issubclass(excspec, BaseException):  # single exception type
+                if isinstance(e, excspec):
+                    if takes_arg(handler):
+                        return handler(e)
+                    return handler()
+            else:
+                raise ValueError("excspec must be an exception type or tuple of exception types")
+    else:
+        if elsef is not None:
+            return elsef()
+        return ret
+    finally:
+        if finallyf is not None:
+            finallyf()
+
 def pack(*args):
     """Multi-argument constructor for tuples.
 
diff --git a/unpythonic/test/test_misc.py b/unpythonic/test/test_misc.py
@@ -8,7 +8,7 @@
 from time import sleep
 import threading
 
-from ..misc import (call, callwith, raisef, pack, namelambda, timer,
+from ..misc import (call, callwith, raisef, tryf, pack, namelambda, timer,
                     getattrrec, setattrrec, Popper, CountingIterator, ulp, slurp,
                     async_raise)
 from ..fun import withself
@@ -121,6 +121,17 @@ def mul3(a, b, c):
     else:
         assert False
 
+    # tryf: handle an exception in an expression position
+    assert tryf(lambda: "hello") == "hello"
+    assert tryf(lambda: "hello",
+                elsef=lambda: "there") == "there"
+    assert tryf(lambda: myfunc(),
+                (ValueError, lambda: "got a ValueError")) == "got a ValueError"
+    assert tryf(lambda: raisef(ValueError("oof")),
+                (TypeError, lambda: "got a TypeError"),
+                ((TypeError, ValueError), lambda: "got a TypeError or a ValueError"),
+                (ValueError, lambda: "got a ValueError")) == "got a TypeError or a ValueError"
+
     myzip = lambda lol: map(pack, *lol)
     lol = ((1, 2), (3, 4), (5, 6))
     assert tuple(myzip(lol)) == ((1, 3, 5), (2, 4, 6))
