   [& generators]
   (assert (every? generator? generators)
           "Args to tuple must be generators")
-  (gen-bind (gen-tuple generators)
-            (fn [roses]
-              (gen-pure (rose/zip core/vector roses)))))
+  (gen-fmap (fn [roses]
+              (rose/zip core/vector roses))
+            (gen-tuple generators)))
 
 (def int
   "Generates a positive or negative integer bounded by the generator's

   (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/vector
                                                roses)))))))
  ([generator num-elements]
   (assert (generator? generator) "First arg to vector must be a generator")
   (apply tuple (repeat num-elements generator)))

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

(defn- swap
  [coll [i1 i2]]
