Fix flake8 warnings in regular code

Technologicat · Technologicat · commit 3f25771d76bd · 2020-08-08T01:38:45.000+03:00
See issue #27.
diff --git a/unpythonic/amb.py b/unpythonic/amb.py
@@ -113,7 +113,7 @@ def forall(*lines):
     # Notation used by the monad implementation for the bind and sequence
     # operators, with any relevant whitespace.
     bind = " >> "
-    seq  = ".then"
+    seq = ".then"
 
     class env:
         def __init__(self):
@@ -142,7 +142,7 @@ def begin(*exprs):  # args eagerly evaluated by Python
     begin_is_open = False
     for j, item in enumerate(lines):
         is_first = (j == 0)
-        is_last  = (j == len(lines) - 1)
+        is_last = (j == len(lines) - 1)
 
         if isinstance(item, Assignment):
             name, body = item
@@ -251,7 +251,7 @@ def __len__(self):
     def __getitem__(self, i):
         return self.x[i]
 
-    def __add__(self, other): # concatenation of Lists, for convenience
+    def __add__(self, other):  # concatenation of Lists, for convenience
         cls = self.__class__
         return cls.from_iterable(self.x + other.x)
 
@@ -263,7 +263,7 @@ def __str__(self):
     def from_iterable(cls, iterable):  # convenience
         try:
             return cls(*iterable)
-        except TypeError: # maybe a generator; try forcing it before giving up.
+        except TypeError:  # maybe a generator; try forcing it before giving up.
             return cls(*tuple(iterable))
 
     def copy(self):
diff --git a/unpythonic/collections.py b/unpythonic/collections.py
@@ -555,8 +555,8 @@ def __eq__(self, other):
             return True
         if len(self) != len(other):
             return False
-        for v, w in zip(self, other):
-            if v != w:
+        for v, wrap in zip(self, other):
+            if v != wrap:
                 return False
         return True
 
@@ -647,8 +647,8 @@ def __getitem__(self, k):
             raise TypeError("multidimensional subscripting not supported; got '{}'".format(k))
         else:
             data, r = self._update_cache()
-            l = len(r)
-            if k >= l or k < -l:
+            n = len(r)
+            if k >= n or k < -n:
                 raise IndexError("view index out of range")
             return data[r[k]]
 
@@ -712,8 +712,8 @@ def __setitem__(self, k, v):
         elif isinstance(k, tuple):
             raise TypeError("multidimensional subscripting not supported; got '{}'".format(k))
         else:
-            l = len(r)
-            if k >= l or k < -l:
+            n = len(r)
+            if k >= n or k < -n:
                 raise IndexError("view assigment index out of range")
             data[r[k]] = v
     def reverse(self):
@@ -749,10 +749,10 @@ def __init__(self, seq, ix=None, v=None):
     def __iter__(self):
         if self.ix is None:  # allow no-op ShadowedSequences since the repr suggests one could do that
             return iter(self.seq)
-        l = len(self)
+        n = len(self)
         getone = self._getone
         def ShadowedSequenceIterator():
-            for j in range(l):
+            for j in range(n):
                 yield getone(j)
         return ShadowedSequenceIterator()
 
@@ -762,31 +762,32 @@ def __len__(self):
     def __getitem__(self, k):
         if self.ix is None:  # allow no-op ShadowedSequences since the repr suggests one could do that
             return self.seq[k]
-        l = len(self)
+        n = len(self)
         if isinstance(k, slice):
             cls = type(self.seq)
             ctor = tuple if hasattr(cls, "_make") else cls  # slice of namedtuple -> tuple
-            return ctor(self._getone(j) for j in range(l)[k])
+            return ctor(self._getone(j) for j in range(n)[k])
         elif isinstance(k, tuple):
             raise TypeError("multidimensional subscripting not supported; got '{}'".format(k))
         else:
-            if k >= l or k < -l:
+            if k >= n or k < -n:
                 raise IndexError("ShadowedSequence index out of range")
             return self._getone(k)
 
     def _getone(self, k):
         ix = self.ix
