clojure.core/binding

View this page on ClojureDocs

Type: macro Added: Clojure 1.0 Examples: 12 Runnable: 2

([bindings & body])

binding => var-symbol init-expr

Creates new bindings for the (already-existing) vars, with the supplied initial values, executes the exprs in an implicit do, then re-establishes the bindings that existed before. The new bindings are made in parallel (unlike let); all init-exprs are evaluated before the vars are bound to their new values.

Examples

by kumarshantanu on 2010-08-11 . May have evaluation errors. ▶

;; Here are the definitions. (defn mymax [x y] (min x y)) (defn find-max [x y] (max x y)) (let [max mymax] (find-max 10 20)) 20 ;let is ineffective outside current lexical scope (binding [max mymax] (find-max 10 20)) 10 ;because max is now acting as min

by onlyafly on 2011-11-18 ▶

;; As of Clojure 1.3, vars need to be explicitly marked as ^:dynamic in order for ;; them to be dynamically rebindable: (def ^:dynamic x 1) (def ^:dynamic y 1) (+ x y) 2 ;; Within the scope of the binding, x = 2 and y = 3 (binding [x 2 y 3] (+ x y)) 5 ;; But once you leave the binding's scope, x and y maintain their original ;; bindings: (+ x y) 2

by Claj on 2012-01-12 . May have evaluation errors. ▶

;;Use t like a "template" (declare ^:dynamic t) (defn addt [] (+ t 10)) (binding [t 1] (addt)) => 11

by kimtg on 2015-03-07 . May have evaluation errors. ▶

; You can set! bindings. Useful in a stateful programming. (def ^:dynamic d) #'user/d d #<Unbound Unbound: #'user/d> (binding [d 0] (prn d) (set! d 1) (prn d)) 0 1 nil d #<Unbound Unbound: #'user/d> ; Note that you can't use set! outside of binding [] "stack": (set! d 1) ; => ...Can't change/establish root binding... ; You can use set! anywhere under binding [] "stack", including from lazy sequences: (defn set-d [v] (set! d v)) (binding [d 0] (set-d 1) (prn d)) ;=> 1 (first (binding [d 0] (set-d 1) (repeat d)) ) ;=> 1 ; But NOT from delay/force: (force (binding [d 0] (set-d 1) (delay d)) ) ;=> ...clojure.lang.Var$Unbound...

by kimtg on 2015-03-07 . May have evaluation errors. ▶

; Speed test. recur is the preferred way. (def a (atom 0)) #'user/a (def ^:dynamic b) #'user/b (def d) #'user/d (time (loop [r 0] (when (< r 10000000) (recur (inc r))))) "Elapsed time: 8.062612 msecs" nil (time (dotimes [_ 10000000] (reset! a 1))) "Elapsed time: 93.428704 msecs" nil (time (binding [b 0] (dotimes [_ 10000000] (set! b 1)))) "Elapsed time: 484.331821 msecs" nil (time (with-local-vars [w 0] (dotimes [_ 10000000] (var-set w 1)))) "Elapsed time: 490.598696 msecs" nil (time (dotimes [_ 10000000] (def d 1))) "Elapsed time: 2154.646688 msecs" nil

by coldnew on 2015-10-28 ▶

;; You can modify the variable inside a binding, ;; inside a let, you can't. (def ^:dynamic z) (binding [z nil] (doseq [x (range 4) y (range 4)] (set! z [x y])) z) ; => [3 3] ;; You can modify the variable inside a for, with dorun. (binding [z nil] (dorun (for [x (range 4) y (range 4)] (set! z [x y]))) z) ; => [3 3]

by tizac on 2016-05-23 . May have evaluation errors. ▶

;; from stackoverflow http://stackoverflow.com/questions/1523240/let-vs-binding-in-clojure ;; let creates a lexically scoped immutable alias for some value. ;; binding creates a dynamically scoped binding for some Var. ;; Dynamic binding means that the code inside your binding form and any code ;; which that code calls (even if not in the local lexical scope) will see the new binding. (def ^:dynamic x 0) #'user/x ;; Lexical vs. dynamic binding: (defn foo [] (println x)) #'user/foo (binding [x 1] (foo)) 1 nil (let [x 1] (foo)) 0 nil

by eyelidlessness on 2016-07-12 . May have evaluation errors. ▶

