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

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

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

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

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

(defn- interleave-specs [specs {:keys [val] :as state} succ fail]
  (letfn [(rec [specs val]
            (if (empty? specs)
              (fail)
              (let [[spec & specs] specs
                    evaled-spec (eval* spec)
                    conformed (s/conform evaled-spec val)]
                (if (s/invalid? conformed)
                  (let [ed (s/explain-data evaled-spec val)
                        ;;FIXME: should deal with all the problems,
                        ;; not only first one
                        {:keys [in path]} (first (::s/problems ed))]
                    (succ (assoc state
                                 :spec spec :val val :in in :path path)
                          fail))
                  (recur specs conformed)))))]
    (rec specs val)))

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

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