Edit flatten and its docstring

Returning a non-collection in a singleton list is more consistent behavior. The type check looks unlikely to be useful.

Author: Kodiologist

Diff for: NEWS.rst

@@ -13,6 +13,8 @@ New Features
 * New macro `pun`.
 * New macro `map-hyseq`.
 * `loop` allows more kinds of parameters.
+* `flatten`, given a non-collection, returns it as a singleton list,
+  instead of raising an error.
 
 Bug Fixes
 ------------------------------

Diff for: hyrule/iterables.hy

@@ -52,20 +52,30 @@
 
 
 (defn flatten [coll]
-  #[=[Recurisvely collect all the elements and subelements of ``coll`` into a
-  single list. :hy:func:`coll?` is used to decide whether objects should be
-  descended into. ::
+  #[=[Recurisvely collect all the elements and subelements of ``coll``,
+  depth-first, and return them in a single list. :hy:func:`coll?` is used to
+  decide whether objects should be descended into. ::
+
 
     (flatten ["foo" #(1 2) [1 [2 3] 4] "bar"])
-      ; => ["foo" 1 2 1 2 3 4 "bar"]]=]
-  (if (coll? coll)
-    (_flatten coll [])
-    (raise (TypeError (.format "{0!r} is not a collection" coll)))))
+      ; => ["foo" 1 2 1 2 3 4 "bar"]
+
+  Since iteration is used to collect the elements of ``coll``, dictionaries
+  are reduced to lists of keys::
+
+    (flatten [{"a" 1  "b" 2} {"c" 3  "d" 4}])
+      ; => ["a" "b" "c" "d"]
+
+  If ``coll`` isn't a collection at all, it's returned in a singleton list::
+
+    (flatten "hello")
+      ; => ["hello"]]=]
+  (_flatten coll []))
 
 (defn _flatten [coll result]
   (if (coll? coll)
-    (do (for [b coll]
-          (_flatten b result)))
+    (for [x coll]
+      (_flatten x result))
     (.append result coll))
   result)
 

Diff for: tests/test_iterables.hy

@@ -63,14 +63,13 @@
   (assert (=
     (flatten ["foo" #(1 2) [1 [2 3] 4] "bar"])
     ["foo" 1 2 1 2 3 4 "bar"]))
+  (assert (= (flatten "foo") ["foo"]))
+  (assert (= (flatten 12.34) [12.34]))
   (assert (= (flatten [1]) [1]))
   (assert (= (flatten []) []))
   (assert (= (flatten #(1)) [1]))
   (assert (= (flatten #(1 #(None 3))) [1 None 3]))
-  (try (flatten "foo")
-       (except [e [TypeError]] (assert (in "not a collection" (str e)))))
-  (try (flatten 12.34)
-       (except [e [TypeError]] (assert (in "not a collection" (str e))))))
+  (assert (= (flatten {"a" 1 "b" 2}) ["a" "b"])))
 
 
 (defn test-rest []