Fix the definition of reduce (#567)

* Fix the definition of `reduce`

* Changelog

Author: chrisrink10

CHANGELOG.md

@@ -34,6 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Fixed multiple bugs relating to symbol resolution of `import`ed symbols in various contexts (#544)
  * Fixed a bug where the `=` function did not respect the equality partition for various builtin collection types (#556)
  * Fixed a bug where collection types could evaluate as boolean `false` (#566)
+ * Fixed a bug where `reduce` required a 1-arity function for the variant with an initial value, rather than returning that initial value (#567)
 
 ## [v0.1.dev13] - 2020-03-16
 ### Added

src/basilisp/core.lpy

@@ -2087,22 +2087,22 @@
   (fn [& ^:no-warn-when-unused args] x))
 
 (defn reduce
-  "Reduce coll by f.
+  "Reduce `coll` by `f`.
 
-  If val is not supplied and coll has no elements, f will be called
+  If `val` is not supplied and `coll` has no elements, `f` will be called
   with no arguments and the result will be returned.
 
-  If val is not supplied and coll has one element, the result of
-  (f (first val)) is returned.
+  If `val` is not supplied and `coll` has one element, the result of
+  `(f (first val))` is returned.
 
-  If val is not supplied and coll has elements, repeatedly reduce coll
-  by calling f on successive elements in coll.
+  If `val` is not supplied and `coll` has elements, repeatedly reduce `coll`
+  by calling `f` on successive elements in `coll`.
 
-  If val is supplied and coll has no elements, the result of (f val)
-  is returned.
+  If `val` is supplied and `coll` has no elements, return `val` and `f` will
+  not be called.
 
-  If val is supplied and coll has elements, repeatedly reduce coll
-  by calling f on successive elements in coll, starting with val."
+  If `val` is supplied and `coll` has elements, repeatedly reduce coll
+  by calling `f` on successive elements in `coll`, starting with `val`."
   ([f coll]
    (if (seq coll)
      (if (seq (rest coll))
@@ -2116,7 +2116,7 @@
                          out))]
      (if (seq coll)
        (reduce-coll val coll)
-       (f val)))))
+       val))))
 
 (defn reduce-kv
   "Reduce an associative coll by f. f must be a function of 3
@@ -2407,29 +2407,25 @@
   "Return a map whose keys are the elements of coll and whose values are
   the counts for the number of times the key appears in coll."
   [coll]
-  (if-not (seq coll)
-    {}
-    (reduce (fn [m v]
-              (if (contains? m v)
-                (update m v inc)
-                (assoc m v 1)))
-            {}
-            coll)))
+  (reduce (fn [m v]
+            (if (contains? m v)
+              (update m v inc)
+              (assoc m v 1)))
+          {}
+          coll))
 
 (defn group-by
   "Return a map whose keys are the result of calling f on each element
   in coll and whose values are vectors of the values which produced the
   corresponding key, in the order they were added."
   [f coll]
-  (if-not (seq coll)
-    {}
-    (reduce (fn [m v]
-              (let [group (f v)]
-                (if (contains? m group)
-                  (update m group conj v)
-                  (assoc m group [v]))))
-            {}
-            coll)))
+  (reduce (fn [m v]
+            (let [group (f v)]
+              (if (contains? m group)
+                (update m group conj v)
+                (assoc m group [v]))))
+          {}
+          coll))
 
 (defn interpose
   "Return a lazy sequence of elements of coll separated by sep. If
@@ -3686,15 +3682,12 @@
 
   Public vars are Vars which are declared without :private metadata."
   [ns]
-  (let [interns (ns-interns (the-ns ns))]
-    (if-not (seq interns)
-      {}
-      (reduce (fn [m entry]
-                (if (:private (meta (val entry)))
-                  m
-                  (assoc m (key entry) (val entry))))
-              {}
-              interns))))
+  (reduce (fn [m entry]
+            (if (:private (meta (val entry)))
+              m
+              (assoc m (key entry) (val entry))))
+          {}
+          (ns-interns (the-ns ns))))
 
 (defn ns-refers
   "Return a map of symbols to Vars which are referred in the current
@@ -3931,16 +3924,15 @@
   (let [doc  (when (string? (first opts))
                (first opts))
         opts (if doc (rest opts) opts)
-        opts (when (seq opts)
-               (reduce (fn [m opt]
-                         (let [opt-name (first opt)
-                               options  (rest opt)]
-                           (when-not (keyword? opt-name)
-                             (throw (ex-info "Namespace option must be a keyword"
-                                             {:option opt-name})))
-                           (assoc m opt-name (vec options))))
-                       {}
-                       opts))
+        opts (reduce (fn [m opt]
+                       (let [opt-name (first opt)
+                             options  (rest opt)]
+                         (when-not (keyword? opt-name)
+                           (throw (ex-info "Namespace option must be a keyword"
+                                           {:option opt-name})))
+                         (assoc m opt-name (vec options))))
+                     {}
+                     opts)
 
         refer-filters (when-let [filters (or (:refer-basilisp opts)
                                              (:refer-clojure opts))]
@@ -4095,14 +4087,12 @@
 (defn select-keys
   "Return a map with only the keys of m which are in ks."
   [m ks]
-  (if-not (seq ks)
-    {}
-    (reduce (fn [new-map k]
-              (if (contains? m k)
-                (assoc new-map k (get m k))
-                new-map))
-            {}
-            ks)))
+  (reduce (fn [new-map k]
+            (if (contains? m k)
+              (assoc new-map k (get m k))
+              new-map))
+          {}
+          ks))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Destructuring Support ;;

src/basilisp/set.lpy

@@ -19,15 +19,13 @@
   "Given a set of maps, return a mapping of unique selections of keys
   from ks to the set of values which have those mappings."
   [rel ks]
-  (if-not (seq rel)
-    {}
-    (reduce (fn [m v]
-              (let [index-val (select-keys v ks)]
-                (if (contains? m index-val)
-                  (update m index-val conj v)
-                  (assoc m index-val #{v}))))
-            {}
-            rel)))
+  (reduce (fn [m v]
+            (let [index-val (select-keys v ks)]
+              (if (contains? m index-val)
+                (update m index-val conj v)
+                (assoc m index-val #{v}))))
+          {}
+          rel))
 
 (defn intersection
   "Return a new set with only elements in s1 that are in all
@@ -42,12 +40,10 @@
   Duplicate values used as keys will overwrite each other as
   iteration order is non-deterministic."
   [m]
-  (if-not (seq m)
-    m
-    (reduce (fn [m entry]
-              (assoc m (val entry) (key entry)))
-            {}
-            m)))
+  (reduce (fn [m entry]
+            (assoc m (val entry) (key entry)))
+          {}
+          m))
 
 (defn project
   "Given a set of maps, return a set of those maps with only the keys in ks."
@@ -58,18 +54,16 @@
   "Return m with any keys appearing in kmap replaced with the value
   in kmap."
   [m kmap]
-  (if-not (seq m)
-    m
-    (reduce (fn [m entry]
-              (let [orig-k (key entry)
-                    new-k  (val entry)]
-                (if (contains? m orig-k)
-                  (let [v         (get m orig-k)
-                        clean-map (dissoc m orig-k)]
-                    (assoc clean-map new-k v))
-                  m)))
-            m
-            kmap)))
+  (reduce (fn [m entry]
+            (let [orig-k (key entry)
+                  new-k  (val entry)]
+              (if (contains? m orig-k)
+                (let [v         (get m orig-k)
+                      clean-map (dissoc m orig-k)]
+                  (assoc clean-map new-k v))
+                m)))
+          m
+          kmap))
 
 (defn rename
   "Given a set of maps, return a set whose maps have had any keys in kmap
@@ -127,28 +121,24 @@
 
          lindex (index lrel shared)
          rindex (index rrel shared)]
-     (if-not (seq lindex)
-       #{}
-       (reduce (fn [s [k l-indexed]]
-                 (if (contains? rindex k)
-                   (apply conj s (product merge l-indexed (get rindex k)))
-                   s))
-               #{}
-               lindex))))
+     (reduce (fn [s [k l-indexed]]
+               (if (contains? rindex k)
+                 (apply conj s (product merge l-indexed (get rindex k)))
+                 s))
+             #{}
+             lindex)))
   ([lrel rrel keymap]
    (let [[f s ks] (if (<= (count lrel) (count rrel))
                     [lrel rrel (map-invert keymap)]
                     [rrel lrel keymap])
          idx      (index f (vals ks))]
-     (if-not (seq s)
-       #{}
-       (reduce (fn [ret x]
-                 (let [match (idx (rename-keys (select-keys x (keys ks)) ks))]
-                   (if match
-                     (reduce (fn [s v]
-                               (conj s (merge v x)))
-                             ret
-                             match)
-                     ret)))
-               #{}
-               s)))))
+     (reduce (fn [ret x]
+               (let [match (idx (rename-keys (select-keys x (keys ks)) ks))]
+                 (if match
+                   (reduce (fn [s v]
+                             (conj s (merge v x)))
+                           ret
+                           match)
+                   ret)))
+             #{}
+             s))))

tests/basilisp/test_core_fns.lpy

@@ -531,10 +531,14 @@
                    :methods '[(method [thing1 thing2])
                               (method [& args])]))
 
+  (is (not (nil? (gen-interface :name "TestInterface"))))
+
   (are [arity-names methods] (let [interface (gen-interface :name "TestInterface"
                                                             :methods methods)]
                                (set/superset? (set (python/dir interface))
                                               (set arity-names)))
+    [] []
+
     ["method"]
     '[(method [arg])]