Динамический обзор в Clojure?

Я ищу идиоматический способ получить динамично ограниченные по объему переменные в Clojure (или подобный эффект) для использования в шаблонах и таком.

Вот проблема в качестве примера с помощью справочной таблицы для перевода атрибутов тега от некоторого формата не-HTML до HTML, где таблице нужен доступ к ряду переменных, предоставленных откуда-либо:

(def *attr-table* 
  ; Key: [attr-key tag-name] or [boolean-function]
  ; Value: [attr-key attr-value] (empty array to ignore)
  ; Context: Variables "tagname", "akey", "aval"
  '(
        ; translate :LINK attribute in  to :href
     [:LINK "a"]    [:href aval]
        ; translate :LINK attribute in  to :src
     [:LINK "img"]  [:src aval]
        ; throw exception if :LINK attribute in any other tag
     [:LINK]        (throw (RuntimeException. (str "No match for " tagname)))
     ; ... more rules
        ; ignore string keys, used for internal bookkeeping
     [(string? akey)] []  )) ; ignore

Я хочу смочь оценить правила (левая сторона), а также результат (правая сторона), и нуждаться в некотором способе поместить переменные в объем в местоположении, где таблица оценена.

Я также хочу сохранить логику поиска и оценки независимой от какой-то конкретной таблицы или набора переменных.

Я предполагаю, что существуют подобные проблемы, вовлеченные в шаблоны (например, для динамического HTML), где Вы не хотите переписывать шаблонную логику обработки каждый раз, когда кто-то помещает новую переменную в шаблон.

Вот один подход с помощью глобальных переменных и привязки. Я включал некоторую логику для поиска по таблице:

;; Generic code, works with any table on the same format.
(defn rule-match? [rule-val test-val]
  "true if a single rule matches a single argument value"
  (cond
    (not (coll? rule-val)) (= rule-val test-val) ; plain value
    (list? rule-val) (eval rule-val) ; function call
    :else false ))

(defn rule-lookup [test-val rule-table]
  "looks up rule match for test-val. Returns result or nil."
  (loop [rules (partition 2 rule-table)]
    (when-not (empty? rules)
      (let [[select result] (first rules)]
        (if (every? #(boolean %) (map rule-match? select test-val))
          (eval result) ; evaluate and return result
          (recur (rest rules)) )))))

;; Code specific to *attr-table*
(def tagname) ; need these globals for the binding in html-attr 
(def akey) 
(def aval) 

(defn html-attr [tagname h-attr]
  "converts to html attributes"
  (apply hash-map
    (flatten 
      (map (fn [[k v :as kv]]
             (binding [tagname tagname akey k aval v]
               (or (rule-lookup [k tagname] *attr-table*) kv)))
        h-attr ))))

;; Testing
(defn test-attr []
  "test conversion"
  (prn "a" (html-attr "a" {:LINK "www.google.com"
                           "internal" 42
                           :title "A link" }))
  (prn "img" (html-attr "img" {:LINK "logo.png" })))

user=> (test-attr)
"a" {:href "www.google.com", :title "A link"}
"img" {:src "logo.png"}

Это хорошо в этом, логика поиска независима от таблицы, таким образом, она может быть снова использована с другими таблицами и различными переменными. (Плюс, конечно, что общий подход таблицы составляет приблизительно четверть размера кода, который я имел, когда я сделал переводы "вручную" в конусовидном гиганте.)

Это не настолько хорошо в этом, я должен объявить, что каждая переменная как глобальное для привязки работает.

Вот другой подход с помощью "полумакроса", функции с заключенным в кавычки из синтаксиса возвращаемым значением, которому не нужен globals:

(defn attr-table [tagname akey aval]
  `(
     [:LINK "a"]   [:href ~aval]
     [:LINK "img"] [:src ~aval]
     [:LINK]       (throw (RuntimeException. (str "No match for " ~tagname)))
     ; ... more rules     
     [(string? ~akey)]        [] )))

Только несколько изменений необходимы к остальной части кода:

In rule-match? The syntax-quoted function call is no longer a list:
- (list? rule-val) (eval rule-val) 
+ (seq? rule-val) (eval rule-val) 

In html-attr:
- (binding [tagname tagname akey k aval v]
- (or (rule-lookup [k tagname] *attr-table*) kv)))
+ (or (rule-lookup [k tagname] (attr-table tagname k v)) kv)))

И мы получаем тот же результат без globals. (И без динамического обзора.)

Есть ли другие альтернативы для проведения наборов привязок переменных, объявленных в другом месте без globals, требуемого Clojure binding?

Есть ли идиоматический способ сделать это, как Ruby binding или JavaScript function.apply(context)?

Обновление

Я, вероятно, делал его слишком сложным, вот то, что я принимаю, более функциональная реализация вышеупомянутого - никакой globals, никакой evals и никакой динамический обзор:

(defn attr-table [akey aval]
  (list
    [:LINK "a"]   [:href aval]
    [:LINK "img"] [:src aval]
    [:LINK]       [:error "No match"]
    [(string? akey)] [] ))

(defn match [rule test-key]
  ; returns rule if test-key matches rule key, nil otherwise.
  (when (every? #(boolean %)
          (map #(or (true? %1) (= %1 %2))
            (first rule) test-key))
    rule))

(defn lookup [key table]
  (let [[hkey hval] (some #(match % key)
                      (partition 2 table)) ]
    (if (= (first hval) :error)
      (let [msg (str (last hval) " at " (pr-str hkey) " for " (pr-str key))]
        (throw (RuntimeException. msg)))
      hval )))

(defn html-attr [tagname h-attr]
  (apply hash-map
    (flatten
      (map (fn [[k v :as kv]]
             (or
               (lookup [k tagname] (attr-table k v))
               kv ))
        h-attr ))))

Эта версия короче, более проста и читает лучше. Таким образом, я предполагаю, что у меня нет потребности в динамическом обзоре по крайней мере еще.

Постскриптум

"Оценивают все, что каждый раз" подход в моем обновлении выше оказался проблематичным, и я не мог выяснить, как реализовать все условные тесты как отправку мультиметода (хотя я думаю, что это должно быть возможно).

Таким образом, я закончил с макросом, который разворачивает таблицу до функции и конусовидного. Это сохраняет гибкость исходной реализации оценки, но более эффективно, берет меньше кодирования и не нуждается в динамическом обзоре:

(deftable html-attr [[akey tagname] aval]
   [:LINK ["a" "link"]] [:href aval]
   [:LINK "img"]        [:src aval]
   [:LINK]              [:ERROR "No match"]
   (string? akey)        [] ))))

расширяется в

(defn html-attr [[akey tagname] aval]
  (cond
    (and 
      (= :LINK akey) 
      (in? ["a" "link"] tagname)) [:href aval]
    (and 
      (= :LINK akey) 
      (= "img" tagname))          [:src aval]
    (= :LINK akey) (let [msg__3235__auto__ (str "No match for "
                                             (pr-str [akey tagname])
                                             " at [:LINK]")]
                     (throw (RuntimeException. msg__3235__auto__)))
    (string? akey) []))

Я не знаю, особенно ли это функционально, но это - конечно, DSLish (сделайте микроязык для упрощения повторяющихся задач), и Lispy (код как данные, данные как код), оба из которых являются ортогональными к тому, чтобы быть функциональным.

По исходному вопросу - как сделать динамический обзор в Clojure - я предполагаю, что ответ становится этим идиоматический Clojure, путь состоит в том, чтобы найти переформулировку, для которой не нужен он.