-        l = len(self)
-        if in_slice(k, ix, l):
+        n = len(self)
+        if in_slice(k, ix, n):
             if isinstance(ix, int):
                 return self.v  # just one item
             # we already know k is in ix, so skip validation for speed.
-            i = _index_in_slice(k, ix, l, _validate=False)
+            i = _index_in_slice(k, ix, n, _validate=False)
             if i >= len(self.v):
                 raise IndexError("Replacement sequence too short; attempted to access index {} with len {} (items: {})".format(i, len(self.v), self.v))
             return self.v[i]
         return self.seq[k]  # not in slice
 
+# TODO: fix flake8 E741 ambiguous variable name "l". Here it's part of the public API, so we'll have to wait until 15.0 to change the name.
 def in_slice(i, s, l=None):
     """Return whether the int i is in the slice s.
 
@@ -816,6 +817,7 @@ def in_slice(i, s, l=None):
     on_grid = (i - start) % step == 0
     return at_or_after_start and on_grid and before_stop
 
+# TODO: fix flake8 E741 ambiguous variable name "l". Here it's part of the public API, so we'll have to wait until 15.0 to change the name.
 def index_in_slice(i, s, l=None):
     """Return the index of the int i in the slice s, or None if i is not in s.
 
@@ -827,60 +829,60 @@ def index_in_slice(i, s, l=None):
 
 # efficiency: allow skipping the validation check for call sites
 # that have already checked with in_slice().
-def _index_in_slice(i, s, l=None, _validate=True):
-    if (not _validate) or in_slice(i, s, l):
-        wrap = _make_negidx_converter(l)
-        start, _, step = _canonize_slice(s, l, wrap)
+def _index_in_slice(i, s, n=None, _validate=True):  # n: length of sequence being indexed
+    if (not _validate) or in_slice(i, s, n):
+        wrap = _make_negidx_converter(n)
+        start, _, step = _canonize_slice(s, n, wrap)
         return (wrap(i) - start) // step
 
-def _make_negidx_converter(l):  # l: length of sequence being indexed
-    if l is not None:
-        if not isinstance(l, int):
-            raise TypeError("l must be int, got {} with value {}".format(type(l), l))
-        if l <= 0:
-            raise ValueError("l must be an int >= 1, got {}".format(l))
+def _make_negidx_converter(n):  # n: length of sequence being indexed
+    if n is not None:
+        if not isinstance(n, int):
+            raise TypeError("n must be int, got {} with value {}".format(type(n), n))
+        if n <= 0:
+            raise ValueError("n must be an int >= 1, got {}".format(n))
         def apply_conversion(k):
-            return k % l
+            return k % n
     else:
         def apply_conversion(k):
-            raise ValueError("Need l to interpret negative indices")
+            raise ValueError("Need n to interpret negative indices")
     def convert(k):
         if k is not None:
             if not isinstance(k, int):
                 raise TypeError("k must be int, got {} with value {}".format(type(k), k))
-            # Almost standard semantics for negative indices. Usually -l < k < l,
+            # Almost standard semantics for negative indices. Usually -n < k < n,
             # but here we must allow for conversion of the end position, for
             # which the last valid value is one past the end.
-            if not -l <= k <= l:
-                raise IndexError("Should have -n <= k <= n, but n = len(args) = {}, and k = {}".format(l, k))
+            if not -n <= k <= n:
+                raise IndexError("Should have -n <= k <= n, but n = len(args) = {}, and k = {}".format(n, k))
             return apply_conversion(k) if k < 0 else k
     return convert
 
-def _canonize_slice(s, l=None, w=None):  # convert negatives, inject defaults.
+def _canonize_slice(s, n=None, wrap=None):  # convert negatives, inject defaults.
     if not isinstance(s, slice):
         raise TypeError("s must be slice, got {} with value {}".format(type(s), s))
 
     step = s.step if s.step is not None else +1  # no "s.step or +1"; someone may try step=0
     if step == 0:
         raise ValueError("slice step cannot be zero")  # message copied from range(5)[0:4:0]
 
-    wrap = w or _make_negidx_converter(l)
+    wrap = wrap or _make_negidx_converter(n)
 
     start = wrap(s.start)
     if start is None:
         if step > 0:
             start = 0
         else:
