 (defn branch! [x]
   (check (= :match/branch (:type x))
          (pattern! (:pattern x))
-         (action! (:action x))))
+         (branch-action! (:action x))))
 
 (defn match! [x]
   (check (= :match (:type x))
-         (id! (:arg x))
+         (data! (:arg x))
          (sequential? (:branches x))
          (every? branch! (:branches x))))
 

                   (every? pattern! (vals x)))
   :else (check false)))

(defn action! [x]
  (case (:type x)
    :call (check (call! x))
    :constant (check (constant! x))

         (id! (:id x))
         (string? (:name x))))

(defn data! [x]
  (cond
   (= :tag (:type x)) (check (tag! x))
