blocks|key|3339864|text|在维基上有一篇很有描述性的文章，叫做Funarg+problem|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3339865|3339866|“向下的函数也可以指函数在实际执行时的状态。但是，由于根据定义，向下的函数的存在包含在创建它的函数的执行中，因此函数的激活记录通常仍然可以存储在堆栈上。”|blockquote|3339867|3339868|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Funarg_problem^0|I|E|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|V|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

There's a pretty descriptive article on Wiki called <a href="http://en.wikipedia.org/wiki/Funarg_problem" rel="noreferrer">Funarg problem</a>

<blockquote>
 "A downwards funarg may also refer to
 a function's state when that function
 is not actually executing. However,
 because, by definition, the existence
 of a downwards funarg is contained in
 the execution of the function that
 creates it, the activation record for
 the function can usually still be
 stored on the stack."
</blockquote>

blocks|key|3339881|text|向下函数是不返回或离开其声明作用域的局部函数。它们只能从当前作用域向下传递到其他函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3339882|两个例子。这是一个向下的funarg：|3339883|function+()+{
++++var+a+=+42;
++++var+f+=+function+()+{+return+a+%2B+1;+}
++++foo(f);+//+`foo`+is+a+function+declared+somewhere+else.
}|code-block|syntax|javascript|3339884|而这不是：|3339885|function+()+{
++++var+a+=+42;
++++var+f+=+function+()+{+return+a+%2B+1;+}
++++return+f;
}|3339886|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Downward funargs are local functions that are not returned or otherwise leave their declaration scope. They only can be passed downwards to other functions from the current scope.

Two examples. This is a downward funarg:

<pre class="lang-js prettyprint-override"><code>function () {
 var a = 42;
 var f = function () { return a + 1; }
 foo(f); // `foo` is a function declared somewhere else.
}
</code></pre>

While this is not:

<pre class="lang-js prettyprint-override"><code>function () {
 var a = 42;
 var f = function () { return a + 1; }
 return f;
}
</code></pre>

blocks|key|348626|text|在Common+Lisp中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|348627|(let+((a+3))
++(mapcar+(lambda+(b)+(%2B+a+b))
++++++++++(list+1+2+3+4)))

->++(4+5+6+7)|code-block|syntax|javascript|348628|在上面的形式中，lambda函数向下传递。当被高阶函数MAPCAR调用时(该函数获取一个函数和一个值列表作为参数，然后将该函数应用于列表中的每个元素并返回结果列表)，lambda函数仍然引用LET表达式中的变量'a‘。但这一切都发生在LET表达式中。|348629|将以上内容与此版本进行比较：|348630|(mapcar+(let+((a+3))
++++++++++(lambda+(b)+(%2B+a+b)))
++++++++(list+1+2+3+4))|348631|这里的lambda函数是从LET返回的。往上一点。然后将其传递给MAPCAR。当MAPCAR调用lambda函数时，它周围的LET不再执行-函数仍然需要引用LET中的变量'a‘。|348632|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In Common Lisp:

<pre><code>(let ((a 3))
 (mapcar (lambda (b) (+ a b))
 (list 1 2 3 4)))

-&gt; (4 5 6 7)
</code></pre>

In above form the lambda function is passed DOWNWARD. When called by the higher-order function MAPCAR (which gets a function and a list of values as arguments, and then applies the function to each element of the list and returns a list of the results), the lambda function still refers to the variable 'a' from the LET expression. But it happens all within the LET expression.

Compare above with this version:

<pre><code>(mapcar (let ((a 3))
 (lambda (b) (+ a b)))
 (list 1 2 3 4))
</code></pre>

Here the lambda function is returned from the LET. UPWARD a bit. It then gets passed to the MAPCAR. When MAPCAR calls the lambda function, its surrounding LET is no longer executing - still the function needs to reference the variable 'a' from the LET.

<a href="http://en.wikipedia.org/wiki/Jwz" rel="noreferrer">Jamie Zawinski</a> uses that term in his (1997) <a href="http://www.jwz.org/doc/java.html" rel="noreferrer">article &quot;java sucks&quot;</a> as if you should know what it means:
<blockquote>
I really hate the lack of downward-funargs; anonymous classes are a lame substitute. (I can live without long-lived closures, but I find lack of function pointers a huge pain.)
</blockquote>
It seems to be Lisper's slang, and I could find the following brief definition <a href="http://www.delorie.com/gnu/docs/emacs/cl_21.html" rel="noreferrer">here</a>, but somehow, I think I still don't get it:
<blockquote>
Many closures are used only during the extent of the bindings they refer to; these are known as &quot;downward funargs&quot; in Lisp parlance.
</blockquote>
Were it not for <a href="http://steve-yegge.blogspot.com/" rel="noreferrer">Steve Yegge</a>, I'd just feel stupid now, but it seems, it might be OK to ask:
<blockquote>
Jamie Zawinski is a hero. A living legend. [...] A guy who can use the term &quot;downward funargs&quot; and then glare at you just daring you to ask him to explain it, you cretin.
-- <a href="http://steve-yegge.blogspot.com/2008/04/xemacs-is-dead-long-live-xemacs.html" rel="noreferrer">XEmacs is dead, long live XEmacs</a>
</blockquote>
So is there a Lisper here who can compile this for C-style-programmers like me?

What are "downward funargs"?

在他的(1997) 中使用了这个术语，好像你应该知道它的意思：我真的讨厌缺少向下的乐趣；匿名类是一个蹩脚的替代品。(我可以不使用长时间的闭包，但我发现缺少函数指针是一个巨大的痛苦。)这似乎是Lisper的俗语，我可以找到以下简短的定义，但不知何故，我想我仍然不明白：许多闭包仅在它们引用的绑定范围内使用；在Lisp语言中...

问什么是“向下funargs"？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是“向下funargs"？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是“向下funargs"？
EN