-            if l is None:
-                raise ValueError("Need l to determine default start for step < 0")
+            if n is None:
+                raise ValueError("Need n to determine default start for step < 0")
             start = wrap(-1)
 
     stop = wrap(s.stop)
     if stop is None:
         if step > 0:
-            if l is None:
-                raise ValueError("Need l to determine default stop for step > 0")
-            stop = l
+            if n is None:
+                raise ValueError("Need n to determine default stop for step > 0")
+            stop = n
         else:
             stop = -1  # yes, really -1 to have index 0 inside the slice
 
diff --git a/unpythonic/env.py b/unpythonic/env.py
@@ -167,7 +167,7 @@ def __exit__(self, exctype, excvalue, traceback):
 
     # pretty-printing
     def __repr__(self):
-        bindings = ["{:s}={}".format(name,repr(value)) for name,value in self._env.items()]
+        bindings = ["{:s}={}".format(name, repr(value)) for name, value in self._env.items()]
         return "<env object at 0x{:x}: {{{:s}}}>".format(id(self), ", ".join(bindings))
 
     # other
diff --git a/unpythonic/fold.py b/unpythonic/fold.py
@@ -320,35 +320,36 @@ def fibo(a, b):
         value, *states = result
         yield value
 
-## This is **not** how to make a right map; the result is exactly the same
-## as for the ordinary (left) map and zip, but unnecessarily using a
-## recursive process for something that can be done using a linear one.
-## For documentation only. For working mapr, zipr, see unpythonic.it.
-## The trick is in the order in which the recurser yields its results.
-#def testme():
-#    squaretwo = lambda a, b: (a**2, b**2)
-#    print(tuple(mapr(squaretwo, (1, 2, 3), (4, 5))))
-#    print(tuple(map(squaretwo, (1, 2, 3), (4, 5))))
+# This is **not** how to make a right map; the result is exactly the same
+# as for the ordinary (left) map and zip, but unnecessarily using a
+# recursive process for something that can be done using a linear one.
+# For documentation only. For working mapr, zipr, see unpythonic.it.
+# The trick is in the order in which the recurser yields its results.
 #
-#def mapr(proc, *iterables):
-#    """Like map, but starting from the right. Recursive process.
+# def testme():
+#     squaretwo = lambda a, b: (a**2, b**2)
+#     print(tuple(mapr(squaretwo, (1, 2, 3), (4, 5))))
+#     print(tuple(map(squaretwo, (1, 2, 3), (4, 5))))
 #
-#    See ``rmap`` for the linear process that works by reversing each input.
-#    """
-#    def scanproc(*args):
-#        *elts, _ = args  # discard acc
-#        return proc(*elts)
-#    # discard the init value with butlast
-#    return butlast(scanr(scanproc, None, *iterables))
+# def mapr(proc, *iterables):
+#     """Like map, but starting from the right. Recursive process.
 #
-#def zipr(*iterables):
-#    """Like zip, but starting from the right. Recursive process.
+#     See ``rmap`` for the linear process that works by reversing each input.
+#     """
+#     def scanproc(*args):
+#         *elts, _ = args  # discard acc
+#         return proc(*elts)
+#     # discard the init value with butlast
+#     return butlast(scanr(scanproc, None, *iterables))
 #
-#    See ``rzip`` for the linear process that works by reversing each input.
-#    """
-#    def identity(*args):  # unpythonic.fun.identity, but dependency loop
-#        return args
-#    return mapr(identity, *iterables)
+# def zipr(*iterables):
+#     """Like zip, but starting from the right. Recursive process.
+#
+#     See ``rzip`` for the linear process that works by reversing each input.
+#     """
+#     def identity(*args):  # unpythonic.fun.identity, but dependency loop
+#         return args
+#     return mapr(identity, *iterables)
 
 def prod(iterable, start=1):
     """Like the builtin sum, but compute the product.
diff --git a/unpythonic/mathseq.py b/unpythonic/mathseq.py
diff --git a/unpythonic/seq.py b/unpythonic/seq.py
