Add iterate, partition to core; prevent apply from swallowing exceptions (#296)

Author: chrisrink10

src/basilisp/core/__init__.lpy

@@ -762,18 +762,27 @@
   (list 'basilisp.lang.seq/LazySeq
         (concat '(fn* []) body)))
 
+(defn iterate
+  "Returns a lazy sequence of (f x), (f (f x)) and so on."
+  [f x]
+  (lazy-seq
+   (let [v (f x)]
+     (when v
+       (cons v (iterate f v))))))
+
 (defn range
   "Return a range of integers from start. If end is specified, the
   sequence will terminate at end."
-  ([] (range 0))
-  ([start]
-   (lazy-seq (cons start (range (inc start)))))
+  ([]
+   (iterate inc -1))
+  ([end]
+   (lazy-seq (cons 0 (range 1 end))))
   ([start end]
-   (lazy-seq (cons start (when (< start end)
+   (lazy-seq (cons start (when (< start (dec end))
                            (range (inc start) end)))))
   ([start end step]
    (lazy-seq (let [next-int (+ start step)]
-               (cons start (when (< next-int end)
+               (cons start (when (< next-int (dec end))
                              (range next-int end step)))))))
 
 (defn complement
@@ -1013,6 +1022,28 @@
     (when (> n 0)
       (cons (f) (repeatedly (dec n) f))))))
 
+(defn partition
+  "Return a lazy sequence of partitions of coll of size n at offsets
+  of step elements. If step is not given, steps of size n will be used
+  and there will be no overlap between partitions. If pad is given,
+  partition will pull elements from pad until the final sequence is
+  equal to size n."
+  ([n coll]
+   (partition n n coll))
+  ([n step coll]
+   (lazy-seq
+    (when (seq coll)
+      (cons (take n coll) (partition n step (drop step coll))))))
+  ([n step pad coll]
+   (lazy-seq
+    (when (seq coll)
+      (let [s  (take n coll)
+            ns (count s)
+            s  (if (< ns n)
+                 (concat s (take (- n ns) pad))
+                 s)]
+        (cons s (partition n step pad (drop step coll))))))))
+
 (defn merge
   "Merge maps together from left to right as by conj. If a duplicate key
   appears in a map, the rightmost map's value for that key will be taken."

src/basilisp/lang/runtime.py

@@ -558,10 +558,16 @@ def apply(f, args):
         (apply max [1 2 3])   ;=> 3
         (apply max 4 [1 2 3]) ;=> 4"""
     final = list(args[:-1])
+
     try:
-        final.extend(to_seq(args[-1]))
-    except TypeError:
-        pass
+        last = args[-1]
+    except TypeError as e:
+        logger.debug("Ignored %s: %s", type(e).__name__, e)
+
+    s = to_seq(last)
+    if s is not None:
+        final.extend(s)
+
     return f(*final)
 
 
@@ -581,8 +587,8 @@ def nth(coll, i, notfound=__nth_sentinel):
         if notfound is not __nth_sentinel:
             return notfound
         raise ex
-    except TypeError:
-        pass
+    except TypeError as ex:
+        logger.debug("Ignored %s: %s", type(ex).__name__, ex)
 
     try:
         for j, e in enumerate(coll):
@@ -685,7 +691,8 @@ def get(m, k, default=None):
 
     try:
         return m[k]
-    except (KeyError, IndexError):
+    except (KeyError, IndexError, TypeError) as e:
+        logger.debug("Ignored %s: %s", type(e).__name__, e)
         return default
 
 

tests/basilisp/core_test.py

@@ -479,6 +479,7 @@ def test_dissoc():
 
 
 def test_get():
+    assert None is core.get(None, "a")
     assert 1 == core.get(lmap.map({"a": 1}), "a")
     assert None is core.get(lmap.map({"a": 1}), "b")
     assert 2 == core.get(lmap.map({"a": 1}), "b", 2)
@@ -507,8 +508,8 @@ def test_vals():
 
 def test_range():
     assert llist.l(1) == core.range_(1, 1)
-    assert llist.l(1, 2, 3, 4, 5) == core.range_(1, 5)
-    assert llist.l(1, 3, 5, 7, 9) == core.range_(1, 10, 2)
+    assert llist.l(1, 2, 3, 4, 5) == core.range_(1, 6)
+    assert llist.l(1, 3, 5, 7, 9) == core.range_(1, 11, 2)
     # assert llist.l(1, -1, -3, -5, -7, -9) == core.range_(1, -10, -2)
 
 
@@ -631,7 +632,7 @@ def test_map():
     assert llist.l(2, 3, 4) == core.map_(core.inc, vec.v(1, 2, 3))
 
     assert llist.l(5, 7, 9) == core.map_(core.__PLUS__, vec.v(1, 2, 3), vec.v(4, 5, 6))
-    assert llist.l(5, 7, 9) == core.map_(core.__PLUS__, vec.v(1, 2, 3), core.range_(4))
+    assert llist.l(5, 7, 9) == core.map_(core.__PLUS__, vec.v(1, 2, 3), core.range_(4, 7))
 
 
 def test_map_indexed():
@@ -742,6 +743,23 @@ def test_repeatedly():
     assert llist.l("yes", "yes", "yes") == core.repeatedly(3, lambda: "yes")
 
 
+def test_partition():
+    assert llist.l(llist.l(1, 2), llist.l(3, 4), llist.l(5, 6)) == core.partition(2, core.range_(1, 7))
+    assert llist.l(llist.l(1, 2, 3), llist.l(4, 5, 6)) == core.partition(3, core.range_(1, 7))
+
+    assert llist.l(llist.l(1, 2, 3, 4, 5), llist.l(11, 12, 13, 14, 15),
+                   llist.l(21, 22, 23)) == core.partition(5, 10, core.range_(1, 24))
+    assert llist.l(llist.l(1, 2, 3, 4, 5), llist.l(11, 12, 13, 14, 15),
+                   llist.l(21, 22, 23, 24, 25)) == core.partition(5, 10, core.range_(1, 26))
+
+    assert llist.l(llist.l(1, 2, 3, 4, 5), llist.l(11, 12, 13, 14, 15),
+                   llist.l(21, 22, 23, kw.keyword("a"), kw.keyword("a"))) == core.partition(
+        5, 10, core.repeat(kw.keyword("a")), core.range_(1, 24))
+    assert llist.l(llist.l(1, 2, 3, 4, 5), llist.l(11, 12, 13, 14, 15),
+                   llist.l(21, 22, 23, 24, 25)) == core.partition(
+        5, 10, core.repeat(kw.keyword("a")), core.range_(1, 26))
+
+
 def test_pr_str():
     assert '' == core.pr_str()
     assert '""' == core.pr_str("")