标签: dynamic-scope

我一直试图让我的头围绕浅层绑定和深层绑定,维基百科并没有很好地解释它.假设我有以下代码,如果语言使用动态范围,输出将是什么

a)深度约束

b)浅层绑定？

x: integer := 1
y: integer := 2

procedure add
  x := x + y

procedure second(P:procedure)
  x:integer := 2
  P()

procedure first
  y:integer := 3
  second(add)

----main starts here---
first()
write_integer(x)

我已经了解到静态作用域是唯一理智的做事方式,而动态作用域是魔鬼的工具,而且只是由于解释器/编译器的不良实现.

然后我从Common Lisp vs. Scheme文章中看到了这个片段:

Both Lexically and Dynamically    Lexical scope only, per the standard.
scoped special vars.  Common      Dynamically scoped vars are provided
Lisp just wins on this point.     by some implementations as an extension
                                  but code using them is not portable.

     (I have heard the arguments about whether Dynamic scoping
      is or is not a Bad Idea in the first place.  I don't care. 
      I'm just noting that you can do things …

clojure.core具有宏绑定和with-redefs.看看关于clojuredocs.org的文档字符串和示例,它们似乎做了非常相似的事情.有什么区别,我应该在哪些情况下使用哪一个？

JavaScript具有词法作用域,这意味着从函数内访问的非局部变量将被解析为定义时该函数的父项范围内存在的变量.这与动态范围形成对比,在动态范围中,从函数内访问的非局部变量在被调用时被解析为该函数的调用范围中存在的变量.

x=1
function g () { echo $x ; x=2 ; }
function f () { local x=3 ; g ; }
f # does this print 1, or 3?
echo $x # does this print 1, or 2?

上面的程序以词法范围的语言打印1然后打印2,并以动态范围的语言打印3然后打印1.由于JavaScript是词法范围的,它将打印1然后2,如下所示:

var print = x => console.log(x);

var x = 1;

function g() {
    print(x);
    x = 2;
}

function f() {
    var x = 3;
    g();
}

f();           // prints 1

print(x);      // prints 2

虽然JavaScript不支持动态范围,但我们可以使用eval以下方法实现它:

var print …

我试着理解动态变量和绑定函数,所以我尝试了这个(clojure 1.3):

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

困惑,我尝试了这个稍微简单的代码:

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

这两段代码有什么区别？为什么第二个例子有效但第一个没有？

提示:我刚刚意识到以下工作(仍然不完全理解为什么):

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

Emacs 24现在具有词法范围的变量.当然,它还具有动态范围的变量.既然它有两者,我很困惑变量什么时候会有哪种范围.有一个lexical-binding变量控制何时启用词法绑定,我想我defvar现在读到一些关于动态范围变量的声明,但总的来说我很丢失.在Emacs 24的新范围规则中,是否有一个很好的解释？换句话说,当我查看为Emacs 24编写的Emacs Lisp代码中的变量时,如何判断变量使用的范围？

我正在将一些代码从lisp转换为Python.

在lisp中,您可以使用let构造,其中引入的变量声明为特殊,因此具有动态范围.(见http://en.wikipedia.org/wiki/Dynamic_scope#Dynamic_scoping)

我怎样才能在Python中做同样的事情？看来语言不直接支持这个,如果是真的,那么什么是模仿它的好方法呢？

在SICP的3.2.2节中执行以下代码

(define (square x)
  (* x x))
(define (sum-of-squares x y)
  (+ (square x) (square y)))
(define (f a)
  (sum-of-squares (+ a 1) (* a 2)))

(f 5)

根据该图解释.

每次应用函数时,都会创建一个新帧(标记为E1through E4),表示符号和值之间的一组绑定.当符号未绑定在框架中时,将查询该框架的封闭环境以查找该特定符号的绑定.

该图的有趣之处在于标记的所有帧E都包含在全局环境中.该文本解释说这是因为函数是在全局环境中定义的,但没有详细说明问题:

请注意,每个帧都由square指向全局环境创建,因为这是square过程对象指示的环境.

相反,如果框架包含在调用函数的环境中,比如E3包含在E2其中E1,那么它是否是动态作用域语言如何工作的有效模型？此外,图中的框架具有相同的"父"环境的方式是因为Scheme是词法范围的吗？

我现在正在从参考手册和LISP Book中的Common Lisp 学习Emacs Lisp .

来自Common Lisp的书

>> (setf power-of-two
     (let ((previous-power-of-two 1))
       #'(lambda ()
           (setf previous-power-of-two
             (* previous-power-of-two 2)))))

>> (funcall power-of-two)
2

>> (funcall power-of-two)
4

>> (funcall power-of-two)
8

由于其动态绑定行为,该函数在Emacs Lisp中不起作用.

我想知道是否可以在不引入全局变量的情况下在Emacs Lisp中实现相同的功能？

我想在循环中重新绑定一个特殊变量.现在,通常,这是使用a完成的let.

(let ((*read-eval* nil))
  (do-something-here))

但由于loop宏有这些好的with条款,我想我可能会在那里这样做.表达式(macroexpand '(loop with *read-eval* = nil))最终将绑定扩展为a let,因此它肯定会对我的实现有所帮助.但我在标准中找不到任何表明这是标准化行为的内容.所以,我想,我的问题是:

(loop with *read-eval* = nil
      for i from 1 to 10
      do (something-involving-the-read-function))

是否需要符合实现来修改现有*read-eval*变量,或者是否存在可能创建同名新词法变量的风险？