Additional core functions and macros (#293)

* Additional core functions and macros

* Docstring

Author: chrisrink10

src/basilisp/core/__init__.lpy

@@ -241,9 +241,12 @@
 
 (defn nth
   "Returns the ith element of coll (0-indexed), if it exists.
-  nil otherwise."
-  [coll i]
-  (basilisp.lang.runtime/nth coll i))
+  nil otherwise. If i is out of bounds, throws an IndexError unless
+  notfound is specified."
+  ([coll i]
+   (basilisp.lang.runtime/nth coll i))
+  ([coll i notfound]
+   (basilisp.lang.runtime/nth coll i notfound)))
 
 (defn nthnext
   "Returns the nth next sequence of coll.
@@ -415,6 +418,39 @@
                       {:first (first clauses)})))
           (cons 'basilisp.core/cond (nthrest clauses 2)))))
 
+(defmacro condp
+  "Take a predicate and an expression and a series of clauses, call
+  (pred test expr) on the first expression for each clause. The result
+  expression from first the set of clauses for which this expression
+  returns a truthy value will be returned from the condp expression.
+
+  Clauses can take two forms:
+
+  - test-expr result-expr
+  - test-expr :>> result-fn, where :>> is a keyword literal
+
+  For the ternary expression clause, the unary result-fn will be called
+  with the result of the predicate."
+  [pred expr & clauses]
+  (when (seq clauses)
+    (let [test-expr (first clauses)
+          remaining (rest clauses)]
+      (if (seq remaining)
+        (let [result    (first remaining)
+              remaining (rest remaining)]
+          (cond
+            (= result :>>) `(let [res# ~(list pred test-expr expr)]
+                              (if res#
+                                (~(first remaining) res#)
+                                (condp ~pred ~expr ~@(rest remaining))))
+            result         `(if ~(list pred test-expr expr)
+                              ~result
+                              (condp ~pred ~expr ~@remaining))
+            :else          (throw
+                            (ex-info "expected result expression"
+                                     {:test test-expr}))))
+        test-expr))))
+
 (defn not
   "Return the logical negation of expr."
   [expr]
@@ -704,6 +740,16 @@
   [entry]
   (.-value entry))
 
+(defn keys
+  "Return a seq of the keys from a map."
+  [m]
+  (seq (.keys m)))
+
+(defn vals
+  "Return a seq of the values from a map."
+  [m]
+  (seq (.values m)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Higher Order Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -842,6 +888,18 @@
       (cons (apply f (first coll) (map first colls))
             (apply map f (rest coll) (map rest colls)))))))
 
