 (s/def ::query
   (s/coll-of ::query-expr :kind vector?
     :gen #(let [g (s/gen (s/coll-of ::query-expr :kind vector? :max-count 5))]
-            (tc/->Generator
+            (gen/->Generator
               (fn [rdn size]
                 (if (> *query-gen-max-depth* 0)
                   (binding [*query-gen-max-depth* (dec *query-gen-max-depth*)]
-                    (tc/call-gen g rdn size))
-                  (tc/call-gen (tc/return []) rdn size)))))))
+                    (gen/call-gen g rdn size))
+                  (gen/call-gen (gen/return []) rdn size)))))))
+
+(def sample-mutations '#{do-something create/this-thing operation.on/space})
 
 (s/def ::mutation-expr
   (s/with-gen
     (s/and list? (s/cat :mutate-key symbol? :params (s/? ::params)))
-    #(tc/let [key (s/gen '#{do-something create/this-thing operation.on/space})
-              val (s/gen ::params)]
+    #(gen/let [key (s/gen sample-mutations)
+               val (s/gen ::params)]
        (list key val))))
 
 (s/def ::mutation-join


(s/def ::om-parser
  (s/fspec :args (s/cat :env map? :tx vector?)
    :ret map?))

(s/def ::wrap-read
  (s/fspec :args (s/cat :reader ::reader-fn)
    :ret ::reader-fn))

(s/def ::wrap-parser
  (s/fspec :args (s/cat :parser ::om-parser)
    :ret ::om-parser))

(s/def ::plugin (s/keys :opt [::wrap-read ::wrap-parser]))



(s/def ::process-reader
  (s/fspec :args (s/cat :reader ::reader)
           :ret ::reader))

(s/def ::error
  (s/spec #?(:clj  #(instance? Throwable %)
