cierre y ^:dinámico

I tried to understand dynamic variables and binding function so I tried this (clojure 1.3):

user=> (defn f [] 
           (def ^:dynamic x 5) 
           (defn g [] (println x)) 
           (defn h [] (binding [x 3] (g))) 
user=> (f)     

Confused, I tried this somewhat simpler code:

user=> (def ^:dynamic y 5)
user=> (defn g [] (println y))
user=> (defn h [] (binding [y 3] (g)))
user=> (h)

What is the difference between the two pieces of code? Why does the second example work but the first does not?

Hint: I just realized that the following works (still don't fully understand why):

user=> (def ^:dynamic y 5)
user=> (defn f [] (defn g [] (println y)) (defn h [] (binding [y 3] (g))) (h))
user=> (f)

preguntado el 30 de julio de 12 a las 23:07

1 Respuestas

I get 3 as a result (as you would expect) when I run your first example in Clojure 1.4.... have you tried this with a fresh REPL?

^:dynamic is an instruction to the Clojure compiler that a symbol (as defined with def) is intended to be dynamically rebound (with binding).


(def foo 1)
(binding [foo 2] foo)
=> IllegalStateException Can't dynamically bind non-dynamic var: ...

(def ^:dynamic bar 10)
(binding [bar 20] bar)    ;; dynamically bind bar within the scope of the binding
=> 20
bar                       ;; check underlying value of bar (outside the binding)
=> 10

Tenga en cuenta que binding has dynamic scope within the calling thread - any functions called within the binding will see the modified value of bar (20), but any other threads will still see the unchanged root value of 10.

Finally a couple of style points that you may find helpful:

  • It's generally considered bad idea to put def y defn within functions as they affect the enclosing namespace. Within functions you should use (let [foo bar] ...) preferiblemente.
  • When you find yourself wanting to use binding you should normally consider whether you can achieve the same result using higher order functions instead. binding is useful in some contexts but it is not in general a good way to pass parameters around - function composition is usually better in the long run. The reason for this is that binding creates an implicit context that is required for the execution of your function and this can be difficult to test/debug.

Respondido 07 Oct 17, 20:10

I understand pros/cons of binding. I also realize the first code example is unusual clojure code. What I didn't understand is why it didn't work (with 1.3, fresh repl). - Kevin

I'm having trouble seeing when you'd ever want binding! It looks anathema to the functional way. What am I missing ? - Hendecágono

@Hendekagon - probably deserves a SO question in its own right. But I have found it useful as an extra way of passing round context while debugging / working at the REPL - if you did this in a purely functional way then you would need to thread new parameters all the way through a (potentially very long) call graph. - mikera

I tried this in 1.4, and it works (as expected), and retried it in 1.3 and it fails. I can only conclude there was some bug in 1.3 that's been since fixed. - Kevin

@ Kevin ^:dynamic was not yet part of the language as of 1.3 -- so no, not a bug, just not something that existed yet; at that time, dynamic vars were named with *barbells* as more than just convention. - Carlos Duffy

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.