   (assert (generator? generator) "First arg to list must be a generator")
   (gen-bind (sized #(choose 0 %))
             (fn [num-elements-rose]
-              (gen-bind (gen-tuple (repeat (rose/root num-elements-rose)
-                                           generator))
-                        (fn [roses]
-                          (gen-pure (rose/shrink-vector core/list
-                                                        roses)))))))
+              (gen-fmap (fn [roses]
+                          (rose/shrink-vector core/list
+                                              roses))
+                        (gen-tuple (repeat (rose/root num-elements-rose)
+                                           generator))))))
 
 (defn- swap
   [coll [i1 i2]]

   (gen-bind
    (choose min-elements max-elements)
    (fn [num-elements-rose]
      (gen-bind (gen-tuple (repeat (rose/root num-elements-rose)
                                   generator))
                (fn [roses]
                  (gen-bind
                   (gen-pure (rose/shrink-vector core/vector
                                                 roses))
                   (fn [rose]
                     (gen-pure (rose/filter
                                (fn [v] (and (>= (count v) min-elements)
                                             (<= (count v) max-elements))) rose))))))))))

(defn list
  "Like `vector`, but generates lists."

  applicable to the domain."
  [gen]
  (assert (generator? gen) "Arg to no-shrink must be a generator")
  (gen-fmap (fn [rose]
              (rose/make-rose (rose/root rose) []))
            gen))

(defn shrink-2
  "Create a new generator like `gen`, but will consider nodes for shrinking
  even if their parent passes the test (up to one additional level)."
  [gen]
  (assert (generator? gen) "Arg to shrink-2 must be a generator")
  (gen-fmap rose/collapse gen))

(def boolean
  "Generates one of `true` or `false`. Shrinks to `false`."