+(defn map-indexed
+  "Return a lazy sequence of (f idx elem) for elements in coll. The
+  index starts at 0."
+  [f coll]
+  (map f (range) coll))
+
+(defn mapcat
+  "Return a lazy sequence of the concatenated results of mapping f over
+  colls."
+  [f & colls]
+  (apply concat (apply map f colls)))
+
 (defn filter
   "Return elements from coll where (pred elem) returns true."
   [pred coll]
@@ -973,6 +1031,11 @@
   [o method & args]
   `(apply (.- ~o ~method) ~@args))
 
+(defmacro comment
+  "Ignore all the forms passed, returning nil."
+  [& forms]
+  nil)
+
 (defmacro new
   "Create a new instance of class with args.
 

src/basilisp/lang/runtime.py

@@ -565,21 +565,31 @@ def apply(f, args):
     return f(*final)
 
 
-def nth(coll, i):
+__nth_sentinel = object()
+
+
+def nth(coll, i, notfound=__nth_sentinel):
     """Returns the ith element of coll (0-indexed), if it exists.
-    None otherwise."""
+    None otherwise. If i is out of bounds, throws an IndexError unless
+    notfound is specified."""
     if coll is None:
         return None
 
     try:
         return coll[i]
+    except IndexError as ex:
+        if notfound is not __nth_sentinel:
+            return notfound
+        raise ex
     except TypeError:
         pass
 
     try:
         for j, e in enumerate(coll):
             if i == j:
                 return e
+        if notfound is not __nth_sentinel:
+            return notfound
         raise IndexError(f"Index {i} out of bounds")
     except TypeError:
         pass

tests/basilisp/core_macros_test.lpy

@@ -1,6 +1,30 @@
 (ns basilisp.core-macros-test
   (:require
-   [basilisp.test :refer [deftest is]]))
+   [basilisp.test :refer [deftest is testing]]))
+
+(deftest condp-test
+  (testing "condp result value"
+    (is (= :a (condp = "a" :a)))
+    (is (= :a (condp = "a"
+                "b" :b
+                :a)))
+    (is (= :a (condp = "a"
+                "b" :b
+                "c" :c
+                :a))))
+
+  (testing "condp result function"
+    (is (= :a (condp some [1 8 10 12]
+                #{2 4 6} :>> inc
+                :a)))
+    (is (= 0 (condp some [1 8 10 12]
+               #{2 4 6} :>> inc
+               #{1 3 5} :>> dec
+               :a)))))
+
+(deftest comment-test
+  (is (= nil (comment 1)))
+  (is (= nil (comment [1 2 3]))))
 
 (deftest ->-test
   (is (= :a (-> :a)))

tests/basilisp/core_test.py

@@ -493,6 +493,18 @@ def test_get():
     assert None is core.get(vec.v(1, 2, 3), -4)
 
 
+def test_keys():
+    assert None is core.keys(lmap.map({}))
+    assert llist.l("a") == core.keys(lmap.map({"a": 1}))
+    assert lset.s("a", "b") == lset.set(core.keys(lmap.map({"a": 1, "b": 2})))
+
+
+def test_vals():
+    assert None is core.vals(lmap.map({}))
+    assert llist.l(1) == core.vals(lmap.map({"a": 1}))
+    assert lset.s(1, 2) == lset.set(core.vals(lmap.map({"a": 1, "b": 2})))
+
+
 def test_range():
     assert llist.l(1) == core.range_(1, 1)
     assert llist.l(1, 2, 3, 4, 5) == core.range_(1, 5)
@@ -622,6 +634,16 @@ def test_map():
     assert llist.l(5, 7, 9) == core.map_(core.__PLUS__, vec.v(1, 2, 3), core.range_(4))
 
 
+def test_map_indexed():
+    assert llist.l(vec.v(0, 1), vec.v(1, 2), vec.v(2, 3)) == core.map_indexed(core.vector, vec.v(1, 2, 3))
+
+
+def test_mapcat():
+    assert llist.List.empty() == core.mapcat(lambda x: vec.v(x, x + 1), vec.Vector.empty())
+    assert llist.l(1, 2, 2, 3, 3, 4) == core.mapcat(lambda x: vec.v(x, x + 1), vec.v(1, 2, 3))
+    assert llist.l(1, 4, 2, 5, 3, 6) == core.mapcat(core.vector, vec.v(1, 2, 3), vec.v(4, 5, 6))
+
+
 def test_filter():
     assert llist.List.empty() == core.filter_(core.identity, vec.Vector.empty())
     assert llist.l(1, 3) == core.filter_(core.odd__Q__, vec.v(1, 2, 3, 4))

tests/basilisp/runtime_test.py

@@ -148,6 +148,9 @@ def test_nth():
     assert "l" == runtime.nth(vec.v("h", "e", "l", "l", "o"), 2)
     assert "l" == runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 2)
 
+    assert "Z" == runtime.nth(llist.l("h", "e", "l", "l", "o"), 7, "Z")
+    assert "Z" == runtime.nth(lseq.sequence(["h", "e", "l", "l", "o"]), 7, "Z")
+
     with pytest.raises(IndexError):
         runtime.nth(llist.l("h", "e", "l", "l", "o"), 7)
 
@@ -157,6 +160,9 @@ def test_nth():
     with pytest.raises(TypeError):
         runtime.nth(3, 1)
 
+    with pytest.raises(TypeError):
+        runtime.nth(3, 1, "Z")
+
 
 def test_assoc():
     assert lmap.Map.empty() == runtime.assoc(None)