标签: lexical-scope

我认为答案是肯定的,但我只是想确定一下.所以,如果我有

sub something {
    my $_;
    my @array = ...;
    while ( @array ) {
        say;
    }
}

是否my $_;实际上有效地将传递给参数的参数词汇化？

在这个特殊的情况下,我正在使用DZP :: UnusedVarsTests,它抱怨我没有使用过my $_;,我怀疑它是一个bug,因为我在它隐含的情况下使用它.

在lisp中我可以绑定绑定在这样的闭包中的自由变量......

(let ((x 1) (y 2) (z 3))
  (defun free-variables () (+ x y z)))

(free-variables)

结果是 ...

6

我想知道的是,是否可以动态检查绑定闭包变量？

例如

(inspect-closure free-variables)

导致类似......

((x 1) (y 2) (z 3))

谢谢你

以下emacs lisp文件是关于当Alice foo在她的init文件中使用词法绑定的局部变量并且Bob 在他的init文件中定义foo为全局特殊变量defvar并且Alice将Bob的init文件代码的一部分借入她自己的init文件时发生的事情.知道这foo会变得特别.

;; -*- lexical-binding: t; -*-
;; Alice init file

;; Alice defining alice-multiplier
(defun alice-multiplier-1 (foo)
  (lambda (n) (* n foo)))
(defun alice-multiplier-2 (num)
  (let ((foo num))
    (lambda (n) (* n foo))))

;; Alice using alice-multiplier
(print
 (list
  :R1 (mapcar (alice-multiplier-1 10) (list 1 2 3))
  :R2 (mapcar (alice-multiplier-2 10) (list 1 2 3))))

;; from Bob's code
;; ...    
(defvar foo 1000)
;; ...

;; Alice using alice-multiplier …

所以我有这个问题,我必须使用两个不同的范围规则来计算输出.我知道用词汇范围输出a=3和b=1,但我使用动态范围界定有很难弄清楚输出.
_{注意:下面的代码示例使用C语法,但我们只是将其视为伪代码.}

int a,b;

int p() {
    int a, p;
    a = 0; b = 1; p = 2;
    return p;
}

void print() {
    printf("%d\n%d\n",a,b);
}

void q () {
    int b;
    a = 3; b = 4;
    print();
}

main() {
    a = p();
    q();
}

这是我想出来的.使用动态范围,非本地引用a和b可以更改.所以我有a=2(从p()返回,然后b=4(在q()内).那么输出是2 4？

我从来没有能够提出一种方法来通过函数开始时定义的set-process-sentinel let-bound变量来渗透层次结构- 只有缓冲区局部或全局变量可以穿透它.允许绑定变量可以达到第一个,但是只要它们可以穿透而不会因为被识别而被拒绝 - 在函数开始时定义的 let-bound变量似乎无法穿透开始的部分与.任何人都可以想到一种方法,包括穿透嵌套的哨兵,如下例所示？start-process(lambda (p e) . . .

(set-process-sentinel 
  (start-process
    "my-process-name-one"
     "*OUTPUT-BUFFER*"
    "/path/to/executable"
    "argument-one"
    "argument-two"
    "argument-three")
  (lambda (p e) (when (= 0 (process-exit-status p))
    (set-process-sentinel 
      (start-process
        "my-process-name-two"
        nil ;; example of not using an output buffer
        "/path/to/executable"
        "argument-one"
        "argument-two"
        "argument-three")
      (lambda (p e) (when (= 0 (process-exit-status p))
        (set-process-sentinel 
          (start-process . . . ))))))))

function buildList( list ) {
  var i      = 0;
  var first  = function () {
    console.log( "in" )
    console.log( i );
  }
  var Second = function () {
    console.log( "out" )
    first();
  }
  return Second;
}

var a = buildList( [1, 2, 3] )
console.dir( a );

a(); // Here closure is created which has function first ,Here first also has one closure of itself that means recursive closure

当我在Chrome中看到我的控制台时,它有一个闭包,它首先有一个函数,它本身就有一个闭包,即它有关闭时自身功能的重复循环,有没有人知道这里发生了什么,我很困惑,为什么有infinte闭环

这是一个很长的标题，但恐怕我不能在不失去问题的真正含义的情况下说出一个字。我将首先简要描述我要实现的目标，然后长篇大论我为什么要这样做。如果您打算直接回答问题标题，请跳过漫谈:-)

快速描述

假设有一个lexicalize内置函数可以满足我的要求，这里是：

package Whatever;
{
  lexicalize $Other::Package::var;
  local $var = 42;
  Other::Package->do_stuff; # depends on that variable internally
}

为什么和为什么不

对于一些上下文，我正在对第三方模块进行白盒测试。

我希望变量本地化，因为我希望它只在有限的时间内更改，然后再进行其他测试。 local是我发现的最好的方法，而不依赖于知道模块对初始值的选择。

我想要一个词法绑定有两个主要原因：

1. 我不想污染测试文件的更高级别的命名空间。
2. 我想要比完全限定名称更短的名称。为简洁起见，它不在示例代码中，但我使用的标识符比显示的要多得多，计算和更新相对于其先前的值。

我不能体面地使用，our因为它不会从另一个包中获取变量：““我们的”中的变量 $Other::Package::var 不允许使用包名称。” 作弊暂时进入 Other::Package 的范围并不会削减它：如果我使用块 ( { package Other::Package; our $var }) 则绑定不会持续足够长的时间而无法使用；如果我不这样做 ( package Other::Package; our @var; package main) 那么我需要知道并复制前一个包的名称，这样可以防止过多地移动那段代码。

在问这个问题的先前形式之前做功课时，我发现Lexical::Var，这似乎正是我所需要的。唉：“无法通过参考进行本地化。”

我也尽了最大的努力来处理my *var基于 -based 的形式的直觉，但一直遇到语法错误。我今天学到的关于范围和绑定的知识比我关心的要多:-)

