Fix nil behaviour with collection types #1011 (#1012)

Fixes #1011

Author: mitch-kyle

CHANGELOG.md

@@ -32,6 +32,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Fix using keyword as a function not returning the default value in some cases (#997)
  * Fix an issue where Python `SyntaxWarning`s would be emitted for certain compiled code (#996)
  * Fix an issue where 2- and 3-arity `range` invocations returned unexpected results (#1004)
+ * Fix the behaviour of `nil` with several collection functions (#1011)
 
 ### Removed
  * Removed `python-dateutil` and `readerwriterlock` as dependencies, switching to standard library components instead (#976)

src/basilisp/core.lpy

@@ -2155,7 +2155,7 @@
 
   For empty collections, returns ``nil``\\."
   [coll]
-  (.peek coll))
+  (when coll (.peek coll)))
 
 (defn ^:inline pop
   "For a list or a queue, return a new list without the first element.
@@ -2164,7 +2164,7 @@
 
   If ``coll`` is empty, throw an exception."
   [coll]
-  (.pop coll))
+  (when coll (.pop coll)))
 
 (defn reverse
   "Return a seq containing the elements in ``coll`` in reverse order. The returned
@@ -2308,8 +2308,8 @@
 (defn find
   "Find the map entry of ``k`` in ``m``\\, if it exists. Return ``nil`` otherwise."
   [m k]
-  (when-let [v (get m k)]
-    (map-entry k v)))
+  (when (contains? m k)
+    (map-entry k (get m k))))
 
 (defn ^:inline key
   "Return the key from a map entry."
@@ -2324,12 +2324,12 @@
 (defn ^:inline keys
   "Return a seq of the keys from a map."
   [m]
-  (seq (.keys m)))
+  (when m (seq (.keys m))))
 
 (defn ^:inline vals
   "Return a seq of the values from a map."
   [m]
-  (seq (.values m)))
+  (when m (seq (.values m))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Transient Collections ;;
@@ -3409,9 +3409,12 @@
 (defn rand-int
   "Return a random integer between ``lower`` (default: 0) and ``upper`` inclusive."
   ([upper]
-   (random/randrange 0 upper))
+   (rand-int 0 upper))
   ([lower upper]
-   (random/randrange lower upper)))
+   (cond
+      (= upper lower) upper
+      (< upper lower) (random/randrange upper lower)
+      :else           (random/randrange lower upper))))
 
 (defn rand-nth
   "Return a random element from ``coll``\\."

src/basilisp/lang/runtime.py

@@ -1229,10 +1229,14 @@ def apply_kw(f, args):
     except TypeError as e:
         logger.debug("Ignored %s: %s", type(e).__name__, e)
 
-    kwargs = {
-        to_py(k, lambda kw: munge(kw.name, allow_builtins=True)): v
-        for k, v in last.items()
-    }
+    if last is None:
+        kwargs = {}
+    else:
+        kwargs = {
+            to_py(k, lambda kw: munge(kw.name, allow_builtins=True)): v
+            for k, v in last.items()
+        }
+
     return f(*final, **kwargs)
 
 

src/basilisp/lang/vector.py

@@ -300,9 +300,11 @@ def from_vec(v: Sequence[Union[K, V]]) -> "MapEntry[K, V]":
 
 
 def vector(
-    members: Iterable[T], meta: Optional[IPersistentMap] = None
+    members: Optional[Iterable[T]], meta: Optional[IPersistentMap] = None
 ) -> PersistentVector[T]:
     """Creates a new vector."""
+    if members is None:
+        members = []
     return PersistentVector(pvector(members), meta=meta)
 
 

tests/basilisp/keyword_test.py

@@ -64,7 +64,7 @@ def test_keyword_as_function():
     assert None is kw(lset.s(1))
     assert "hi" == kw(lset.s(1), default="hi")
 
-    assert 1 is kw(None, 1)
+    assert 1 == kw(None, 1)
     assert None is kw(None, None)
 
     assert None is kw(lvector.v(1))

tests/basilisp/test_core_fns.lpy

@@ -373,7 +373,8 @@
 (deftest peek-test
   (are [x] (nil? (peek x))
     []
-    '())
+    '()
+    nil)
   (are [x y] (= x (peek y))
     :a '(:a)
     :a '(:a :b :c)
@@ -387,7 +388,8 @@
     '() '(:a)
     '(:b :c) '(:a :b :c)
     [] [:a]
-    [:a :b] [:a :b :c]))
+    [:a :b] [:a :b :c]
+    nil nil))
 
 (deftest reverse-test
   (are [x y] (= x (reverse y))
@@ -424,6 +426,22 @@
     '(4 3 2 1) [1 2 3 4]
     '(:d :c :b :a) [:a :b :c :d]))
 
+(deftest rand-nth-test
+  (is (= nil (rand-nth nil)))
+  (is (= 1 (rand-nth [1])))
+  (is (#{1 2} (rand-nth [1 2]))))
+
+(deftest vec-test
+  (are [expected x] (= expected (vec x))
+    []       []
+    []       ()
+    []       #{}
+    []       {}
+    []       nil
+    [1]      (list 1)
+    [1]      #{1}
+    [1 2]    (list 1 2)))
+
 (deftest subvec-test
   (is (= [] (subvec [] 0)))
   (is (thrown? python/IndexError (subvec [] 3)))
@@ -699,6 +717,13 @@
 ;; Higher Order and Collection Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(deftest apply-kw-test
+  (let [kwargs ^{:kwargs :collect} (fn [x] x)]
+    (are [expected x] (= expected (apply-kw kwargs x))
+      {:test 1} {:test 1}
+      {}        {}
+      {}        nil)))
+
 (deftest run!-test
   (testing "empty collection"
     (let [a (atom 0)]
@@ -1382,6 +1407,42 @@
     {:a "A" 'b 2}                                {:a "a" 'b 2}
     ^{:good :yes :great :also-yes} {:a "A" 'b 2} ^{:good :yes :great :also-yes} {:a "a" 'b 2}))
 
+(deftest keys-test
+  (are [expected m] (= expected (set (keys m)))
+    #{}      {}
+    #{}      nil
+    #{:a}    {:a 1}
+    #{:a}    {:a nil}
+    #{:a :b} {:a 1 :b 2}
+    #{"a"}   {"a" 1}
+    #{}      (python/dict {})
+    #{:a}    (python/dict {:a 1})))
+
+(deftest vals-test
+  (are [expected m] (= expected (set (vals m)))
+    #{}    {}
+    #{}    nil
+    #{1}   {:a 1}
+    #{nil} {:a nil}
+    #{1 2} {:a 1 :b 2}
+    #{1}   {"a" 1}
+    #{}    (python/dict {})
+    #{1}   (python/dict {:a 1})))
+
+(deftest find-test
+  (are [expected m k] (= expected (find m k))
+    nil      {}                   :a
+    nil      nil                  nil
+    nil      nil                  :a
+    [:a 1]   {:a 1}               :a
+    nil      {:a 1}               :b
+    [:a nil] {:a nil}             :a
+    [:b 2]   {:a 1 :b 2}          :b
+    ["a" 1]  {"a" 1}              "a"
+    nil      (python/dict {})     :a
+    nil      (python/dict {})     nil
+    [:a 1]   (python/dict {:a 1}) :a))
+
 ;;;;;;;;;;;;;;;;;;;;;;
 ;; String Functions ;;
 ;;;;;;;;;;;;;;;;;;;;;;