added is_sequable fn, support flatten

Author: ikappaki

src/basilisp/core.lpy

@@ -1487,7 +1487,7 @@
   "Return ``true`` if an :py:class:`basilisp.lang.interfaces.ISeq` can be produced from
   ``x``\\."
   [x]
-  (instance? basilisp.lang.interfaces/ISeqable x))
+  (basilisp.lang.interfaces/is_seqable x))
 
 (defn ^:inline sequential?
   "Return ``true`` if ``x`` implements :py:class:`basilisp.lang.interfaces.ISequential`\\."
@@ -3266,7 +3266,7 @@
   sequence."
   [v]
   (lazy-seq
-   (when (and (or (seq? v) (seqable? v)) (seq v))
+   (when-let [v (and (or (seq? v) (seqable? v)) (seq v))]
      (let [e (first v)
            r (rest v)]
        (if (or (seq? e) (seqable? e))

src/basilisp/lang/interfaces.py

@@ -14,6 +14,7 @@
     overload,
 )
 
+from types import GeneratorType
 from typing_extensions import Self, Unpack
 
 from basilisp.lang.obj import LispObject as _LispObject
@@ -759,3 +760,6 @@ class IType(ABC):
        :ref:`data_types_and_records`"""
 
     __slots__ = ()
+
+def is_seqable(x):
+    return isinstance(x, ISeqable) or isinstance(x, GeneratorType)

tests/basilisp/test_core_fns.lpy

@@ -2453,20 +2453,20 @@
             cat
             (iteration range-chunk :somef (partial some #(< % 7)) :kf (comp inc last) :initk 0))))))
 
-(def test-generator-vals [0 1 2 "three" nil 5])
+(def test-generator-vals [0 1 [2] "three" nil 5])
 
 (defn test-generator []
   (dotimes [i (count test-generator-vals)]
     (yield (nth test-generator-vals i))))
 
-(deftest python-iterators-seq-fns-test
+(deftest python-generators-seq-fns-test
   ;; The plan here is to consume with each function the test generator
   ;; in its entirety, and check for missing values.
 
   (testing "every?"
     (let [nums* (atom [])]
       (is (every? #(do (swap! nums* conj %)
-                       (or (number? %) (string? %) (nil? %)))
+                       (or (number? %) (string? %) (nil? %) (vector? %)))
                   (test-generator)))
       (is (= test-generator-vals @nums*))))
 
@@ -2479,16 +2479,16 @@
 
   (testing "map"
     (is (= test-generator-vals (map identity (test-generator))))
-    (is (= ["00" "11" "22" "threethree" "" "55"] (map str (test-generator) (test-generator)))))
+    (is (= ["00" "11" "[2][2]" "threethree" "" "55"] (map str (test-generator) (test-generator)))))
 
   (testing "filter"
-    (is (= [0 1 2 5] (filter #(and (number? %) (> % -1)) (test-generator)))))
+    (is (= [0 1 5] (filter #(and (number? %) (> % -1)) (test-generator)))))
 
   (testing "keep"
-    (is (= [0 1 2 "three" 5] (keep identity (test-generator)))))
+    (is (= [0 1 [2] "three" 5] (keep identity (test-generator)))))
 
   (testing "keep-indexed"
-    (is (= [[0 0] [1 1] [2 2] [3 "three"] [4 nil] [5 5]] (keep-indexed vector (test-generator)))))
+    (is (= [[0 0] [1 1] [2 [2]] [3 "three"] [4 nil] [5 5]] (keep-indexed vector (test-generator)))))
 
   (testing "take"
     (is (= test-generator-vals (take 6 (test-generator)))))
@@ -2500,43 +2500,42 @@
     (is (= test-generator-vals (drop 0 (test-generator)))))
 
   (testing "take-while"
-    (is (= [1 2 "three" nil 5] (drop-while #(not= % 1) (test-generator)))))
+    (is (= [1 [2] "three" nil 5] (drop-while #(not= % 1) (test-generator)))))
 
   (testing "interpose"
-    (is (= [0 "-" 1 "-" 2 "-" "three" "-" nil "-" 5] (interpose "-" (test-generator)))))
+    (is (= [0 "-" 1 "-" [2] "-" "three" "-" nil "-" 5] (interpose "-" (test-generator)))))
 
   (testing "interleave"
-    (is (= [0 0 1 1 2 2 "three" "three" nil nil 5 5] (interleave (test-generator) (test-generator)))))  
+    (is (= [0 0 1 1 [2] [2] "three" "three" nil nil 5 5] (interleave (test-generator) (test-generator)))))  
 
   (testing "cycle"
-    (is (= [0 1 2 "three" nil 5 0 1 2 "three"] (take 10 (cycle (test-generator))))))
+    (is (= [0 1 [2] "three" nil 5 0 1 [2] "three"] (take 10 (cycle (test-generator))))))
 
   (testing "take-nth"
-    (is (= [0 2 nil] (take-nth 2 (test-generator)))))
+    (is (= [0 [2] nil] (take-nth 2 (test-generator)))))
 
   (testing "partition"
-    (is (= [[0 1] [2 "three"] [nil 5]] (partition 2 (test-generator))))
-    (is (= [[0 1] [1 2] [2 "three"] ["three" nil] [nil 5]] (partition 2 1 (test-generator))))
-    (is (= [[0 1 2 "three"] [nil 5 :pad :pad]] (partition 4 4 (repeat :pad) (test-generator)))))
+    (is (= [[0 1] [[2] "three"] [nil 5]] (partition 2 (test-generator))))
+    (is (= [[0 1] [1 [2]] [[2] "three"] ["three" nil] [nil 5]] (partition 2 1 (test-generator))))
+    (is (= [[0 1 [2] "three"] [nil 5 :pad :pad]] (partition 4 4 (repeat :pad) (test-generator)))))
 
   (testing "partition-all"
-    (is (= [[0 1 2 "three"] [nil 5]] (partition-all 4 (test-generator))))
-    (is (= [[0 1 2 "three"] [nil 5]] (partition-all 4 4 (test-generator)))))  
+    (is (= [[0 1 [2] "three"] [nil 5]] (partition-all 4 (test-generator))))
+    (is (= [[0 1 [2] "three"] [nil 5]] (partition-all 4 4 (test-generator)))))  
 
   (testing "distinct"
     (is (= test-generator-vals (dedupe (test-generator)))))  
 
-  ;; TODO
-  ;; (testing "flatten"
-  ;;   (is (= nil (flatten [[:a :b :c] (test-generator)]))))
-
+  (testing "flatten"
+    (is (= [:a :b :c 0 1 2 "three" nil 5] (flatten [[:a :b :c] (test-generator)]))))
 
   (testing "take-last"
-    (is (= [2 "three" nil 5] (take-last 4 (test-generator)))))  
+    (is (= [[2] "three" nil 5] (take-last 4 (test-generator)))))
 
-  (testing "sort-by"
-    (is (= [5 nil "three" 2 1 0] (reverse (test-generator)))))
+  (testing "reverse"
+    (is (= [5 nil "three" [2] 1 0] (reverse (test-generator)))))
 
+  ;; others: sort-by, for, last ...
   )
 
 ;;;;;;;;;;