Обзор правил в Clojure

let затеняет верхний уровень Var x с локальным x . let не создает Var и не влияет на Var верхнего уровня; он связывает некоторый символ, так что локальные ссылки на этот символ будут заменены значением let -bound. let имеет лексическую область видимости, поэтому его привязки видны только в самой форме let (не в функциях, вызываемых из let ).

binding временно (локально в потоке) изменяет значение верхнего уровня Var x , вот и все, что он делает. Если привязка let установлена, привязка привязка не видит ее при принятии решения, какое значение следует изменить (и привязки let не являются переменными и не являются изменяемый, так что "хорошо или это" d выдает ошибку). И привязка не будет маскировать let . привязка имеет динамическую область видимости, поэтому ее влияние на Vars верхнего уровня видно в форме привязки и в любой функции, которая вызывается из формы привязки .

] Доступ к значению простого старого x даст вам все, что находится наверху стека привязок, либо самое вложенное значение let -bound x (или параметр функции с именем x , или какое-то значение x заменяется на, если вы используете свой собственный макрос, или другие возможности.), и использует только текущее значение верхнего уровня Var x по умолчанию, если нет другой привязки.

Даже если верхний уровень Var x замаскирован let -bound x , вы всегда можете получить доступ к верхнему уровню Var через @ # ' х . Попробуйте эту версию, может быть, она будет более понятной:

(def x 1)

(defn dummy-fn2[]
  (println "x from dummy-fn2:" x)
  (+ x 1))  

(defn dummy-fn[]
  (println "entering function:" x)
  (println "var x:" @#'x)
  (dummy-fn2)
  (println "---")
  (let [x 100]
    (println "after let:" x)
    (println "var x:" @#'x)
    (dummy-fn2)
    (println "---")
    (let [x (dummy-fn2)]
      (println "after let and dummy-fn2:" x)
      (println "var x:" @#'x)
      (dummy-fn2)
      (println "---")
      (binding [x 888]
        (println "after binding:" x)
        (println "var x:" @#'x)
        (dummy-fn2)
        (println "---")
        (let [x (dummy-fn2)]
          (println "after binding and dummy2:" x)
          (println "var x:" @#'x)
          (dummy-fn2)
          (println "---"))))))

Дает:

entering function: 1
var x: 1
x from dummy-fn2: 1
---
after let: 100
var x: 1
x from dummy-fn2: 1
---
x from dummy-fn2: 1
after let and dummy-fn2: 2
var x: 1
x from dummy-fn2: 1
---
after binding: 2
var x: 888
x from dummy-fn2: 888
---
x from dummy-fn2: 888
after binding and dummy2: 889
var x: 888
x from dummy-fn2: 888
---

Clojure использует как лексическую область видимости let для символов, так и привязку динамической области для переменных ознакомьтесь с документацией clojure vars .

• "функция входа" : пока все хорошо! символ x преобразуется в var, и это захватывает «корневую привязку» переменной x.
• «после let» : локальная привязка закрывает переменную, символ x теперь равен 100, а не var.
• "после let и dummy2" : x в dummy-fn2 относится к переменной x, поэтому он использует корневую привязку x и возвращает на единицу больше (+ 1 1)
• "после привязки ": хитрый! привязка динамически заменяет корневую привязку переменной с именем x (которая была 1) на 100, но локальный символ x больше не является переменной, поэтому вы получаете локальную привязку.
• "после привязки и dummy2" : привязка заменила корневое значение переменной x на 100, и это вернуло на единицу больше, чем это (+ 100 1)