Style: eliminate line continuations for great justice

Technologicat · Technologicat · commit bf8b0075aced · 2020-08-10T01:57:44.000+03:00
More pythonic to use parentheses.
diff --git a/unpythonic/ec.py b/unpythonic/ec.py
@@ -200,15 +200,18 @@ def s(loop, acc=0, i=0):
         else:  # single tag
             tags = set((tags,))
 
+    def shouldcatch(e):
+        return ((tags is None and e.allow_catchall) or
+                (catch_untagged and e.tag is None) or
+                (tags is not None and e.tag is not None and e.tag in tags))
+
     def decorator(f):
         @wraps(f)
         def catchpoint(*args, **kwargs):
             try:
                 return f(*args, **kwargs)
             except Escape as e:
-                if (tags is None and e.allow_catchall) or \
-                   (catch_untagged and e.tag is None) or \
-                   (tags is not None and e.tag is not None and e.tag in tags):
+                if shouldcatch(e):
                     return e.value
                 else:  # meant for someone else, pass it on
                     raise
diff --git a/unpythonic/fold.py b/unpythonic/fold.py
@@ -284,8 +284,8 @@ def unfold1(proc, init):
         def step2(k):  # x0, x0 + 2, x0 + 4, ...
             return (k, k + 2)
 
-        assert tuple(take(10, unfold1(step2, 10))) == \\
-               (10, 12, 14, 16, 18, 20, 22, 24, 26, 28)
+        assert (tuple(take(10, unfold1(step2, 10))) ==
+                (10, 12, 14, 16, 18, 20, 22, 24, 26, 28))
     """
     state = init
     while True:
@@ -309,8 +309,8 @@ def unfold(proc, *inits):
         def fibo(a, b):
             return (a, b, a + b)
 
-        assert tuple(take(10, unfold(fibo, 1, 1))) == \\
-               (1, 1, 2, 3, 5, 8, 13, 21, 34, 55)
+        assert (tuple(take(10, unfold(fibo, 1, 1))) ==
+                (1, 1, 2, 3, 5, 8, 13, 21, 34, 55))
     """
     states = inits
     while True:
diff --git a/unpythonic/it.py b/unpythonic/it.py
@@ -203,18 +203,18 @@ def msqrt(x):  # multivalued sqrt
             else:
                 s = x**0.5
                 return (s, -s)
-        assert tuple(flatmap(msqrt, (0, 1, 4, 9))) == \\
-               (0., 1., -1., 2., -2., 3., -3.)
+        assert (tuple(flatmap(msqrt, (0, 1, 4, 9))) ==
+                (0., 1., -1., 2., -2., 3., -3.))
 
         def add_and_tuplify(a, b):
             return (a + b,)
-        assert tuple(flatmap(add_and_tuplify, (10, 20, 30), (1, 2, 3))) == \\
-               (11, 22, 33)
+        assert (tuple(flatmap(add_and_tuplify, (10, 20, 30), (1, 2, 3))) ==
+                (11, 22, 33))
 
         def sum_and_diff(a, b):
             return (a + b, a - b)
-        assert tuple(flatmap(sum_and_diff, (10, 20, 30), (1, 2, 3))) == \\
-               (11, 9, 22, 18, 33, 27)
+        assert (tuple(flatmap(sum_and_diff, (10, 20, 30), (1, 2, 3))) ==
+                (11, 9, 22, 18, 33, 27))
     """
     yield from chain.from_iterable(map(f, iterable0, *iterables))
 #    for xs in map(f, iterable0, *iterables):
@@ -531,10 +531,10 @@ def flatten_in(iterable, pred=None):
 
         is_nested = lambda e: all(isinstance(x, (list, tuple)) for x in e)
         data = (((1, 2), ((3, 4), (5, 6)), 7), ((8, 9), (10, 11)))
-        assert tuple(flatten(data, is_nested))    == \\
-               (((1, 2), ((3, 4), (5, 6)), 7), (8, 9), (10, 11))
-        assert tuple(flatten_in(data, is_nested)) == \\
-               (((1, 2), (3, 4), (5, 6), 7), (8, 9), (10, 11))
+        assert (tuple(flatten(data, is_nested)) ==
+                (((1, 2), ((3, 4), (5, 6)), 7), (8, 9), (10, 11)))
+        assert (tuple(flatten_in(data, is_nested)) ==
+                (((1, 2), (3, 4), (5, 6), 7), (8, 9), (10, 11)))
     """
     pred = pred or (lambda x: True)
     it = iter(iterable)
