Hi,
I'm looking for an idiomatic way to get dynamically scoped
variables in Clojure (or a similar effect) for use in templates and such.
Here is an example problem using a lookup table to translate tag attributes from some non-HTML format to HTML, where the table needs access to a set of
variables supplied from elsewhere:
(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 <a> to :href
[:LINK "a"] [:href aval]
; translate :LINK attribute in <img> 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
I want to be able to evaluate the rules (left hand side) as well as the result (right hand side), and need some way to put the
variables in scope at the location where the table is evaluated.
I also want to keep the lookup and evaluation logic independent of any particular table or set of
variables.
I suppose there are similar issues involved in templates (for example for
dynamic HTML), where you don't want to rewrite the template processing logic every time someone puts a new variable in a template.
Here is one approach using global
variables and bindings. I have included some logic for the table lookup:
;; 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 ))))
(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"}
This is nice in that the lookup logic is independent of the table, so it can be reused with other tables and different
variables. (Plus of course that the general table approach is about a quarter of the size of the code I had when I did the translations "by hand" in a giant cond.)
It is not so nice in that I need to declare every variable as a global for the binding to work.
Here is another approach using a "semi-macro", a function with a syntax-quoted return value, that doesn't need 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)] [] )))
Only a couple of changes are needed to the rest of the code:
In rule-match?, when syntax-quoted the 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)))
And we get the same result without globals. (And without
dynamic scoping.)
Are there other alternatives to pass along sets of variable bindings declared elsewhere, without the globals required by Clojure's binding?
Is there an idiomatic way of doing it, like Ruby's binding
or Javascript's function.apply(context)?
