 
                    :else [#(empty (c/or conform-into %)) addcv identity]))]
        (reify
+        Specize
+        (specize* [s] s)
+        (specize* [s _] s)
+        
         Spec
         (conform* [_ x]
-                  (cond
-                   (coll-prob x kind kind-form distinct count min-count max-count
-                              nil nil nil)
-                   ::invalid
-
-                   conform-all
-                   (let [[init add complete] (cfns x)]
-                     (loop [ret (init x), i 0, [v & vs :as vseq] (seq x)]
-                       (if vseq
-                         (let [cv (dt pred v nil)]
-                           (if (invalid? cv)
-                             ::invalid
-                             (recur (add ret i v cv) (inc i) vs)))
-                         (complete ret))))
-                   
-                   
-                   :else
-                   (if (indexed? x)
-                     (let [step (max 1 (long (/ (c/count x) *coll-check-limit*)))]
-                       (loop [i 0]
-                         (if (>= i (c/count x))
-                           x
-                           (if (check? (nth x i))
-                             (recur (c/+ i step))
-                             ::invalid))))
-                     (c/or (c/and (every? check? (take *coll-check-limit* x)) x)
-                           ::invalid))))
+                  (let [spec @spec]
+                    (cond
+                     (not (cpred x)) ::invalid
+
+                     conform-all
+                     (let [[init add complete] (cfns x)]
+                       (loop [ret (init x), i 0, [v & vs :as vseq] (seq x)]
+                         (if vseq
+                           (let [cv (conform* spec v)]
+                             (if (invalid? cv)
+                               ::invalid
+                               (recur (add ret i v cv) (inc i) vs)))
+                           (complete ret))))
+                     
+                     
+                     :else
+                     (if (indexed? x)
+                       (let [step (max 1 (long (/ (c/count x) *coll-check-limit*)))]
+                         (loop [i 0]
+                           (if (>= i (c/count x))
+                             x
+                             (if (valid? spec (nth x i))
+                               (recur (c/+ i step))
+                               ::invalid))))
+                       (let [limit *coll-check-limit*]
+                         (loop [i 0 [v & vs :as vseq] (seq x)]
+                           (cond
+                            (c/or (nil? vseq) (= i limit)) x
+                            (valid? spec v) (recur (inc i) vs)
+                            :else ::invalid)))))))
         (unform* [_ x] x)
         (explain* [_ path via in x]
                   (c/or (coll-prob x kind kind-form distinct count min-count max-count

(defn spec?
  "returns x if x is a spec object, else logical false"
  [x]
  (c/and (extends? Spec (class x)) x))

(defn regex?
  "returns x if x is a (clojure.spec) regex op, else logical false"

                          (recur nret (inc i))))
                      ret)))))]
    (reify
     Specize
     (specize* [s] s)
     (specize* [s _] s)
     
     Spec
     (conform* [_ x] (cform x))
     (unform* [_ x] (reduce #(unform %2 %1) x (reverse preds)))