diff --git a/unpythonic/syntax/autoref.py b/unpythonic/syntax/autoref.py
@@ -89,19 +89,19 @@ def isexpandedautorefblock(tree):
         if not (type(tree) is With and len(tree.items) == 1):
             return False
         ctxmanager = tree.items[0].context_expr
-        return type(ctxmanager) is Call and \
-                 type(ctxmanager.func) is Name and ctxmanager.func.id == "AutorefMarker" and \
-                 len(ctxmanager.args) == 1 and type(ctxmanager.args[0]) is Str
+        return (type(ctxmanager) is Call and
+                type(ctxmanager.func) is Name and ctxmanager.func.id == "AutorefMarker" and
+                len(ctxmanager.args) == 1 and type(ctxmanager.args[0]) is Str)
     def getreferent(tree):
         return tree.items[0].context_expr.args[0].s
 
     # (lambda _ar314: _ar314[1] if _ar314[0] else x)(_autoref_resolve((p, o, "x")))
     def isautoreference(tree):
-        return type(tree) is Call and \
-               len(tree.args) == 1 and type(tree.args[0]) is Call and \
-               type(tree.args[0].func) is Name and tree.args[0].func.id == "_autoref_resolve" and \
-               type(tree.func) is Lambda and len(tree.func.args.args) == 1 and \
-               tree.func.args.args[0].arg.startswith("_ar")
+        return (type(tree) is Call and
+                len(tree.args) == 1 and type(tree.args[0]) is Call and
+                type(tree.args[0].func) is Name and tree.args[0].func.id == "_autoref_resolve" and
+                type(tree.func) is Lambda and len(tree.func.args.args) == 1 and
+                tree.func.args.args[0].arg.startswith("_ar"))
     def get_resolver_list(tree):  # (p, o, "x")
         return tree.args[0].args[0].elts
     def add_to_resolver_list(tree, objnode):
diff --git a/unpythonic/syntax/lambdatools.py b/unpythonic/syntax/lambdatools.py
@@ -186,6 +186,10 @@ def getargs(tree):  # tree: FunctionDef, AsyncFunctionDef, Lambda
             argnames.append(a.kwarg.arg)
         return argnames
 
+    def isfunctionoruserlambda(tree):
+        return ((type(tree) in (FunctionDef, AsyncFunctionDef)) or
+                (type(tree) is Lambda and id(tree) in userlambdas))
+
     # Create a renamed reference to the env() constructor to be sure the Call
     # nodes added by us have a unique .func (not used by other macros or user code)
     _ismakeenv = make_isxpred("_envify")
@@ -199,8 +203,7 @@ def isourupdate(thecall):
                 return False
             return thecall.func.attr == "update" and any(isx(thecall.func.value, x) for x in enames)
 
-        if type(tree) in (FunctionDef, AsyncFunctionDef) or \
-           (type(tree) is Lambda and id(tree) in userlambdas):
+        if isfunctionoruserlambda(tree):
             argnames = getargs(tree)
             if argnames:
                 # prepend env init to function body, update bindings
diff --git a/unpythonic/syntax/lazify.py b/unpythonic/syntax/lazify.py
@@ -267,9 +267,9 @@ def transform_starred(tree, dstarred=False):
             # namelambda() is used by let[] and do[]
             # Lazy() is a strict function, takes a lambda, constructs a Lazy object
             # _autoref_resolve doesn't need any special handling
