 (defn join-rose
   "Turn a tree of trees into a single tree. Does this by concatenating
   children of the inner and outer trees."
+  {:no-doc true}
   [[[inner-root inner-children] children]]
   [inner-root (concat (clojure.core/map join-rose children)
                       inner-children)])
 
 (defn rose-root
   "Returns the root of a Rose tree."
+  {:no-doc true}
   [[root _children]]
   root)
 
 (defn rose-children
   "Returns the children of the root of the Rose tree."
+  {:no-doc true}
   [[_root children]]
   children)
 
 (defn rose-pure
   "Puts a value `x` into a Rose tree, with no children."
+  {:no-doc true}
   [x]
   [x []])
 
 (defn rose-fmap
   "Applies functions `f` to all values in the tree."
+  {:no-doc true}
   [f [root children]]
   [(f root) (clojure.core/map (partial rose-fmap f) children)])
 

  "Returns a new Rose tree whose values pass `pred`. Values who
  do not pass `pred` have their children cut out as well.
  Takes a list of roses, not a rose"
  [pred [root children]]
  [root (clojure.core/map (partial rose-filter pred)
                          (clojure.core/filter (comp pred rose-root) children))])
(defn rose-permutations
  "Create a seq of vectors, where each rose in turn, has been replaced
  by its children."
  [roses]
  (apply concat
         (for [[rose index]

;; ---------------------------------------------------------------------------

(defn resize
  "Create a new generator with `size` always bound to `n`."
  [n {gen :gen}]
  (make-gen
    (fn [rnd _size]
