   (step-forward state (regex-succ succ) fail))
 
 (defmethod step* `s/& [state succ fail]
-  (choose-spec (rest (:spec state)) state (regex-succ succ) fail))
+  (interleave-specs (rest (:spec state)) state succ fail))
 
 (defmethod step* `s/alt [state succ fail]
   (step-forward state (regex-succ succ) fail))

  (with-cont succ fail
    (update state :spec second)))

(defn- choose-spec [specs state succ fail]
  (letfn [(rec [specs]
            (if (empty? specs)
              (fail)
              (succ (assoc state :spec (first specs))
                    #(rec (rest specs)))))]
    (rec specs)))

(defmethod step* `s/and [state succ fail]
  (let [specs (rest (:spec state))]
    (choose-spec specs state succ fail)))

(defn- step-forward [{:keys [spec path] :as state} succ fail]
  (with-cont succ fail

            (get keys key))]
    (step-for-keys state succ fail get-key)))

(defmethod step* `s/merge [{:keys [spec] :as state} succ fail]
  (letfn [(rec [specs]
            (if (empty? specs)
              (fail)
              (let [[spec & specs] specs]
                (if (s/invalid? (s/conform (eval* spec) val))
                  ;;FIXME: should deal with all the problems,
                  ;; not only the first one
                  (succ (assoc state :spec spec) fail)
                  (recur specs)))))]
    (rec (rest spec))))

(def ^:private regex-ops
  `#{s/cat s/& s/alt s/? s/* s/+})