-            elif isdo(tree) or is_decorator(tree.func, "namelambda") or \
-               any(isx(tree.func, s) for s in _ctorcalls_all) or isx(tree.func, isLazy) or \
-               any(isx(tree.func, s) for s in ("_autoref_resolve", "AutorefMarker")):
+            elif (isdo(tree) or is_decorator(tree.func, "namelambda") or
+                  any(isx(tree.func, s) for s in _ctorcalls_all) or isx(tree.func, isLazy) or
+                  any(isx(tree.func, s) for s in ("_autoref_resolve", "AutorefMarker"))):
                 # here we know the operator (.func) to be one of specific names;
                 # don't transform it to avoid confusing lazyrec[] (important if this
                 # is an inner call in the arglist of an outer, lazy call, since it
diff --git a/unpythonic/syntax/letdoutil.py b/unpythonic/syntax/letdoutil.py
@@ -18,8 +18,8 @@ def where(*bindings):
 # avoid circular dependency; can't import from .util, so implement a minimal isx() for what we need
 def _isx(tree, x):
     ismatch = x if callable(x) else lambda s: s == x
-    return (type(tree) is Name and ismatch(tree.id)) or \
-           (type(tree) is Captured and ismatch(tree.name))
+    return ((type(tree) is Name and ismatch(tree.id)) or
+            (type(tree) is Captured and ismatch(tree.name)))
 def _pred(x):
     rematch = re.match
     pat = re.compile(r"^{}\d*$".format(x))
@@ -46,8 +46,8 @@ def _canonize_bindings(elts, locref, allow_call_in_name_position=False):
     allow_call_in_name_position: used by let_syntax to allow template definitions.
     """
     def iskey(x):
-        return type(x) is Name or \
-               allow_call_in_name_position and type(x) is Call and type(x.func) is Name
+        return ((type(x) is Name) or
+                (allow_call_in_name_position and type(x) is Call and type(x.func) is Name))
     if len(elts) == 2 and iskey(elts[0]):
         return [Tuple(elts=elts, lineno=locref.lineno, col_offset=locref.col_offset)]
     if all((type(b) is Tuple and len(b.elts) == 2 and iskey(b.elts[0])) for b in elts):
@@ -150,9 +150,15 @@ def _ishaskellylet(tree):
     To detect the full expression including the ``let[]``, use ``islet`` instead.
     """
     # let[((k0, v0), ...) in body]
-    if type(tree) is Compare and \
-       len(tree.ops) == 1 and type(tree.ops[0]) is In and \
-       type(tree.left) is Tuple:
+    def maybeiscontentofletin(tree):
+        return (type(tree) is Compare and
+                len(tree.ops) == 1 and type(tree.ops[0]) is In and
+                type(tree.left) is Tuple)
+    # let[body, where((k0, v0), ...)]
+    def maybeiscontentofletwhere(tree):
+        return type(tree) is Tuple and len(tree.elts) == 2 and type(tree.elts[1]) is Call
+
+    if maybeiscontentofletin(tree):
         bindings = tree.left
         if all((type(b) is Tuple and len(b.elts) == 2 and type(b.elts[0]) is Name)
                    for b in bindings.elts):
@@ -163,8 +169,7 @@ def _ishaskellylet(tree):
         #  require it, because they look like function calls in the AST.)
         if len(bindings.elts) == 2 and type(bindings.elts[0]) is Name:
             return "in_expr"
-    # let[body, where((k0, v0), ...)]
-    elif type(tree) is Tuple and len(tree.elts) == 2 and type(tree.elts[1]) is Call:
+    elif maybeiscontentofletwhere(tree):
         thecall = tree.elts[1]
         if type(thecall.func) is Name and thecall.func.id == "where":
             return "where_expr"
@@ -197,9 +202,9 @@ def isdo(tree, expanded=True):
             return False
         return kind
     # TODO: detect also do[] with a single expression inside? (now requires a comma)
