            ))))))
 
 (defmacro providepath [name apath]
-  `(let [comped# (comp-paths* ~apath)
-         expected-params# (num-needed-params ~name)
-         needed-params# (num-needed-params comped#)]
+  `(let [comped# (i/comp-paths* ~apath)
+         expected-params# (i/num-needed-params ~name)
+         needed-params# (i/num-needed-params comped#)]
      (if-not (= needed-params# expected-params#)
-       (throw-illegal "Invalid number of params in provided path, expected "
+       (i/throw-illegal "Invalid number of params in provided path, expected "
            expected-params# " but got " needed-params#))
      (def ~(declared-name name)
        (update-in comped#
                   [:transform-fns]
-                  coerce-tfns-rich)
+                  i/coerce-tfns-rich)
        )))
 
 (defmacro extend-protocolpath [protpath & extensions]
-  `(extend-protocolpath* ~protpath ~(protpath-sym protpath) ~(vec extensions)))
+  `(i/extend-protocolpath* ~protpath ~(protpath-sym protpath) ~(vec extensions)))


(defn pathed-path* [builder paths-seq latefns-sym pre-bindings post-bindings impls]
  (let [num-params-sym (gensym "num-params")]
    `(let [paths# (map comp-paths* ~paths-seq)
           needed-params# (map num-needed-params paths#)
           offsets# (cons 0 (reductions + needed-params#))
           any-params-needed?# (->> paths#
                                    (filter params-needed-path?)
                                    empty?
                                    not)
           ~num-params-sym (last offsets#)
           ~latefns-sym (map
                          (fn [o# p#]
                            (if (compiled-path? p#)
                              (fn [params# params-idx#]
                                p# )
                              (fn [params# params-idx#]
                                (bind-params* p# params# (+ params-idx# o#))
                                )))
                          offsets#
                          paths#)

          (defprotocol ~prot-name (~m [structure#]))
          (def ~name
            (if (= ~num-params 0)
              (i/no-params-compiled-path
                (i/->TransformFunctions
                  i/RichPathExecutor
                  (fn ~rargs
                    (let [path# ~retrieve
                          selector# (i/compiled-selector path#)]
                      (selector# ~@rargs)
                      ))
                  (fn ~rargs
                    (let [path# ~retrieve
                          transformer# (i/compiled-transformer path#)]
                      (transformer# ~@rargs)
                      ))))
              (i/->ParamsNeededPath
                (i/->TransformFunctions
                  i/RichPathExecutor
                  (fn ~rargs
                    (let [path# ~retrieve
                          selector# (i/params-needed-selector path#)]
                      (selector# ~@rargs)
                      ))
                  (fn ~rargs
                    (let [path# ~retrieve
                          transformer# (i/params-needed-transformer path#)]
                      (transformer# ~@rargs)
                      )))
                ~num-params
