             (every? vector? rule-expression)) (let [nested-expr (create-let-expression
                                                                   input
                                                                   rule-expression
-                                                                  body-creation-fn
+                                                                  out-format-fn
                                                                   output
                                                                   (inc nesting-level))]
                                                 (conj v (prefix-rule-name rule-name nesting-level) nested-expr))

(declare create-proc-fn)

(defn- create-bindings-vector
  [input rules body-creation-fn output nesting-level]
  (reduce
    (fn [v rule]
      (let [rule-name (first rule)

                                                                                    (create-let-expression
                                                                                      input
                                                                                      v
                                                                                      out-format-fn
                                                                                      output
                                                                                      (inc nesting-level)))
                                                                  :default (do
