A few more seq utility functions (#618)

Author: chrisrink10

src/basilisp/core.lpy

@@ -3047,6 +3047,15 @@
          (concat (flatten e) (flatten r))
          (cons e (flatten r)))))))
 
+(defn take-last
+  "Return the last n items in coll in linear time."
+  [n coll]
+  (loop [c   (seq coll)
+         rem (seq (drop n coll))]
+    (if rem
+      (recur (next c) (next rem))
+      c)))
+
 (defn min-key
   "Return the arg for which (k arg) is the smallest number.
   If multiple values return the same number, return the last."
@@ -3102,6 +3111,24 @@
       (recur (ret))
       ret)))
 
+(defn tree-seq
+  "Return a lazy seq on the nodes of the tree-like data structure `root`.
+
+  `branch?` should be a function of a single argument which should return
+  true if a node might contain children (though it need not).
+
+  `children` should be a function of one argument which should return a
+  sequence of children of a node. `children` will only be called on a node
+  if `branch?` returns true for that node."
+  [branch? children root]
+  (let [walk (fn walk
+               [node]
+               (lazy-seq
+                (cons node
+                      (when (branch? node)
+                        (mapcat walk (children node))))))]
+    (walk root)))
+
 (import* multiprocessing)
 
 (def ^:dynamic *pmap-cpu-count*
@@ -3745,6 +3772,20 @@
        (throw (python/IndexError "Start index must be less than or equal to end index"))))
    (operator/getitem s (python/slice start end))))
 
+;;;;;;;;;;;;;;;;;;;;
+;; File Functions ;;
+;;;;;;;;;;;;;;;;;;;;
+
+(import* pathlib)
+
+(defn file-seq
+  "Return a seq of `pathlib.Path` objects for all files and subdirectories of `dir`."
+  [dir]
+  (-> (pathlib/Path dir)
+      (.resolve)
+      (.rglob "*")
+      (seq)))
+
 ;;;;;;;;;;;;;;;;;;;;;;
 ;; Output Utilities ;;
 ;;;;;;;;;;;;;;;;;;;;;;

tests/basilisp/test_core_fns.lpy

@@ -934,6 +934,15 @@
     '(1) [[[1]]]
     '(1 2 3) [[[1]] 2 [3]]))
 
+(deftest take-last-test
+  (are [res n coll] (= res (take-last n coll))
+    [:c :d] 2  [:a :b :c :d]
+    [:a]    2  [:a]
+    nil     2  []
+    nil     2  nil
+    nil     0  [:a]
+    nil     -1 [:a]))
+
 (deftest min-key-test
   (is (= "dsd" (max-key count "asd" "bsd" "dsd")))
   (is (= "long word" (max-key count "asd" "bsd" "dsd" "long word")))
@@ -976,6 +985,11 @@
                 "idiot")
     (is (= [:a :b] @a))))
 
+(deftest tree-seq-test
+  (are [res branch? children root] (= res (tree-seq branch? children root))
+    '(((1 2 (3)) (4)) (1 2 (3)) 1 2 (3) 3 (4) 4)                             seq? identity '((1 2 (3)) (4))
+    '((:A (:B (:D) (:E)) (:C (:F))) (:B (:D) (:E)) (:D) (:E) (:C (:F)) (:F)) next rest     '(:A (:B (:D) (:E)) (:C (:F)))))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Associative Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;