我想不出为什么我想要的东西不可能实现的原因，但我找不到正确的咒语。我是在要求一个不幸的未实现的边缘案例吗？

" Google Common Lisp样式指南 "的"全局变量和常量"部分中说明:

"Common Lisp没有全局词法变量,因此使用命名约定来确保动态绑定的全局变量从不具有与局部变量重叠的名称.

可以使用不同命名的全局变量和DEFINE-SYMBOL-MACRO伪造全局词法变量.你不应该使用这个技巧,除非你首先发布一个抽象它的库."

请有人帮助我理解最后一句话的含义.

我是R的新手,当我阅读手册时,我遇到了一个关于词法范围的段落以及这个代码示例:

 open.account <- function(total) {
   list(
     deposit = function(amount) {
       if(amount <= 0)
         stop("Deposits must be positive!\n")
       total <<- total + amount
       cat(amount, "deposited.  Your balance is", total, "\n\n")
     },
     withdraw = function(amount) {
       if(amount > total)
         stop("You don't have that much money!\n")
       total <<- total - amount
       cat(amount, "withdrawn.  Your balance is", total, "\n\n")
     },
     balance = function() {
       cat("Your balance is", total, "\n\n")
     }
   )
 }

 ross <- open.account(100)
 robert <- open.account(200)

 ross$withdraw(30)
 ross$balance()
 robert$balance()

 ross$deposit(50)
 ross$balance()
 ross$withdraw(500) …

似乎很常见,根据源代码中的位置,可以在编译时(或通过静态分析器,因为我的示例在Python中)访问词法范围.

这是一个非常简单的例子,其中一个函数有两个具有不同值的闭包a.

def elvis(a):
  def f(s):
    return a + ' for the ' + s
  return f

f1 = elvis('one')
f2 = elvis('two')
print f1('money'), f2('show')

我没有问题,当我们读取函数的代码f时,当我们看到a它没有定义时f,所以我们弹出封闭函数并在那里找到一个,这就是ain f所指的.源代码中的位置足以告诉我从封闭范围f获取值a.

但作为描述在这里,当一个函数被调用时,它的本地帧扩展其父环境.因此,在运行时进行环境查找是没有问题的.但我不确定的是,静态分析器总能确定在编译时,在代码运行之前引用哪个闭包.在上面的例子中,很明显elvis有两个闭包,很容易跟踪它们,但其他情况不会那么简单.直觉上,我很担心静态分析的尝试一般会遇到停顿问题.

那么词法作用域确实具有动态方面,源代码中的位置告诉我们涉及一个封闭的范围,但不一定涉及哪个封闭？或者这是编译器中解决的问题,并且函数内的所有引用都可以通过静态详细解决？

或者答案取决于编程语言 - 在这种情况下,词法范围并不像我想象的那么强大？

[编辑@评论:

就我的例子而言,我可以重申一下我的问题:我读过诸如"可以在编译时确定词法解析"这样的说法,但是想知道如何在编译时(通常)静态地计算ain f1和in 的值f2.

解决方案是,词汇范围并没有那么多.LS可以告诉我们,在编译时,每当我进入时都会定义一个被调用的东西(这显然可以静态地解决;这是词法范围的定义),但确定它实际需要什么值(或者,哪个闭包) (1)超出LS概念,2)在运行时完成(非静态),因此在某种意义上是动态的,当然3)使用与动态范围不同的规则.af

引用@PatrickMaupin的内容消息是"仍有一些动态的工作要做." ]