;; Beware usage in ClojureScript around asynchronous calls, as the bound ;; var's original value will be re-established before the async code executes: (def ^:dynamic *foo* nil) (binding [*foo* :bar] (js/setTimeout (fn [] *foo* ;;=> nil )) ;; Also beware *synchronous* usage inside `cljs.test/async`, as the bound ;; var's original value will not be re-established: (ns my-ns (:require [cljs.test :refer-macros [async deftest is]])) (def ^:dynamic *foo* nil) (deftest my-test (async done (binding [*foo* :bar] (done)))) (deftest another-test (async done (is (nil? *foo*)))) ;; FAIL in (another-test) ;; expected: (nil? *foo*) ;; actual: (not (nil? :bar)) ;; At time of writing, the stable ClojureScript version is 1.9.89.

by Hindol on 2019-04-28 . May have evaluation errors. ▶

;; Re-bind `*in*` so that `read-line` reads from a file instead of stdin. ;; Taken from here: https://stackoverflow.com/a/24826485/1019491 (with-open [is (clojure.java.io/reader "/tmp/foo.txt")] (binding [*in* is] (println (read-line))))

by stribb on 2019-08-06 . May have evaluation errors. ▶

;; Seed the random number generator so every invocation comes out the same. (require '[clojure.data.generators :as gen]) (defn not-random-at-all [] (let [wordlist '[one two three four five]] (binding [gen/*rnd* (java.util.Random. 42)] (gen/shuffle wordlist)))) (not-random-at-all) ;; => [two five one three four] (not-random-at-all) ;; => [two five one three four] (not-random-at-all) ;; => [two five one three four]

by PEZ on 2021-04-12 . May have evaluation errors. ▶

;; Beware of lazyness (def ^:dynamic *foo* :FOO) (defn foo [x] [*foo* x]) ;; realized when bindings are reset (binding [*foo* :BAR] (map foo [1 2 3])) => ([:FOO 1] [:FOO 2] [:FOO 3]) ;; force realization while bindings active (binding [*foo* :BAR] (doall (map foo [1 2 3]))) => ([:BAR 1] [:BAR 2] [:BAR 3]) ;; closure `bound-foo` with bindings (binding [*foo* :BAR] (let [bound-foo (bound-fn [x] (foo x))] (map bound-foo [1 2 3]))) => ([:BAR 1] [:BAR 2] [:BAR 3]) ;; more convenient closuring (binding [*foo* :BAR] (let [bound-foo (bound-fn* foo)] (map bound-foo [1 2 3]))) => ([:BAR 1] [:BAR 2] [:BAR 3])

by ertugrulcetin on 2025-03-10 . May have evaluation errors. ▶

In ClojureScript, binding won’t work for event handler callbacks. (binding [*scene* scene] (js/console.log *scene*) (js/setTimeout (fn [] (println "Callback here!") ;; THIS WILL PRINT undefined! (js/console.log *scene*)) 2000))

Note by fordsfords

The first example (binding mymax to max) appears to be broken. The last line generates the error:

  IllegalStateException Can't dynamically bind non-dynamic var: clojure.core/max

I tried inserting (.setDynamic #'max) at the top, and it got rid of the error, but the binding didn't seem to actually happen. I.e. the last line prints 20.

The only way I could get it to work is by redefining max from scratch as dynamic:

(defn ^:dynamic max
  ([x] x)
  ([x y] (. clojure.lang.Numbers (max x y)))
  ([x y & more]
   (reduce max (max x y) more)))

After THIS the first example succeeds.

The moral of the story - I guess you can't easily bind built-in functions. You need to write your functions with the intention of them being bindable. And I guess the first example should simply be removed?

Note by NeedMoreDesu

So about first example --

(defn find-max [x y]
  (max x y)) ;; => #'user/find-max
(binding [max clojure.core/min]
  (find-max 10 20)) ;; Can't dynamically bind non-dynamic var: clojure.core/max
(def ^:dynamic max clojure.core/max)
(binding [max clojure.core/min]
  (find-max 10 20)) ;; => 20
(defn find-max [x y]
  (max x y)) ;; => #'user/find-max
(binding [max clojure.core/min]
  (find-max 10 20)) ;; => 10

Long story short: var needs to be defined ^:dynamic before you create your function with var being bound here, or else no dynamic building occur (which is intended behavior, I guess).

Note by finalfantasia

There's a great blog post from Chas Emerick about binding, Be Mindful of Clojure's binding, that discusses two common pitfalls that one can fall into when using binding.

See also

• clojure.core/with-redefs (1)
• clojure.core/with-bindings
• clojure.core/with-local-vars (0)
• clojure.core/def (4)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.