ordering of special/general cases in ifs with return and omitted else

Technologicat · Technologicat · commit 3e7157b7d0a3 · 2018-09-23T10:05:36.000+03:00
diff --git a/unpythonic/env.py b/unpythonic/env.py
@@ -78,10 +78,9 @@ def __getattr__(self, name):
         if not name.isidentifier():
             raise ValueError("'{}' is not a valid identifier".format(name))
         e = self._env   # __getattr__ not called if direct attr lookup succeeds, no need for hook.
-        if name in e:
-            return e[name]
-        else:
+        if name not in e:
             raise AttributeError("name '{:s}' is not defined".format(name))
+        return e[name]
 
     # membership test (in, not in)
     def __contains__(self, k):
diff --git a/unpythonic/fploop.py b/unpythonic/fploop.py
@@ -422,20 +422,20 @@ def _(loop, i=0):
     # same without using side effects - use an accumulator parameter:
     @looped
     def out(loop, i=0, acc=[]):
-        if i < 3:
-            acc.append(i)
-            return loop(i + 1)
-        return acc
+        if i >= 3:
+            return acc
+        acc.append(i)
+        return loop(i + 1)
     assert out == [0, 1, 2]
 
     # there's no "continue"; package your own:
     @looped
     def s(loop, acc=0, i=0):
         cont = lambda newacc=acc: loop(newacc, i + 1)
-        if i <= 4:
-            return cont()
-        elif i == 10:
+        if i == 10:
             return acc
+        elif i <= 4:
+            return cont()
         return cont(acc + i)
     assert s == 35
 
@@ -493,9 +493,9 @@ def filter_fp(predicate, iterable):
         predicate = predicate or (lambda x: x)  # None -> truth value test
         @looped_over(iterable, acc=())
         def out(loop, x, acc):
-            if predicate(x):
-                return loop(acc + (x,))
-            return loop(acc)
+            if not predicate(x):
+                return loop(acc)
+            return loop(acc + (x,))
         return out
     assert filter_fp(lambda x: x % 2 == 0, range(10)) == (0, 2, 4, 6, 8)
 
@@ -629,9 +629,9 @@ def result():
         @looped
         def s(loop, acc=0, i=0):
             cont = lambda newacc=acc: loop(newacc, i + 1)
-            if i < 10:
-                return cont(acc + i)
-            return acc
+            if i >= 10:
+                return acc
+            return cont(acc + i)
         print("s is {:d}".format(s))
         return 2 * s
     assert result == 90
diff --git a/unpythonic/it.py b/unpythonic/it.py
@@ -441,9 +441,9 @@ def flatten(iterable, pred=None):
 
 def flatten1(iterable, pred=None):
     """Like flatten, but process outermost level only."""
-    if pred:
-        return _flatten(iterable, pred, recursive=False)
-    return chain.from_iterable(iterable)  # itertools recipes: fast, no pred
+    if not pred:
+        return chain.from_iterable(iterable)  # itertools recipes: fast, no pred
+    return _flatten(iterable, pred, recursive=False)
 
 def _flatten(iterable, pred=None, recursive=True):
     pred = pred or (lambda x: True)  # unpythonic.fun.const(True), but dependency loop
