blocks|key|826925|text|CLISP实现了一个扩展来评估词法环境中的形式。从它是一个扩展的事实来看，我怀疑你不能以一种符合标准的方式做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|826926|(ext:eval-env+x+(ext:the-environment))|code-block|syntax|javascript|826927|参见http://clisp.cons.org/impnotes.html#eval-environ。|offset|length|826928|entityMap|0|LINK|mutability|MUTABLE|url|http://clisp.cons.org/impnotes.html#eval-environ^0|0|0|2|1C|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

CLISP implements an extension to evaluate a form in the lexical environment. From the fact that it is an extension, I suspect you can't do that in a standard-compliant way.

<pre><code>(ext:eval-env x (ext:the-environment))
</code></pre>

See <a href="http://clisp.cons.org/impnotes.html#eval-environ" rel="nofollow noreferrer">http://clisp.cons.org/impnotes.html#eval-environ</a>.

blocks|key|3994045|text|在Common+Lisp中，您可以定义允许您向(eval+...)传递环境的*evalhook*。*evalhook*是独立于平台的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3994046|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cvc.uab.es/~javier/CrossVisions/Help/FrameTopic487.html^0|N|A|1D|A|12|A|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

In Common Lisp you can define <a href="http://www.cvc.uab.es/~javier/CrossVisions/Help/FrameTopic487.html" rel="nofollow noreferrer">*evalhook*</a> Which allows you to pass an environment to <code>(eval ...)</code>. <code>*evalhook*</code> is platform independent.

blocks|key|3148547|text|你想解决的实际问题是什么？最有可能的是，您试图以错误的方式处理它。词法绑定是针对在其作用域内以词法出现的内容，而不是针对从外部获得的随机内容。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3148548|也许你想要一个动态闭包？这样的东西在Common+Lisp中是不存在的，尽管在一些Lisp方言中是存在的(就我所知，像Pico+Lisp+)。|3148549|请注意，您可以执行以下操作，这与此类似：|3148550|(defvar+*a*)
(defvar+*x*+'(%2B+*a*+2))++;'

(let+((a+10))
++;;+...
++(let+((*a*+a))
++++(eval+*x*)))|code-block|syntax|javascript|3148551|不过，我建议你认真考虑一下你是否真的想这样做。|3148552|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|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

What is the actual problem that you want to solve? Most likely, you're trying to tackle it the wrong way. Lexical bindings are for things that appear lexically within their scope, not for random stuff you get from outside.

Maybe you want a dynamic closure? Such a thing doesn't exist in Common Lisp, although it does in some Lisp dialects (like Pico Lisp, as far as I understand).

Note that you can do the following, which is similar:

<pre><code>(defvar *a*)
(defvar *x* '(+ *a* 2)) ;'

(let ((a 10))
 ;; ...
 (let ((*a* a))
 (eval *x*)))
</code></pre>

I advise you to think hard about whether you really want this, though.

blocks|key|827339|text|您需要创建具有必要绑定的代码。用字母括起你的代码，并绑定你想要在你的代码中可用的每个变量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827340|(defvar+*x*+'(%2B+a+2))

(let+((a+4))
++(eval+`(let+((a+,a))
+++++++++++,*x*)))|code-block|syntax|javascript|827341|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You need to create code that has the necessary bindings. Wrap a LET around your code and bind every variable you want to make available in your code:

<pre><code>(defvar *x* '(+ a 2))

(let ((a 4))
 (eval `(let ((a ,a))
 ,*x*)))
</code></pre>

blocks|key|5404414|text|可以使用COMPILE将表达式编译成函数，然后使用PROGV在动态设置变量的环境中对编译后的函数执行FUNCALL。或者，更好的方法是使用COMPILE将表达式编译成接受变量的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5404415|Compile接受列表形式的函数定义，并将其转换为函数。在使用SBCL的情况下，此函数被编译为机器码，并将有效地执行。|5404416|第一个选项(使用编译和进度)：|5404417|(defvar+*fn*+(compile+nil+'(lambda+()+(%2B+a+2)))
(progv+'(a)+'(4)+(funcall+*fn*))
=>
6|code-block|syntax|javascript|5404418|第二个选项：|5404419|(defvar+*fn*+(compile+nil+'(lambda+(a)+(%2B+a+2))))
(funcall+*fn*+4)
=>
6|5404420|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|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

It is possible to use COMPILE to compile the expression into function and then use PROGV to FUNCALL the compiled function in the environment where variables are dynamically set. Or, better, use COMPILE to compile the expression into function that accepts variables.

Compile accepts the function definition as a list and turns it into function. In case of SBCL, this function is compiled into machine code and will execute efficiently.

First option (using compile and progv):

<pre><code>(defvar *fn* (compile nil '(lambda () (+ a 2)))
(progv '(a) '(4) (funcall *fn*))
=&gt;
6
</code></pre>

Second option:

<pre><code>(defvar *fn* (compile nil '(lambda (a) (+ a 2))))
(funcall *fn* 4)
=&gt;
6
</code></pre>

I have an s-expression bound to a variable in Common Lisp:

<pre><code>(defvar x '(+ a 2))
</code></pre>

Now I want to create a function that when called, evaluates the expression in the scope in which it was defined. I've tried this:

<pre><code>(let ((a 4))
 (lambda () (eval x)))
</code></pre>

and

<pre><code>(let ((a 4))
 (eval `(lambda () ,x)))
</code></pre>

But both of these create a problem: EVAL will evaluate the code at the top level, so I can't capture variables contained in the expression. Note that I cannot put the LET form in the EVAL. Is there any solution?

EDIT: So if there is not solution to the EVAL problem, how else can it be done?

EDIT: There was a question about what exactly I am try to do. I am writing a compiler. I want to accept an s-expression with variables closed in the lexical environment where the expression is defined. It may indeed be better to write it as a macro.

Creating a lambda from an s-expression

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个s表达式绑定到Common Lisp中的一个变量：(defvar x '(+ a 2))现在我想创建一个函数，当调用它时，在定义它的作用域中计算表达式的值。我试过了：(let ((a 4))  (lambda () (eval x)))和(let ((a 4))  (eval `(lambda () ,x)))...

问从s表达式创建lambda
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从s表达式创建lambdaEN