-    return type(tree) is Subscript and \
-           type(tree.value) is Name and any(tree.value.id == x for x in ("do", "do0")) and \
-           type(tree.slice) is Index and type(tree.slice.value) is Tuple
+    return (type(tree) is Subscript and
+            type(tree.value) is Name and any(tree.value.id == x for x in ("do", "do0")) and
+            type(tree.slice) is Index and type(tree.slice.value) is Tuple)
 
 def isenvassign(tree):
     """Detect whether tree is an unpythonic ``env`` assignment, ``name << value``.
diff --git a/unpythonic/syntax/tailtools.py b/unpythonic/syntax/tailtools.py
@@ -255,8 +255,7 @@ def iscallcc(tree):
         if type(tree) not in (Assign, Expr):
             return False
         tree = tree.value
-        if type(tree) is Subscript and type(tree.value) is Name \
-           and tree.value.id == "call_cc":
+        if type(tree) is Subscript and type(tree.value) is Name and tree.value.id == "call_cc":
             if type(tree.slice) is Index:
                 return True
             assert False, "expected single expr, not slice in call_cc[...]"
diff --git a/unpythonic/syntax/util.py b/unpythonic/syntax/util.py
@@ -40,9 +40,9 @@ def isx(tree, x, accept_attr=True):
     # and bare names for anything hq[]'d; but any references that appear
     # explicitly in the user code may use either bare names or somemodule.f.
     ismatch = x if callable(x) else lambda s: s == x
-    return (type(tree) is Name and ismatch(tree.id)) or \
-           (type(tree) is Captured and ismatch(tree.name)) or \
-           (accept_attr and type(tree) is Attribute and ismatch(tree.attr))
+    return ((type(tree) is Name and ismatch(tree.id)) or
+            (type(tree) is Captured and ismatch(tree.name)) or
+            (accept_attr and type(tree) is Attribute and ismatch(tree.attr)))
 
 def make_isxpred(x):
     """Make a predicate for isx.
@@ -160,8 +160,8 @@ def is_decorator(tree, fname):
 
         - ``Call`` whose ``.func`` matches the above rule (parametric decorator).
     """
-    return isx(tree, fname) or \
-           (type(tree) is Call and isx(tree.func, fname))
+    return ((isx(tree, fname)) or
+            (type(tree) is Call and isx(tree.func, fname)))
 
 def is_lambda_decorator(tree, fname=None):
     """Test tree whether it decorates a lambda with ``fname``.
@@ -180,8 +180,8 @@ def is_lambda_decorator(tree, fname=None):
         trampolined(arg)                    # --> non-parametric decorator
         looped_over(range(10), acc=0)(arg)  # --> parametric decorator
     """
-    return (type(tree) is Call and len(tree.args) == 1) and \
-           (fname is None or is_decorator(tree.func, fname))
+    return ((type(tree) is Call and len(tree.args) == 1) and
+            (fname is None or is_decorator(tree.func, fname)))
 
 def is_decorated_lambda(tree, mode):
     """Detect a tree of the form f(g(h(lambda ...: ...)))
diff --git a/unpythonic/test/test_ec.py b/unpythonic/test/test_ec.py
@@ -60,8 +60,7 @@ def erroneous(ec):
 
 #    def catching_truth_table():
 #        def check(tags, catch_untagged, e):
-#            if (tags is None and e.allow_catchall) or \
-#               (catch_untagged and e.tag is None):
+#            if (tags is None and e.allow_catchall) or (catch_untagged and e.tag is None):
 #                return 2  # unconditional catch
 #            if (tags is not None and e.tag is not None): # and e.tag in tags):
 #                   return 1  # catch if tags match
diff --git a/unpythonic/test/test_fold.py b/unpythonic/test/test_fold.py
@@ -149,8 +149,8 @@ def op(acc, *elts):
     assert myprod(b) == 12
 
     packtwo = lambda a, b: ll(a, b)  # using a tuple return value here would confuse curry.
-    assert foldl(composerc(cons, packtwo), nil, (1, 2, 3), (4, 5), longest=True) == \
-           ll(ll(3, None), ll(2, 5), ll(1, 4))
+    assert (foldl(composerc(cons, packtwo), nil, (1, 2, 3), (4, 5), longest=True) ==
+            ll(ll(3, None), ll(2, 5), ll(1, 4)))
 
     @rotate(-1)
     def zipper(acc, *rest):   # so that we can use the *args syntax to declare this
