   [spec]
   (let [spec (specize spec)]
     (reify
+     Specize
+     (specize* [s] s)
+     (specize* [s _] s)
+     
      Spec
      (conform* [_ x] (let [ret (conform* spec x)]
                        (if (invalid? ret)


                   :else [#(empty (c/or conform-into %)) addcv identity]))]
       (reify
        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))))
        (unform* [_ x] x)
        (explain* [_ path via in x]
                  (c/or (coll-prob x kind kind-form distinct count min-count max-count

     (valAt [this k] (get specs k))
     (valAt [_ k not-found] (get specs k not-found))

     Specize
     (specize* [s] s)
     (specize* [s _] s)
       
     Spec
     (conform* [_ f] (if (ifn? f)
                       (if (identical? f (validate-fn f specs *fspec-iterations*)) f ::invalid)
