 
 (defn- add-dispatch-entries
   [dispatch-map method pathvec handler]
-  (let [pathvec'      (mapv #(if (variable? %) ::param %) pathvec)
+  (let [pathvec' (mapv #(if (variable? %) ::param %) pathvec)
         dispatch-path (conj pathvec' method)
-        route-params  (filterv variable? pathvec)]
+        route-params (filterv variable? pathvec)]
     (assoc-in dispatch-map dispatch-path
-      {:handler handler
-       :route-param-keys (mapv keyword route-params)})))
+              {:handler          handler
+               :route-param-keys (mapv keyword route-params)})))
 
 (defn- build-dispatch-map
   "Returns a dispatch-map for use with map-traversal-dispatcher."

  entries such as

      [:get [\"api\" \"foo\"] 'example.foo/index ns-middleware]."
  [options? & ns-specs]
  (let [opts (merge default-opts (if (map? options?) options?))
        {outer-context-pathvec :context-pathvec
         default-middleware    :default-middleware} opts
        ns-specs (canonicalize-ns-specs
                   []
                   default-middleware
                   (if (map? options?)
                     ns-specs
                     (cons options? ns-specs)))]
    [(reduce into [outer-context-pathvec default-middleware]
             (map (fn [[context-pathvec ns-sym middleware]]
                    (simple-namespace-dispatch-table
                      context-pathvec ns-sym middleware))
                  ns-specs))]))

  (let [arg-symbol (symbol-for-argument arg)
        arg-meta (meta arg-symbol)]
    (t/track #(format "Identifying argument resolver for `%s'." arg-symbol)
             (cond
               ;; route param resolution takes precedence
               (contains? route-params arg)
               (make-route-param-resolver arg-symbol)

               ;; explicit ::rook/resolver metadata takes precedence for non-route params
               (contains? arg-meta :io.aviso.rook/resolver)
               (find-resolver arg-resolvers arg-symbol (:io.aviso.rook/resolver arg-meta))

               :else
               (if-let [resolver-tag (find-argument-resolver-tag
                                       arg-resolvers arg-symbol arg-meta)]
                 ;; explicit tags attached to the arg symbol itself come next
                 (find-resolver arg-resolvers arg-symbol resolver-tag)

                 ;; non-route-param name-based resolution is implicit and
                 ;; should not override explicit tags, so this check comes
                 ;; last; NB. the value at arg-symbol might be a keyword
                 ;; identifying a resolver factory, so we still need to call
                 ;; find-resolver
                 (if (contains? arg-resolvers arg-symbol)
                   (find-resolver arg-resolvers arg-symbol (get arg-resolvers arg-symbol))

                   ;; only static resolution is supported
                   (throw (ex-info
                            (format "Unable to identify argument resolver for symbol `%s'." arg-symbol)
                            {:symbol        arg-symbol
                             :symbol-meta   arg-meta
                             :route-params  route-params
                             :arg-resolvers arg-resolvers}))))))))

(defn- create-arglist-resolver
  "Returns a function that is passed the Ring request and returns an array of argument values which
