   [& 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

  (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)))))))

(defn- swap
  [coll [i1 i2]]

  [coll]
  (assert (seq coll) "elements cannot be called with an empty collection")
  (core/let [v (vec coll)]
    (gen-fmap #(rose/fmap v %)
              (choose 0 (dec (count v))))))

(defn- such-that-helper
  [pred gen {:keys [ex-fn max-tries]} rng size]
