Fix keep and keep-indexed two-arity forms (#962) (#964)

Fix for #962

Author: mitch-kyle

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
  * Fixed an issue where attempting to run a namespace from the CLI could fail in certain cases (#957)
+ * Fixed an issue with `keep` and `keep-indexed` two-arity forms not preserving the transformed values (#962)
 
 ## [v0.1.0]
 ### Added

src/basilisp/core.lpy

@@ -2861,10 +2861,10 @@
   ([f coll]
    (lazy-seq
     (when (seq coll)
-      (let [elem (first coll)]
-        (if-not (nil? (f elem))
-          (cons elem (keep f (rest coll)))
-          (keep f (rest coll))))))))
+      (let [elem (f (first coll))]
+        (if (nil? elem)
+          (keep f (rest coll))
+          (cons elem (keep f (rest coll)))))))))
 
 (defn keep-indexed
   "Return a lazy-sequence of non- ``nil`` results of ``(f index elem)`` for elements
@@ -2887,11 +2887,10 @@
                     [rng coll]
                     (lazy-seq
                      (when (seq coll)
-                       (let [idx  (first rng)
-                             elem (first coll)]
-                         (if-not (nil? (f idx elem))
-                           (cons elem (keep-idx (rest rng) (rest coll)))
-                           (keep-idx (rest rng) (rest coll)))))))]
+                       (let [elem (f (first rng) (first coll))]
+                         (if (nil? elem)
+                           (keep-idx (rest rng) (rest coll))
+                           (cons elem (keep-idx (rest rng) (rest coll))))))))]
      (keep-idx (range) coll))))
 
 (defn take

tests/basilisp/test_core_fns.lpy

@@ -899,40 +899,54 @@
       '(2 4 6) odd?     [1 2 3 4 5 6])))
 
 (deftest keep-test
-  (testing "transducer"
-    (are [res input] (= res (into [] (keep identity) input))
-      []            []
-      [:a :b :c]    [:a :b :c]
-      [:a :b :c]    [:a :b nil :c]
-      [:a :b :c]    [:a :b nil nil :c]
-      [:a :b :c :d] [:a :b nil :c nil nil :d]))
-
-  (testing "higher order function"
-    (are [res input] (= res (keep identity input))
-      '()            []
-      '(:a :b :c)    [:a :b :c]
-      '(:a :b :c)    [:a :b nil :c]
-      '(:a :b :c)    [:a :b nil nil :c]
-      '(:a :b :c :d) [:a :b nil :c nil nil :d])))
+  (let [transform (fn [x] (when x (-> x name symbol)))]
+    (testing "transducer"
+      (are [res input] (= res (into [] (keep transform) input))
+        '[]        []
+        '[a b c]   [:a :b :c]
+        '[a b c]   [:a :b nil :c]
+        '[a b c]   [:a :b nil nil :c]
+        '[a b c d] [:a :b nil :c nil nil :d]))
+
+    (testing "higher order function"
+      (are [res input] (= res (keep transform input))
+        '()        []
+        '(a b c)   [:a :b :c]
+        '(a b c)   [:a :b nil :c]
+        '(a b c)   [:a :b nil nil :c]
+        '(a b c d) [:a :b nil :c nil nil :d]))
+
+    (testing "lazy"
+      (let [counter (atom 0)
+            vals    (keep (partial swap! counter +) (repeat 1 10))]
+        (is (= 0 @counter))
+        (seq vals)
+        (is (= 10 @counter))))))
 
 (deftest keep-indexed-test
-  (testing "transducer"
-    (let [f (fn [i v] v)]
+  (let [f (fn [i x] (when x [i (-> x name symbol)]))]
+    (testing "transducer"
       (are [res input] (= res (into [] (keep-indexed f) input))
-        []            []
-        [:a :b :c]    [:a :b :c]
-        [:a :b :c]    [:a :b nil :c]
-        [:a :b :c]    [:a :b nil nil :c]
-        [:a :b :c :d] [:a :b nil :c nil nil :d])))
+        '[]                        []
+        '[[0 a] [1 b] [2 c]]       [:a :b :c]
+        '[[0 a] [1 b] [3 c]]       [:a :b nil :c]
+        '[[0 a] [1 b] [4 c]]       [:a :b nil nil :c]
+        '[[0 a] [1 b] [3 c] [6 d]] [:a :b nil :c nil nil :d]))
 
-  (testing "higher order function"
-    (let [f (fn [i v] v)]
+    (testing "higher order function"
       (are [res input] (= res (keep-indexed f input))
-        '()            []
-        '(:a :b :c)    [:a :b :c]
-        '(:a :b :c)    [:a :b nil :c]
-        '(:a :b :c)    [:a :b nil nil :c]
-        '(:a :b :c :d) [:a :b nil :c nil nil :d]))))
+        '()                        []
+        '([0 a] [1 b] [2 c])       [:a :b :c]
+        '([0 a] [1 b] [3 c])       [:a :b nil :c]
+        '([0 a] [1 b] [4 c])       [:a :b nil nil :c]
+        '([0 a] [1 b] [3 c] [6 d]) [:a :b nil :c nil nil :d]))
+
+    (testing "lazy"
+      (let [counter (atom 0)
+            vals    (keep-indexed (fn [i x] (swap! counter + x)) (repeat 1 10))]
+        (is (= 0 @counter))
+        (seq vals)
+        (is (= 10 @counter))))))
 
 (deftest take-test
   (testing "transducer"