[原创]极致之美——百行代码实现全新智能语言！

月影

首先要解释一下：


“极致之美”不是说月儿的这篇文章，因为本人还没有自大到这种程度:P，它形容的是Lisp和javascript结合的优美形态。

本来以下内容是要在无优首发的，但是不巧完成文章的当天忽然发现无优“弹”了，直到上周末才恢复=.=，由于不能等那么久，所以就先放到月儿在CSDN上的博客里去了。

正如标题所描述的，下文是关于用javascript实现类Lisp语言的技巧，然而重点不在于如何实现一门编程语言，而是在于通过思考和实现过程展示javascript的简洁灵活和Lisp的优美。

或许这里接触Lisp的人不多，因此不少人一定会对以下的内容或形式感到奇怪，如果你完全没有接触过它，不必过分惊讶，Lisp的确与以前你见过得所有编程语言不同，因为，呃，它是Lisp，独一无二的Lisp，一段优雅、简洁、完整、独立的奇妙思想，也许你会觉得它很难懂，但是一旦你懂了，你会喜欢上它的。

好了，下面开始我们的LispScript之旅~


最近在网上偶然看到一篇文章，说javascript = C+Lisp，于是思考这样的问题，既然javascript包含着部分Lisp的血统，那么用javascript来实现一个类似于Lisp的人工智能脚本又会是什么样子？

LISt Processing语系作为一种“函数式”语系，自从诞生之日起便以其简单优美的风格和简洁高效的结构征服了许许多多的研究者和爱好者。

目前这种古老的语言和文法仍然被许许多多的人使用着并热爱着，而且在人工智能等领域发挥着非常巨大的作用。

我认为，javascript的灵活加上Lisp的简洁，应该能够创造出一种非常优美的语言，不过这种语言是什么样子的呢？相信大家也很想知道，那么下面我们一起来研究一下这个非常吸引人的问题。

（在仔细阅读下面的内容之前，建议大家先倒杯热茶，坐下来平静一下自己的心情，深呼吸一下，集中起精神来，因为下面的过程将是有趣而又颇耗脑细胞的...^^）

在进入Lisp王国之前，让我们先来做一些javascrip的准备工作...请仔细阅读下面的代码

1. NIL = [];
   
2. 
   
3. Array.prototype.toEvalString = function()
   
4. {
   
5. if(this.length <= 0) return "NIL";
   
6. var str = "";
   
7. for (var i = 0; i < this.length; i++)
   
8. {
   
9.   if(this[i] instanceof Array)
   
10.    str += "," + this[i].toEvalString();
    
11.   else str += "," + this[i];
    
12. }
    
13. return "[" + str.slice(1) + "]";
    
14. };
    
15. 
    
16. (function(){
    
17. 
    
18. LispScript = {
    
19.   Run : run
    
20. };
    
21. 
    
22. function run(code)
    
23. {
    
24.   if(code instanceof Array)
    
25.   {
    
26.    var elements = new Array();
    
27.    for (var i = 0; i < code.length; i++)
    
28.    {
    
29.     code[i] = run(code[i]); //递归向下读取
    
30.     if(code[i] instanceof Function)  //解析表达式
    
31.     {
    
32.      if(code[i].length <= 0) //无参函数可省略[]直接以函数名称调用
    
33.      {
    
34.       code[i] = code[i].call(null);
    
35.      }
    
36.      else if(i == 0)  //调用带参数的函数[funcall,args...]
    
37.      {
    
38.       return code[i].apply(null, code.slice(1));
    
39.      }
    
40.     }
    
41.    }
    
42. 
    
43.    return code;
    
44.   }
    
45.   return Element(code);
    
46. };
    
47. })();
    
48. 
    
49. function Assert(msg, cond)
    
50. {
    
51. if(cond)
    
52.   return true;
    
53. else
    
54.   {
    
55.    alert(msg);
    
56.    throw new Error(msg);
    
57.   }
    
58. };
    
59. 
    
60. function Element(arg)
    
61. {
    
62. if(arg == null)
    
63.   return [];
    
64. else if(arg instanceof Function && arg.length <= 0)
    
65.   return arg.call(null);
    
66. else
    
67.   return arg;
    
68. };
    
69. 
    
70. __funList = new Array();

复制代码运行代码另存代码

以上这段简简单单不过数十行的javascript代码由三个辅助函数、一个主体对象、一个常量NIL（后面我们会知道它表示一个空表或者逻辑false），以及一个存放函数名称的堆栈组成。

LispScript静态对象构成了LispScript解析器的主体，它只有一个Run方法，该方法用向下递归的方式解析传递进来的LispScript代码，代码的类型——相信细心的读者已经发现了——直接用的是javascript的数组，也就是一系列“[”、“]”和分隔符“,”构成的序列。

用javascript天然的数组特性，使得我们的解析器可以设计得十分简洁——不用去拆分和解析每一个token，于是一段简短到不到50行的代码惊人地实现了整个LispScript解析器的核心！

三个辅助函数的作用分别是为函数迭代提供解析（toEvalString），检测序列异常（Assert，后面的具体实现中其实并没有用到），以及解析指令单词（Element）

接下来我们先定义表达式.表达式或是一个原子[atom],它是一个字母序列(如 foo),或是一个由零个或多个表达式组成的表(list), 表达式之间用逗号分开, 放入一对中括号中. 以下是一些表达式:
（注：原Lisp语法的表达式用空格隔开，放入一对括号中。因是javascript的实现，所以用中括号和逗号较为简洁）

foo
[]
[foo]
[foo,bar]
[a,b,[c],d]

最后一个表达式是由四个元素组成的表, 第三个元素本身是由一个元素组成的表.
在算术中表达式 1 + 1 得出值2. 正确的Lisp表达式也有值. 如果表达式e得出值v,我们说e返回v. 下一步我们将定义几种表达式以及它们的返回值.

如果一个表达式是表,我们称第一个元素为操作符,其余的元素为自变量.我们将定义七个原始(从公理的意义上说)操作符: quote,atom,eq,car,cdr,cons,和 cond.

[quote,x] 返回x. 我们把[quote,x]简记为[_,x].

> [quote,a]
a
> [_,a]
a
> [quote,[a b c]]
[a,b,c]

1. quote = _ = function(args)
   
2. {
   
3. if(arguments.length < 1)
   
4.   return [];
   
5. else if(arguments.length >= 1)
   
6. {
   
7.   return arguments[0];
   
8. }
   
9. };

复制代码运行代码另存代码

[atom,x]返回原子true如果x的值是一个原子或是空表,否则返回[]. 在Lisp中我们按惯例用原子true表示真, 而用空表表示假.

> [atom,[_,a]]
true
> [atom,[_,[a,b,c]]]
[]
> [atom,[_,[]]]
true

1. atom = function(arg)
   
2. {
   
3. var tmp = LispScript.Run(arg); //先对参数求值
   
4. 
   
5. if(!(tmp instanceof Array) || tmp.length <= 0)
   
6.   return true;
   
7. else
   
8.   return [];
   
9. };

复制代码运行代码另存代码

既然有了一个自变量需要求值的操作符, 我们可以看一下quote的作用. 通过引用(quote)一个表,我们避免它被求值. 一个未被引用的表作为自变量传给象 atom这样的操作符将被视为代码:

> [atom,[atom,[_,a]]]
true

反之一个被引用的表仅被视为表, 在此例中就是有两个元素的表:

> [atom,[_,[atom,[_,a]]]]
[]

这与我们在英语中使用引号的方式一致. Cambridge(剑桥)是一个位于麻萨诸塞州有90000人口的城镇. 而"Cambridge"是一个由9个字母组成的单词.

引用看上去可能有点奇怪因为极少有其它语言有类似的概念. 它和Lisp最与众不同的特征紧密联系:代码和数据由相同的数据结构构成, 而我们用quote操作符来区分它们.

[eq,x,y]返回t如果x和y的值是同一个原子或都是空表, 否则返回[].

> [eq,[_,a],[_,a]]
true
> [eq,[_,a],[_,b]]
[]
> [eq,[_,[]],[_,[]]]
true

1. equal = eq = function(arg1, arg2)
   
2. {
   
3. var tmp1 = LispScript.Run(arg1);
   
4. var tmp2 = LispScript.Run(arg2);   //先对参数求值
   
5. 
   
6. if(!(tmp1 instanceof Array) && !(tmp2 instanceof Array) &&
   
7.   tmp1.toString() == tmp2.toString() ||
   
8.   (tmp1 instanceof Function) && (tmp2 instanceof Function) && tmp1.toString() == tmp2.toString() ||
   
9.   (tmp1 instanceof Array) && (tmp2 instanceof Array) && (tmp1.length == 0) && (tmp2.length == 0))
   
10.   return true;
    
11. else
    
12.   return [];
    
13. };

复制代码运行代码另存代码

[car,x]期望x的值是一个表并且返回x的第一个元素.

> [car,[_,[a b c]]]
a

1. car = function(arg)
   
2. {
   
3. var tmp = LispScript.Run(arg);  //先对参数求值
   
4. 
   
5. if(tmp instanceof Array && tmp.length > 0)
   
6.   return tmp[0];
   
7. else
   
8.   return [];
   
9. };

复制代码运行代码另存代码

[cdr,x]期望x的值是一个表并且返回x的第一个元素之后的所有元素.

> [cdr,[_,[a b c]]]
[b,c]

1. cdr = function(arg)
   
2. {
   
3. var tmp = LispScript.Run(arg);  //先对参数求值
   
4. 
   
5. if(tmp instanceof Array && tmp.length > 0)
   
6.   return tmp.slice(1);
   
7. else
   
8.   return [];
   
9. };

复制代码运行代码另存代码

[cons,x,y]期望y的值是一个表并且返回一个新表,它的第一个元素是x的值, 后面跟着y的值的各个元素.

> [cons,[_,a],[_,[b,c]]]
[a,b,c]
> [cons,[_,a],[cons,[_,b],[cons,[_,c],[_,[]]]]]
[a,b,c]
> [car,[cons,[_,a],[_,[b c]]]]
a
> [cdr,[cons,[_,a],[_,[b,c]]]]
[b,c]

1. cons = function(arg1, arg2)
   
2. {
   
3. var tmp1 = LispScript.Run(arg1);
   
4. var tmp2 = LispScript.Run(arg2);   //先对参数求值
   
5. 
   
6. if(tmp2 instanceof Array)
   
7. {
   
8.   var list = new Array();
   
9.   list.push(tmp1);
   
10.   return list.concat(tmp2);
    
11. }
    
12. else
    
13.   return [];
    
14. };

复制代码运行代码另存代码

[cond [...] ...[...]] 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式,相应的e表达式的值作为整个cond表达式的返回值.

> [cond,[[eq,[_,a],[_,b]],[_,first]],
      [,[atom,[_,a]], [_,second]]]
second

1. cond = function(args)
   
2. {
   
3. for (var i = 0; i < arguments.length; i++)
   
4. {
   
5.   if(arguments[i] instanceof Array)
   
6.   {
   
7.    var cond = LispScript.Run(arguments[i][0]);  //先对参数求值
   
8.    //alert(cond);
   
9.    if(cond == true && arguments[i][1] != null)
   
10.     return LispScript.Run(arguments[i][1]);
    
11.   }
    
12. }
    
13. return [];
    
14. };

复制代码运行代码另存代码

当表达式以七个原始操作符中的五个开头时,它的自变量总是要求值的.2 我们称这样 的操作符为函数.

接着我们定义一个记号来描述函数.函数表示为[lambda, [...], e],其中 ...是原子(叫做参数),e是表达式. 如果表达式的第一个元素形式如上
[[lambda,[...],e],...]

则称为函数调用.它的值计算如下.每一个表达式先求值,然后e再求值.在e的求值过程中,每个出现在e中的的值是相应的在最近一次的函数调用中的值.

> [[lambda,['x'],[cons,'x',[_,[c]]]],[_,a]]
[a,c]
> [[lambda,['x','y'],[cons,'x',[cdr,'y']]],[_,z],[_,[a,b,c]]]
[z,b,c]

1. lambda = function(args, code)
   
2. {
   
3. if(code instanceof Array)
   
4. {
   
5.   var fun = new Function(args,
   
6.    "for(var i = 0; i < arguments.length; i++) arguments[i] = LispScript.Run(arguments[i]);return LispScript.Run("+code.toEvalString()+");");
   
7. 
   
8.   var globalFuncName = __funList.pop();
   
9.   
   
10.   fun._funName = globalFuncName;
    
11. 
    
12.   if(globalFuncName != null)
    
13.    self[globalFuncName] = fun;
    
14. 
    
15.   return fun;
    
16. }
    
17. 
    
18. return [];
    
19. };

复制代码运行代码另存代码

如果一个表达式的第一个元素f是原子且f不是原始操作符
[f ...]

并且f的值是一个函数[lambda,[...]],则以上表达式的值就是

[[lambda,[...],e],...]

的值. 换句话说,参数在表达式中不但可以作为自变量也可以作为操作符使用:

> [[lambda,[f],[f,[_,[b,c]]],[_,[lambda,[x],[cons,[_,a],x]]]
[a,b,c]

有另外一个函数记号使得函数能提及它本身,这样我们就能方便地定义递归函数.记号

[label,f,[lambda,[...],e]]

表示一个象[lambda,[...],e]那样的函数,加上这样的特性: 任何出现在e中的f将求值为此label表达式, 就好象f是此函数的参数.

假设我们要定义函数[subst,x,y,z], 它取表达式x,原子y和表z做参数,返回一个象z那样的表, 不过z中出现的y(在任何嵌套层次上)被x代替.

> [subst,[_,m],[_,b],[_,[a,b,[a,b,c],d]]]
[a,m,[a,m,c],d]

我们可以这样表示此函数

[label,subst,[lambda,[x,y,z],
               [cond,[[atom,z],
                      [cond,[[eq,z,y],x],
                            true,z]]],
                     [true,[cons,[subst,x,y,[car,z]],
                               [subst,x,y,[cdr,z]]]]]]]

1. label = function(funName, funDef)
   
2. {
   
3. __funList.push(funName);
   
4. 
   
5. return LispScript.Run(funDef);
   
6. };

复制代码运行代码另存代码

我们简记f=[label,f,[lambda,[...],e]]为
[defun,f,[...],e]

1. defun = function(funName, args, code)
   
2. {
   
3. __funList.push(funName);
   
4. 
   
5. if(code instanceof Array)
   
6. {
   
7.   var fun = new Function(args,
   
8.    "for(var i = 0; i < arguments.length; i++) arguments[i] = LispScript.Run(arguments[i]);return LispScript.Run("+code.toEvalString()+");");
   
9. 
   
10.   var globalFuncName = __funList.pop();
    
11. 
    
12.   fun._funName = globalFuncName;
    
13. 
    
14.   if(globalFuncName != null)
    
15.    self[globalFuncName] = fun;
    
16. 
    
17.   return fun;
    
18. }
    
19. 
    
20. return [];
    
21. };

复制代码运行代码另存代码

于是

[defun,subst,[x,y,z],
  [cond,[[atom,z],
         [cond,[[eq,z,y],x],
               [true,z]]],
     [true,[cons,[subst,x,y,[car,z]],
                  [subst,x,y,[cdr,z]]]]]]

偶然地我们在这儿看到如何写cond表达式的缺省子句. 第一个元素是't的子句总是会成功的. 于是
[cond,[x,y],[[_,true],z]]

等同于我们在某些语言中写的
if x then y else z

对于函数调用，具有如下结构：[FunName,[_,args]]
其中FunName是函数名称，[_,args]是指定参数引用列表args
注意[FunName,args]也是合法的，但是和[FunName,[_,args]]有所区别，对于前者，指令在被调用之前先计算args的值，把计算出的值作为参数列表代入函数计算（期望args计算结果为List），而后者的args参数列表在函数指令调用时才被计算


到这里为止我们很高兴地看到LispScript已经可以不依赖于javascript来扩展了

现在我们可以直接用LispScript定义一些新函数了：

函数：[isNull,x]测试它的自变量是否是空表.

1. LispScript.Run(
   
2. [defun,'isNull',['x'],
   
3.   [eq,'x',[_,NIL]]]
   
4. );

复制代码运行代码另存代码

> [isNull,[_,a]]
[]
> [isNull. [_,[]]]
t

函数:[and,x,y]返回t如果它的两个自变量都是t, 否则返回[].

1. LispScript.Run(
   
2. [defun,'and',['x','y'],
   
3.   [cond,['x',[cond,['y',true],[true,NIL]],
   
4.    [true,NIL]]]]
   
5. );

复制代码运行代码另存代码

> [and,[atom,[_,a]],[eq,[_,a],[_,a]]]
t
> [and,[atom,[_,a]],[eq,[_,a],[_,b]]]
[]

函数：[not,x]返回t如果它的自变量返回[],返回[]如果它的自变量返回t.

1. LispScript.Run(
   
2. [defun,'not',['x'],
   
3.   [cond,['x',NIL],
   
4.         [true,true]]]
   
5. );

复制代码运行代码另存代码

> [not,[eq,[_,a],[_,a]]]
[]
> [not,[eq,[_,a],[_,b]]]
t

函数：[append,x,y]取两个表并返回它们的连结.

1. LispScript.Run(
   
2. [defun,'append',['x','y'],
   
3.   [cond,[[isNull,'x'],'y'],
   
4.     [true,[cons,[car,'x'],['append',[cdr,'x'],'y']]]]]
   
5. );

复制代码运行代码另存代码

> [append,[_,[a,b]],[_,[c,d]]]
[a,b,c,d]
> [append,[], [_,[c,d]]]
[c,d]

函数：[pair,x,y]取两个相同长度的表,返回一个由双元素表构成的表,双元素表是相应位置的x,y的元素对.

1. LispScript.Run(
   
2. [defun,'pair',['x','y'],
   
3.   [cond,
   
4.    [[and,[isNull,'x'],[isNull,'y']],NIL],
   
5.    [[and,[not,[atom,'x']],[not,[atom,'y']]],
   
6.     [append,[[[car,'x'],[car,'y']]],['pair',[cdr,'x'],[cdr,'y']]]
   
7.    ]]]
   
8. );

复制代码运行代码另存代码

> [pair,[_,[x,y,z]],[_,[a,b,c]]]
[[x,a],[y,b],[z,c]]

[assoc,x,y]取原子x和形如pair函数所返回的表y,返回y中第一个符合如下条件的表的第二个元素:它的第一个元素是x.

1. LispScript.Run(
   
2. [defun,'assoc',['x','y'],
   
3.   [cond,[[eq,[car,[car,'y']],'x'],[car,[cdr,[car,'y']]]],
   
4.    [[isNull,'y'],NIL],[true,['assoc','x',[cdr,'y']]]]]
   
5. );

复制代码运行代码另存代码

> [assoc,[_,x],[_,[[x,a],[y,b]]]]
a
> [assoc,[_,x],[_,[[x,new],[x,a],[y,b]]]]
new

[ret,e]返回表达式计算结果

1. LispScript.Run(
   
2. [defun,'ret',['e'],[car,['e']]]
   
3. );

复制代码运行代码另存代码

[str,e]返回表达式计算结果的引用

1. LispScript.Run(
   
2. [defun,'str',['e'],[_,[_,'e']]]
   
3. );

复制代码运行代码另存代码

我们来看一下为什么要定义ret函数：
我想通过前面的解释和实际应用大家已经理解了引用(quote)的重要性，并且很容易证明：[[_,e]] = [e]
现在的问题是我们必须要定义一个引用的反函数f，令[f,[_,e]] = e
而显然地ret正是这样一个函数

[map,x,y]期望x是原子，y是一个表，如果[assoc,x,y]非空返回[assoc,x,y]的值否则返回x

1. LispScript.Run(
   
2. [defun,'map',['x','y'],
   
3.   [cond,[[isNull,[assoc,'x','y']],'x'],[true,[assoc,'x','y']]]]
   
4. );

复制代码运行代码另存代码

[maplist,x,y]期望x和y都是表，返回由x中的每个元素t求[map,t,y]的结果构成的表

1. LispScript.Run(
   
2. [defun,'maplist',['x','y'],
   
3.   [cond,
   
4.    [[atom,[_,'x']],[map,'x','y']],
   
5.    [true,[cons,['maplist',[car,[_,'x']],'y'],['maplist',[cdr,[_,'x']],'y']]]
   
6.   ]
   
7. ]
   
8. );

复制代码运行代码另存代码

因此我们能够定义函数来连接表,替换表达式等等.也许算是一个优美的表示法, 那下一步呢? 现在惊喜来了. 我们可以写一个函数作为我们语言的解释器:此函数取任意Lisp表达式作自变量并返回它的值. 如下所示:

1. LispScript.Run(
   
2. [defun,'_eval',['e','a'],
   
3.   [ret,[maplist,[_,'e'],'a']]
   
4. ]
   
5. );

复制代码运行代码另存代码

_eval.的简洁程度或许超出了我们原先的预想，于是这样我们获得了LispScrip实现的一个完整的自身的解析器！
让我们回过头考虑一下这意味着什么. 我们在这儿得到了一个非常优美的计算模型. 仅用quote,atom,eq,car,cdr,cons,和cond, 我们定义了函数_eval.,它事实上实现了我们的语言,用它可以定义和（或）动态生成任何我们想要的额外的函数和各种文法（这一点比较重要）


其他（略为复杂）的扩展：

下面我们定义变量的赋值操作[setq,paraName,paraValue]

1. LispScript.Run(
   
2. [defun,'setq',['para','val'],
   
3.   [ret,[defun,'para',[],[_eval,'val']]]]
   
4. );

复制代码运行代码另存代码

增加逻辑操作符or，[or,x,y]返回t如果它的自变量有一个为t，否则返回[]

1. LispScript.Run(
   
2. [defun,'or',['x','y'],
   
3.   [not,[and,[not,'x'],[not,'y']]]]
   
4. );

复制代码运行代码另存代码

增加循环控制foreach，[foreach,v,[paralist],[expr]]
foreach期望list是一个表，依次取表中的每一个原子作为expr的参数进行计算，返回计算结果的表

1. LispScript.Run(
   
2. [defun,'foreach',['v','list','expr'],
   
3.   [cond,
   
4.    [[isNull,'list'],[]],
   
5.    [true,[cons,[_eval,[_,'expr'],[['v',[car,'list']]]],['foreach','v',[cdr,'list'],[_,'expr']]]]
   
6.   ]
   
7. ]
   
8. );

复制代码运行代码另存代码

增加批量赋值操作let，[let,[[a1,v1],[a2,v2]...]]

1. LispScript.Run(
   
2.   [defun,'let',['paralist'],
   
3.    [foreach,"'v'",'paralist',[_,[setq,[car,"'v'"],[car,[cdr,"'v'"]]]]]
   
4.   ]
   
5. );

复制代码运行代码另存代码

总结

现在该回过头来看看我们究竟做了什么，以及这么做有什么意义了。
首先我们用javascript实现了一个简单的向下递归的词法分析器，它能对嵌套数组的每个原子进行简单处理，加上几个辅助函数(toEvalString(),Assert(),Element()和一个存放函数名称的堆栈...简单来说我们仅用了数十行代码实现了一种全新的“函数式”语言??LispScript的完整内核。
接着我们定义了7种原始操作，它们分别是quote,atom,eq,car,cdr,cons和cond
然后（相对较复杂地），我们定义了三种用来描述和调用函数的标记，它们分别是lambda, label以及defun，于是我们成功地用另外不到百行代码实现了LispScript语言的核心环境。
接着（接下来的部分已经可以完全独立于javascript）我们用7种原始操作符和函数定义标记defun定义出一些新的函数，分别是：isNull,and,not,append,pair,assoc,ret和str
然后我们惊喜地发现，可以仅用一行LispScript指令定义出自身的“解析器”??_eval函数
最后我们在此基础上定义出一些略为复杂的函数，它们包括：or,setq,foreach和let，其中一些新函数带给我们的新语言定义变量和处理循环的能力，加上前面实现的一些函数，一个比较完善的基础环境就搭建成了。

写在最后：LispScript和Lisp

事实上我们依照[ref. Paul Graham.]的精彩描述用javascript实现了LispScript，毫无疑问，它是一种Lisp（或者Lisp风格的函数式语言），尽管功能上还十分简陋，但它确实是符合Lisp的基本思想和拥有Lisp的基本特性。由于javascript数组文法的特点，我用[]取代了[ref. Paul Graham]中的()，用逗号取代了空格作为分隔符。同[ref. Paul Graham]的文章以及目前一些标准（或者相对标准）的Lisp不同的是，我根据javascript灵活的特点有意弱化了LispScript的语法结构，这样使得LispScript更加灵活，也更加方便实现，然而代价是一小部分的可维护性和安全性。
最后，LispScript还有许多需要完善的内容，例如，最明显地是它基本上还不具有基本的数值运算能力（相对而言，符号操作能力已经比较完善），另外对原子操作参数合法性的检验、副作用, 连续执行 (它得和副作用在一起才有用), 动态可视域、复杂数据结构支持以及注释文法（这相当重要！）也都是它所欠缺的，不过这些功能“都可以令人惊讶地用极少的额外代码来补救”。

感谢约翰麦卡锡，这位天才早在数十年前就向我们展示了一种程序设计领域内至今无人能超越的“极致的美”，他于1960年发表了一篇非凡的论文,他在这篇论文中对编程的贡献有如欧几里德对几何的贡献.1 他向我们展示了,在只给定几个简单的操作符和一个表示函数的记号的基础上, 如何构造出一个完整的编程语言. 麦卡锡称这种语言为Lisp, 意为List Processing, 因为他的主要思想之一是用一种简单的数据结构表(list)来代表代码和数据.

感谢保罗格雷厄姆，他用浅显易懂的语言将Lisp的根源和实质展现在我们面前，令我们能够幸运地零距离体验Lisp的这种“超凡的美”

如果你理解了约翰麦卡锡的eval, 那你就不仅仅是理解了程序语言历史中的一个阶段. 这些思想至今仍是Lisp的语义核心. 所以从某种意义上, 学习约翰麦卡锡的原著向我们展示了Lisp究竟是什么. 与其说Lisp是麦卡锡的设计,不如说是他的发现. 它不是生来就是一门用于人工智能, 快速原型开发或同等层次任务的语言. 它是你试图公理化计算的结果(之一).

随着时间的推移, 中级语言, 即被中间层程序员使用的语言, 正一致地向Lisp靠近. 因此通过理解eval你正在明白将来的主流计算模式会是什么样.

References
The Roots of Lisp Paul Graham. Draft, January 18, 2002.
LISt Primer Colin Allen & Maneesh Dhagat.Tue Feb 6, 2001.(http://mypage.iu.edu/~colallen/lp/lp.html)

[ 本帖由 月影 最后编辑于 2005-11-7 23:36 ]

月影

上面的那些放在文本区域里的代码并不是可以运行的，只是为了让大家看得清楚些

要试着体验LispScript的话，可以运行下面的代码：

1. <script>
   
2. NIL = [];
   
3. 
   
4. Array.prototype.toEvalString = function()
   
5. {
   
6.         if(this.length <= 0) return "NIL";
   
7.         var str = "";
   
8.         for (var i = 0; i < this.length; i++)
   
9.         {
   
10.                 if(this[i] instanceof Array)
    
11.                         str += "," + this[i].toEvalString();
    
12.                 else str += "," + this[i];
    
13.         }
    
14.         return "[" + str.slice(1) + "]";
    
15. };
    
16. 
    
17. (function(){
    
18.        
    
19.         LispScript = {
    
20.                 Run : run
    
21.         };
    
22.        
    
23.         function run(code)
    
24.         {
    
25.                 if(code instanceof Array)
    
26.                 {
    
27.                         var elements = new Array();
    
28.                         for (var i = 0; i < code.length; i++)
    
29.                         {
    
30.                                 code[i] = run(code[i]);        //递归向下读取
    
31.                                 if(code[i] instanceof Function)  //解析表达式
    
32.                                 {
    
33.                                         if(code[i].length <= 0)        //无参函数可省略[]直接以函数名称调用
    
34.                                         {
    
35.                                                 code[i] = code[i].call(null);
    
36.                                         }
    
37.                                         else if(i == 0)  //调用带参数的函数[funcall,args...]
    
38.                                         {
    
39.                                                 return code[i].apply(null, code.slice(1));
    
40.                                         }
    
41.                                 }
    
42.                         }
    
43. 
    
44.                         return code;
    
45.                 }
    
46.                 return Element(code);
    
47.         };
    
48. })();
    
49. 
    
50. function Assert(msg, cond)
    
51. {
    
52.         if(cond)
    
53.                 return true;
    
54.         else
    
55.                 {
    
56.                         alert(msg);
    
57.                         throw new Error(msg);
    
58.                 }
    
59. };
    
60. 
    
61. function Element(arg)
    
62. {
    
63.         if(arg == null)
    
64.                 return [];
    
65.         else if(arg instanceof Function && arg.length <= 0)
    
66.                 return arg.call(null);
    
67.         else
    
68.                 return arg;
    
69. };
    
70. 
    
71. __funList = new Array();
    
72. 
    
73. //七个原始操作符
    
74. //开始我们先定义表达式.表达式或是一个原子[atom],它是一个字母序列(如 foo),或是一个由零个或多个表达式组成的表(list), 表达式之间用逗号分开, 放入一对中括号中. 以下是一些表达式:
    
75. //（注：原Lisp语法的表达式用空格隔开，放入一对括号中。因是javascript的实现，所以用中括号和逗号比较较为简洁）
    
76. 
    
77. //foo
    
78. //[]
    
79. //[foo]
    
80. //[foo,bar]
    
81. //[a,b,[c],d]
    
82. 
    
83. //最后一个表达式是由四个元素组成的表, 第三个元素本身是由一个元素组成的表.
    
84. //在算术中表达式 1 + 1 得出值2. 正确的Lisp表达式也有值. 如果表达式e得出值v,我们说e返回v. 下一步我们将定义几种表达式以及它们的返回值.
    
85. 
    
86. //如果一个表达式是表,我们称第一个元素为操作符,其余的元素为自变量.我们将定义七个原始(从公理的意义上说)操作符: quote,atom,eq,car,cdr,cons,和 cond.
    
87. 
    
88. //[quote,x] 返回x. 我们把[quote,x]简记为[_,x].
    
89. 
    
90. //> [quote,a]
    
91. //a
    
92. //> [_,a]
    
93. //a
    
94. //> [quote,[a b c]]
    
95. //[a,b,c]
    
96. 
    
97. quote = _ = function(args)
    
98. {
    
99.         if(arguments.length < 1)
    
100.                 return [];
     
101.         else if(arguments.length >= 1)
     
102.         {
     
103.                 return arguments[0];
     
104.         }
     
105. };
     
106. 
     
107. //[atom,x]返回原子t如果x的值是一个原子或是空表,否则返回[]. 在Lisp中我们按惯例用原子t表示真, 而用空表表示假.
     
108. 
     
109. //> [atom,[_,a]]
     
110. //t
     
111. //> [atom,[_,[a,b,c]]]
     
112. //[]
     
113. //> [atom,[_,[]]]
     
114. //t
     
115. 
     
116. atom = function(arg)
     
117. {
     
118.         var tmp = LispScript.Run(arg); //先对参数求值
     
119. 
     
120.         if(!(tmp instanceof Array) || tmp.length <= 0)
     
121.                 return true;
     
122.         else
     
123.                 return [];
     
124. };
     
125. 
     
126. //既然有了一个自变量需要求值的操作符, 我们可以看一下quote的作用. 通过引用(quote)一个表,我们避免它被求值. 一个未被引用的表作为自变量传给象 atom这样的操作符将被视为代码:
     
127. 
     
128. 
     
129. //> [atom,[atom,[_,a]]]
     
130. //t
     
131. 
     
132. //反之一个被引用的表仅被视为表, 在此例中就是有两个元素的表:
     
133. 
     
134. //> [atom,[_,[atom,[_,a]]]]
     
135. //[]
     
136. 
     
137. //这与我们在英语中使用引号的方式一致. Cambridge(剑桥)是一个位于麻萨诸塞州有90000人口的城镇. 而"Cambridge"是一个由9个字母组成的单词.
     
138. 
     
139. //引用看上去可能有点奇怪因为极少有其它语言有类似的概念. 它和Lisp最与众不同的特征紧密联系:代码和数据由相同的数据结构构成, 而我们用quote操作符来区分它们.
     
140. 
     
141. //[eq,x,y]返回t如果x和y的值是同一个原子或都是空表, 否则返回[].
     
142. 
     
143. //> [eq,[_,a],[_,a]]
     
144. //t
     
145. //> [eq,[_,a],[_,b]]
     
146. //[]
     
147. //> [eq,[_,[]],[_,[]]]
     
148. //t
     
149. 
     
150. equal = eq = function(arg1, arg2)
     
151. {
     
152.         var tmp1 = LispScript.Run(arg1);
     
153.         var tmp2 = LispScript.Run(arg2);   //先对参数求值
     
154. 
     
155.         if(!(tmp1 instanceof Array) && !(tmp2 instanceof Array) &&
     
156.                 tmp1.toString() == tmp2.toString() ||
     
157.                 (tmp1 instanceof Function) && (tmp2 instanceof Function) && tmp1.toString() == tmp2.toString() ||
     
158.                 (tmp1 instanceof Array) && (tmp2 instanceof Array) && (tmp1.length == 0) && (tmp2.length == 0))
     
159.                 return true;
     
160.         else
     
161.                 return [];
     
162. };
     
163. 
     
164. //[car,x]期望x的值是一个表并且返回x的第一个元素.
     
165. 
     
166. //> [car,[_,[a b c]]]
     
167. //a
     
168. 
     
169. car = function(arg)
     
170. {
     
171.         var tmp = LispScript.Run(arg);  //先对参数求值
     
172. 
     
173.         if(tmp instanceof Array && tmp.length > 0)
     
174.                 return tmp[0];
     
175.         else
     
176.                 return [];
     
177. };
     
178. 
     
179. //[cdr,x]期望x的值是一个表并且返回x的第一个元素之后的所有元素.
     
180. //> [cdr,[_,[a b c]]]
     
181. //[b,c]
     
182. 
     
183. cdr = function(arg)
     
184. {
     
185.         var tmp = LispScript.Run(arg);  //先对参数求值
     
186. 
     
187.         if(tmp instanceof Array && tmp.length > 0)
     
188.                 return tmp.slice(1);
     
189.         else
     
190.                 return [];       
     
191. };
     
192. 
     
193. //[cons,x,y]期望y的值是一个表并且返回一个新表,它的第一个元素是x的值, 后面跟着y的值的各个元素.
     
194. 
     
195. //> [cons,[_,a],[_,[b,c]]]
     
196. //[a,b,c]
     
197. //> [cons,[_,a],[cons,[_,b],[cons,[_,c],[_,[]]]]]
     
198. //[a,b,c]
     
199. //> [car,[cons,[_,a],[_,[b c]]]]
     
200. //a
     
201. //> [cdr,[cons,[_,a],[_,[b,c]]]]
     
202. //[b,c]
     
203. 
     
204. cons = function(arg1, arg2)
     
205. {
     
206.         var tmp1 = LispScript.Run(arg1);
     
207.         var tmp2 = LispScript.Run(arg2);   //先对参数求值
     
208. 
     
209.         if(tmp2 instanceof Array)
     
210.         {
     
211.                 var list = new Array();
     
212.                 list.push(tmp1);
     
213.                 return list.concat(tmp2);
     
214.         }
     
215.         else
     
216.                 return [];
     
217. };
     
218. 
     
219. //[cond [...] ...[...]] 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式,相应的e表达式的值作为整个cond表达式的返回值.
     
220. 
     
221. //> [cond,[[eq,[_,a],[_,b]],[_,first]],
     
222. //      [,[atom,[_,a]], [_,second]]]
     
223. //second
     
224. 
     
225. cond = function(args)
     
226. {
     
227.         for (var i = 0; i < arguments.length; i++)
     
228.         {
     
229.                 if(arguments[i] instanceof Array)
     
230.                 {
     
231.                         var cond = LispScript.Run(arguments[i][0]);  //先对参数求值
     
232.                         //alert(cond);
     
233.                         if(cond == true && arguments[i][1] != null)
     
234.                                 return LispScript.Run(arguments[i][1]);
     
235.                 }
     
236.         }
     
237.         return [];
     
238. };
     
239. 
     
240. //当表达式以七个原始操作符中的五个开头时,它的自变量总是要求值的.2 我们称这样 的操作符为函数.
     
241. 
     
242. //函数的表示
     
243. 
     
244. //接着我们定义一个记号来描述函数.函数表示为[lambda, [...], e),其中 ...是原子(叫做参数),e是表达式. 如果表达式的第一个元素形式如上
     
245. //[[lambda,[...],e],...]
     
246. 
     
247. //则称为函数调用.它的值计算如下.每一个表达式先求值,然后e再求值.在e的求值过程中,每个出现在e中的的值是相应的在最近一次的函数调用中的值.
     
248. 
     
249. //> [[lambda,['x'],[cons,'x',[_,[b]]]],[_,a]]
     
250. //[a,b]
     
251. //> [[lambda,['x','y'],[cons,'x',[cdr,'y']]],[_,z],[_,[a,b,c]]]
     
252. //[z,b,c]
     
253. 
     
254. lambda = function(args, code)
     
255. {
     
256.         if(code instanceof Array)
     
257.         {
     
258.                 var fun = new Function(args,
     
259.                         "for(var i = 0; i < arguments.length; i++) arguments[i] = LispScript.Run(arguments[i]);return LispScript.Run("+code.toEvalString()+");");
     
260. 
     
261.                 var globalFuncName = __funList.pop();
     
262.                
     
263.                 fun._funName = globalFuncName;
     
264. 
     
265.                 if(globalFuncName != null)
     
266.                         self[globalFuncName] = fun;
     
267. 
     
268.                 return fun;
     
269.         }
     
270. 
     
271.         return [];
     
272. };
     
273. 
     
274. //如果一个表达式的第一个元素f是原子且f不是原始操作符
     
275. //[f ...]
     
276. 
     
277. //并且f的值是一个函数[lambda,[...]],则以上表达式的值就是
     
278. 
     
279. //[[lambda,[...],e],...]
     
280. 
     
281. //的值. 换句话说,参数在表达式中不但可以作为自变量也可以作为操作符使用:
     
282. 
     
283. 
     
284. //> [[lambda,[f],[f,[_,[b,c]]],[_,[lambda,[x],[cons,[_,a],x]]]
     
285. //[a,b,c]
     
286. 
     
287. //有另外一个函数记号使得函数能提及它本身,这样我们就能方便地定义递归函数.记号
     
288. 
     
289. //[label,f,[lambda,[...],e]]
     
290. 
     
291. //表示一个象[lambda,[...],e]那样的函数,加上这样的特性: 任何出现在e中的f将求值为此label表达式, 就好象f是此函数的参数.
     
292. 
     
293. //假设我们要定义函数[subst,x,y,z], 它取表达式x,原子y和表z做参数,返回一个象z那样的表, 不过z中出现的y(在任何嵌套层次上)被x代替.
     
294. 
     
295. //> [subst,[_,m],[_,b],[_,[a,b,[a,b,c],d]]]
     
296. //[a,m,[a,m,c],d]
     
297. 
     
298. //我们可以这样表示此函数
     
299. //[label,subst,[lambda,[x,y,z],
     
300. //               [cond,[[atom,z],
     
301. //                      [cond,[[eq,z,y],x],
     
302. //                            [_,t],z]]],
     
303. //                     [[_,t],[cons,[subst,x,y,[car,z]],
     
304. //                               [subst,x,y,[cdr,z]]]]]]]
     
305. 
     
306. label = function(funName, funDef)
     
307. {
     
308.         __funList.push(funName);
     
309. 
     
310.         return LispScript.Run(funDef);
     
311. };
     
312. 
     
313. //我们简记f=[label,f,[lambda,[...],e]]为
     
314. //[defun,f,[...],e]
     
315. 
     
316. defun = function(funName, args, code)
     
317. {
     
318.         __funList.push(funName);
     
319.        
     
320.         if(code instanceof Array)
     
321.         {
     
322.                 var fun = new Function(args,
     
323.                         "for(var i = 0; i < arguments.length; i++) arguments[i] = LispScript.Run(arguments[i]);return LispScript.Run("+code.toEvalString()+");");
     
324. 
     
325.                 var globalFuncName = __funList.pop();
     
326. 
     
327.                 fun._funName = globalFuncName;
     
328. 
     
329.                 if(globalFuncName != null)
     
330.                         self[globalFuncName] = fun;
     
331. 
     
332.                 return fun;
     
333.         }
     
334. 
     
335.         return [];
     
336. };
     
337. 
     
338. //于是
     
339. 
     
340. //[defun,subst,[x,y,z],
     
341. //  [cond,[[atom,z],
     
342. //         [cond,[[eq,z,y],x],
     
343. //               [[_,t],z]]],
     
344. //                                        [[_,t],[cons,[subst,x,y,[car,z]],
     
345. //                  [subst,x,y,[cdr,z]]]]]]
     
346. 
     
347. //偶然地我们在这儿看到如何写cond表达式的缺省子句. 第一个元素是't的子句总是会成功的. 于是
     
348. //[cond,[x,y],[[_,true],z]]
     
349. 
     
350. //等同于我们在某些语言中写的
     
351. //if x then y else z
     
352. 
     
353. //现在我们可以直接用LispScript定义一些新函数了：
     
354. 
     
355. //对于函数调用，具有如下结构：[FunName,[_,args]]
     
356. //其中FunName是函数名称，[_,args]是指定参数引用列表args
     
357. //注意[FunName,args]也是合法的，但是和[FunName,[_,args]]有所区别，对于前者，指令在被调用之前先计算args的值，把计算出的值作为参数列表代入函数计算（期望args计算结果为List），而后者的args参数列表在函数指令调用时才被计算
     
358. 
     
359. //函数：[null,x]测试它的自变量是否是空表.
     
360. LispScript.Run(
     
361.         [defun,'isNull',['x'],
     
362.                 [eq,'x',[_,NIL]]]
     
363. );
     
364. 
     
365. //> [null,[_,a]]
     
366. //[]
     
367. //> [null. [_,[]]]
     
368. //t
     
369. 
     
370. //函数:[and,x,y]返回t如果它的两个自变量都是t, 否则返回[].
     
371. LispScript.Run(
     
372.         [defun,'and',['x','y'],
     
373.                 [cond,['x',[cond,['y',true],[true,NIL]],
     
374.                         [true,NIL]]]]
     
375. );
     
376. 
     
377. //> [and,[atom,[_,a]],[eq,[_,a],[_,a]]]
     
378. //t
     
379. //> [and,[atom,[_,a]],[eq,[_,a],[_,b]]]
     
380. //[]
     
381. 
     
382. //函数：[not,x]返回t如果它的自变量返回[],返回[]如果它的自变量返回t.
     
383. LispScript.Run(
     
384.         [defun,'not',['x'],
     
385.                 [cond,['x',NIL],
     
386.         [true,true]]]
     
387. );
     
388. 
     
389. //> [not,[eq,[_,a],[_,a]]]
     
390. //[]
     
391. //> [not,[eq,[_,a],[_,b]]]
     
392. //t
     
393. 
     
394. //函数：[append,x,y]取两个表并返回它们的连结.
     
395. LispScript.Run(
     
396.         [defun,'append',['x','y'],
     
397.                 [cond,[[isNull,'x'],'y'],
     
398.                          [true,[cons,[car,'x'],['append',[cdr,'x'],'y']]]]]
     
399. );
     
400. 
     
401. //> [append,[_,[a,b]],[_,[c,d]]]
     
402. //[a,b,c,d]
     
403. //> [append,[], [_,[c,d]]]
     
404. //[c,d]
     
405. 
     
406. //函数：[pair,x,y]取两个相同长度的表,返回一个由双元素表构成的表,双元素表是相应位置的x,y的元素对.
     
407. LispScript.Run(
     
408.         [defun,'pair',['x','y'],
     
409.                 [cond,
     
410.                         [[and,[isNull,'x'],[isNull,'y']],NIL],       
     
411.                         [[and,[not,[atom,'x']],[not,[atom,'y']]],
     
412.                          [append,[[[car,'x'],[car,'y']]],['pair',[cdr,'x'],[cdr,'y']]]
     
413.                         ]]]
     
414. );
     
415. 
     
416. //> [pair,[_,[x,y,z]],[_,[a,b,c]]]
     
417. //[[x,a],[y,b],[z,c]]
     
418. 
     
419. //[assoc,x,y]取原子x和形如pair函数所返回的表y,返回y中第一个符合如下条件的表的第二个元素:它的第一个元素是x.
     
420. 
     
421. LispScript.Run(
     
422.         [defun,'assoc',['x','y'],
     
423.                 [cond,[[eq,[car,[car,'y']],'x'],[car,[cdr,[car,'y']]]],
     
424.                         [[isNull,'y'],NIL],[true,['assoc','x',[cdr,'y']]]]]
     
425. );
     
426. 
     
427. //> [assoc,[_,x],[_,[[x,a],[y,b]]]]
     
428. //a
     
429. //> [assoc,[_,x],[_,[[x,new],[x,a],[y,b]]]]
     
430. //new
     
431. 
     
432. //[ret,e]返回表达式计算结果
     
433. LispScript.Run(
     
434.         [defun,'ret',['e'],[car,['e']]]
     
435. );
     
436. 
     
437. //[str,e]返回表达式计算结果的引用
     
438. LispScript.Run(
     
439.         [defun,'str',['e'],[_,[_,'e']]]
     
440. );
     
441. 
     
442. //我们来看一下为什么要定义ret函数：
     
443. //我想通过前面的解释和实际应用大家已经理解了引用(quote)的重要性，并且很容易证明：[[_,e]] = [e]
     
444. //现在的问题是我们必须要定义一个引用的反函数f，令[f,[_,e]] = e
     
445. //而显然地ret正是这样一个函数
     
446. 
     
447. //[map,x,y]期望x是原子，y是一个表，如果[assoc,x,y]非空返回[assoc,x,y]的值否则返回x
     
448. LispScript.Run(
     
449.         [defun,'map',['x','y'],
     
450.                 [cond,[[isNull,[assoc,'x','y']],'x'],[true,[assoc,'x','y']]]]
     
451. );
     
452. 
     
453. //[maplist,x,y]期望x和y都是表，返回由x中的每个元素t求[map,t,y]的结果构成的表
     
454. LispScript.Run(
     
455.         [defun,'maplist',['x','y'],
     
456.                 [cond,
     
457.                         [[atom,[_,'x']],[map,'x','y']],
     
458.                         [true,[cons,['maplist',[car,[_,'x']],'y'],['maplist',[cdr,[_,'x']],'y']]]
     
459.                 ]
     
460.         ]
     
461. );
     
462. 
     
463. //一个惊喜
     
464. 
     
465. //因此我们能够定义函数来连接表,替换表达式等等.也许算是一个优美的表示法, 那下一步呢? 现在惊喜来了. 我们可以写一个函数作为我们语言的解释器:此函数取任意Lisp表达式作自变量并返回它的值. 如下所示:
     
466. 
     
467. 
     
468. LispScript.Run(
     
469.         [defun,'_eval',['e','a'],
     
470.                 [ret,[maplist,[_,'e'],'a']]
     
471.         ]
     
472. );
     
473. 
     
474. //_eval.的简洁程度或许超出了我们原先的预想，于是这样我们获得了LispScrip实现的一个完整的自身的解析器！
     
475. //让我们回过头考虑一下这意味着什么. 我们在这儿得到了一个非常优美的计算模型. 仅用quote,atom,eq,car,cdr,cons,和cond, 我们定义了函数_eval.,它事实上实现了我们的语言,用它可以定义和（或）动态生成任何我们想要的额外的函数和各种文法（这一点比较重要）
     
476. 
     
477. //其他的扩展
     
478. 
     
479. //下面我们定义变量的赋值操作[setq,paraName,paraValue]
     
480. LispScript.Run(
     
481.         [defun,'setq',['para','val'],
     
482.                 [ret,[defun,'para',[],[_eval,'val']]]]
     
483. );
     
484. 
     
485. 
     
486. //增加逻辑操作符or，[or,x,y]返回t如果它的自变量有一个为t，否则返回[]
     
487. LispScript.Run(
     
488.         [defun,'or',['x','y'],
     
489.                 [not,[and,[not,'x'],[not,'y']]]]
     
490. );
     
491. 
     
492. //增加循环控制foreach，[foreach,v,[list],[expr]]
     
493. //foreach期望list是一个表，依次取表中的每一个原子作为expr的参数进行计算，返回计算结果的表
     
494. LispScript.Run(
     
495.         [defun,'foreach',['v','list','expr'],
     
496.                 [cond,
     
497.                         [[isNull,'list'],[]],
     
498.                         [true,[cons,[_eval,[_,'expr'],[['v',[car,'list']]]],['foreach','v',[cdr,'list'],[_,'expr']]]]
     
499.                 ]
     
500.         ]
     
501. );
     
502. 
     
503. //增加批量赋值操作let，[let,[[a1,v1],[a2,v2]...]]
     
504. LispScript.Run(
     
505.                 [defun,'let',['paralist'],
     
506.                         [foreach,"'v'",'paralist',[_,[setq,[car,"'v'"],[car,[cdr,"'v'"]]]]]
     
507.                 ]
     
508. );
     
509. 
     
510. //总结
     
511. 
     
512. //现在该回过头来看看我们究竟做了什么，以及这么做有什么意义了。
     
513. //首先我们用javascript实现了一个简单的向下递归的词法分析器，它能对嵌套数组的每个原子进行简单处理，加上几个辅助函数(toEvalString(),Assert(),Element()和一个存放函数名称的堆栈...简单来说我们仅用了数十行代码实现了一种全新的“函数式”语言??LispScript的完整内核。
     
514. //接着我们定义了7种原始操作，它们分别是quote,atom,eq,car,cdr,cons和cond
     
515. //然后（相对较复杂地），我们定义了三种用来描述和调用函数的标记，它们分别是lambda, label以及defun，于是我们成功地用另外不到百行代码实现了LispScript语言的核心环境。
     
516. //接着（接下来的部分已经可以完全独立于javascript）我们用7种原始操作符和函数定义标记defun定义出一些新的函数，分别是：isNull,and,not,append,pair,assoc,ret和str
     
517. //然后我们惊喜地发现，可以仅用一行LispScript指令定义出自身的“解析器”??_eval函数
     
518. //最后我们在此基础上定义出一些略为复杂的函数，它们包括：or,setq,foreach和let，其中一些新函数带给我们的新语言定义变量和处理循环的能力，加上前面实现的一些函数，一个比较完善的基础环境就搭建成了。
     
519. 
     
520. //写在最后：LispScript和Lisp
     
521. 
     
522. //事实上我们依照[ref. Paul Graham.]的精彩描述用javascript实现了LispScript，毫无疑问，它是一种Lisp（或者Lisp风格的函数式语言），尽管功能上还十分简陋，但它确实是符合Lisp的基本思想和拥有Lisp的基本特性。由于javascript数组文法的特点，我用[]取代了[ref. Paul Graham]中的()，用逗号取代了空格作为分隔符。同[ref. Paul Graham]的文章以及目前一些标准（或者相对标准）的Lisp不同的是，我根据javascript灵活的特点有意弱化了LispScript的语法结构，这样使得LispScript更加灵活，也更加方便实现，然而代价是一小部分的可维护性和安全性。
     
523. //最后，LispScript还有许多需要完善的内容，例如，最明显地是它基本上还不具有基本的数值运算能力（相对而言，符号操作能力已经比较完善），另外对原子操作参数合法性的检验、副作用, 连续执行 (它得和副作用在一起才有用), 动态可视域、复杂数据结构支持以及注释文法（这相当重要！）也都是它所欠缺的，不过这些功能“都可以令人惊讶地用极少的额外代码来补救”。
     
524. 
     
525. //感谢约翰麦卡锡，这位天才早在数十年前就向我们展示了一种程序设计领域内至今无人能超越的“极致的美”，他于1960年发表了一篇非凡的论文,他在这篇论文中对编程的贡献有如欧几里德对几何的贡献.1 他向我们展示了,在只给定几个简单的操作符和一个表示函数的记号的基础上, 如何构造出一个完整的编程语言. 麦卡锡称这种语言为Lisp, 意为List Processing, 因为他的主要思想之一是用一种简单的数据结构表(list)来代表代码和数据.
     
526. 
     
527. //感谢保罗格雷厄姆，他用浅显易懂的语言将Lisp的根源和实质展现在我们面前，令我们能够幸运地零距离体验Lisp的这种“超凡的美”
     
528. 
     
529. //如果你理解了约翰麦卡锡的eval, 那你就不仅仅是理解了程序语言历史中的一个阶段. 这些思想至今仍是Lisp的语义核心. 所以从某种意义上, 学习约翰麦卡锡的原著向我们展示了Lisp究竟是什么. 与其说Lisp是麦卡锡的设计,不如说是他的发现. 它不是生来就是一门用于人工智能, 快速原型开发或同等层次任务的语言. 它是你试图公理化计算的结果(之一).
     
530. 
     
531. //随着时间的推移, 中级语言, 即被中间层程序员使用的语言, 正一致地向Lisp靠近. 因此通过理解eval你正在明白将来的主流计算模式会是什么样.
     
532. 
     
533. //References
     
534. //The Roots of Lisp Paul Graham. Draft, January 18, 2002.
     
535. //LISt Primer Colin Allen & Maneesh Dhagat.Tue Feb 6, 2001.(http://mypage.iu.edu/~colallen/lp/lp.html)
     
536. </script>
     
537. LispScript指令：（以分号分隔每条指令）<br>
     
538. <textarea cols="80" rows="20" id="code">
     
539. </textarea><br>
     
540. 运行结果：<br>
     
541. <textarea cols="80" rows="5" readonly id="result">
     
542. </textarea><br>
     
543. <input type="button" value="运行" onclick="RunCode()">
     
544. <script>
     
545. function RunCode()
     
546. {
     
547.         var codes = code.value.split(';');
     
548.         result.value = "";
     
549.         for (var i = 0; i < codes.length; i++)
     
550.         {
     
551.                 try
     
552.                 {
     
553.                         var res = LispScript.Run(eval(codes[i]));
     
554.                 }
     
555.                 catch(e)
     
556.                 {
     
557.                         result.value += "错误的LispScript语法!(" + e.message + ")";
     
558.                         continue;
     
559.                 }
     
560.                 if(res instanceof Array)
     
561.                         result.value += res.toEvalString() + "\n";
     
562.                 else if(res instanceof Function)
     
563.                         result.value += "Function " + res._funName + "\n";
     
564.                 else
     
565.                         result.value += res + "\n";
     
566.         }
     
567. }
     
568. </script>

复制代码运行代码另存代码

你可以在这个简易的运行环境中输入LispScript的语句，多条语句请用分号分开

例如：你可以输入
[cons,1,[2,3]]
然后运行，结果是[1,2,3]

你可以输入
[setq,'x',1];
[setq,'y',[2,3]];
[cons,x,y]
然后运行，结果仍然是[1,2,3]

你可以输入
[defun,'mycons',['x','y'],[cons,'x','y']];
[mycons,1,[2,3]]
然后运行，结果也仍然是[1,2,3]

lint

不推不行
JavaScript:
世界上最被误解的语言
http://www2.uuzone.com/blog/555080192/18957.htm
http://www.cnblogs.com/shiningray/articles/143004.html

[ 本帖由 lint 最后编辑于 2005-11-7 20:23 ]

泣红亭

现在在上班，没办法如何研究，只能回家再仔细研究一下，简略看了一下。。郁闷。。看得冷汗直流。。。单从思想上来看，评为精华三并无夸大之处，先评后快。。

月影

引用内容由 泣红亭 发表于 2005-11-7 09:53 PM
现在在上班，没办法如何研究，只能回家再仔细研究一下，简略看了一下。。郁闷。。看得冷汗直流。。。单从思想上来看，评为精华三并无夸大之处，先评后快。。

上夜班啊...好辛苦哦...=.=

evlon

为了学习,测试上面的ListScript,我写了一个命令环境

<script>
NIL = [];

Array.prototype.toEvalString = function()
{
if(this.length <= 0) return "NIL";
var str = "";
for (var i = 0; i < this.length; i++)
{
  if(this instanceof Array)
   str += "," + this.toEvalString();
  else str += "," + this;
}
return "[" + str.slice(1) + "]";
};

(function(){

LispScript = {
  Run : run
};

function run(code)
{
  if(code instanceof Array)
  {
   var elements = new Array();
   for (var i = 0; i < code.length; i++)
   {
    code = run(code); //递归向下读取
    if(code instanceof Function)  //解析表达式
    {
     if(code.length <= 0) //无参函数可省略[]直接以函数名称调用
     {
      code = code.call(null);
     }
     else if(i == 0)  //调用带参数的函数[funcall,args...]
     {
      return code.apply(null, code.slice(1));
     }
    }
   }

   return code;
  }
  return Element(code);
};
})();

function Assert(msg, cond)
{
if(cond)
  return true;
else
  {
   alert(msg);
   throw new Error(msg);
  }
};

function Element(arg)
{
if(arg == null)
  return [];
else if(arg instanceof Function && arg.length <= 0)
  return arg.call(null);
else
  return arg;
};

__funList = new Array();


/////////////////
quote = _ = function(args)
{
if(arguments.length < 1)
  return [];
else if(arguments.length >= 1)
{
  return arguments[0];
}
};

//[atom,x]返回原子true如果x的值是一个原子或是空表,否则返回[]. 在Lisp中我们按惯例用原子true表示真, 而用空表表示假.
atom = function(arg)
{
var tmp = LispScript.Run(arg); //先对参数求值

if(!(tmp instanceof Array) || tmp.length <= 0)
  return true;
else
  return [];
};

//[eq,x,y]返回t如果x和y的值是同一个原子或都是空表, 否则返回[].
equal = eq = function(arg1, arg2)
{
var tmp1 = LispScript.Run(arg1);
var tmp2 = LispScript.Run(arg2);   //先对参数求值

if(!(tmp1 instanceof Array) && !(tmp2 instanceof Array) &&
  tmp1.toString() == tmp2.toString() ||
  (tmp1 instanceof Function) && (tmp2 instanceof Function) && tmp1.toString() == tmp2.toString() ||
  (tmp1 instanceof Array) && (tmp2 instanceof Array) && (tmp1.length == 0) && (tmp2.length == 0))
  return true;
else
  return [];
};

//[car,x]期望x的值是一个表并且返回x的第一个元素.
car = function(arg)
{
var tmp = LispScript.Run(arg);  //先对参数求值

if(tmp instanceof Array && tmp.length > 0)
  return tmp[0];
else
  return [];
};

//[cdr,x]期望x的值是一个表并且返回x的第一个元素之后的所有元素.
cdr = function(arg)
{
var tmp = LispScript.Run(arg);  //先对参数求值

if(tmp instanceof Array && tmp.length > 0)
  return tmp.slice(1);
else
  return [];
};

//[cons,x,y]期望y的值是一个表并且返回一个新表,它的第一个元素是x的值, 后面跟着y的值的各个元素.
cons = function(arg1, arg2)
{
var tmp1 = LispScript.Run(arg1);
var tmp2 = LispScript.Run(arg2);   //先对参数求值

if(tmp2 instanceof Array)
{
  var list = new Array();
  list.push(tmp1);
  return list.concat(tmp2);
}
else
  return [];
};

/*
[cond [...] ...[...]] 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式,相应的e表达式的值作为整个cond表达式的返回值.

*/
cond = function(args)
{
for (var i = 0; i < arguments.length; i++)
{
  if(arguments instanceof Array)
  {
   var cond = LispScript.Run(arguments[0]);  //先对参数求值
   //alert(cond);
   if(cond == true && arguments[1] != null)
    return LispScript.Run(arguments[1]);
  }
}
return [];
};

//则称为函数调用.它的值计算如下.每一个表达式先求值,然后e再求值.在e的求值过程中,每个出现在e中的的值是相应的在最近一次的函数调用中的值.
lambda = function(args, code)
{
if(code instanceof Array)
{
  var fun = new Function(args,
   "for(var i = 0; i < arguments.length; i++) arguments = LispScript.Run(arguments);return LispScript.Run("+code.toEvalString()+");");

  var globalFuncName = __funList.pop();
  
  fun._funName = globalFuncName;

  if(globalFuncName != null)
   self[globalFuncName] = fun;

  return fun;
}

return [];
};

</script>
<script>
        var prompt = '>';
        function initPrompt()
        {
                if(cmd.value == '')
                        cmd.value = prompt;
        }
        function runLastCmd()
        {
                if(window.event.keyCode == 13)
                {
                        window.event.returnValue = false;
                       
                        var idx = cmd.value.lastIndexOf('\n') + 1;
                        idx += prompt.length;

                        var strCmd = cmd.value.substr(idx);
                        var output = '';
                        try
                        {
                                var lisp = eval(strCmd);
                                if(lisp instanceof Array)
                                {
                                         output = LispScript.Run(lisp);
                                }
                                else
                                {
                                        output = '未知命令';
                                }
                        }
                        catch(e)
                        {
                                output = '语法错误';
                        }
                        if(output instanceof Array)
                        {
                                output = '[' + output + ']';
                        }
                        cmd.value += '\n' + output + '\n' + prompt;
                }
               
        }
</script>
<textarea id=cmd style="width:600px;height:600px" onkeydown="runLastCmd()" onclick="initPrompt()">
</textarea>

1. <script>
   
2. NIL = [];
   
3. 
   
4. Array.prototype.toEvalString = function()
   
5. {
   
6. if(this.length <= 0) return "NIL";
   
7. var str = "";
   
8. for (var i = 0; i < this.length; i++)
   
9. {
   
10.   if(this[i] instanceof Array)
    
11.    str += "," + this[i].toEvalString();
    
12.   else str += "," + this[i];
    
13. }
    
14. return "[" + str.slice(1) + "]";
    
15. };
    
16. 
    
17. (function(){
    
18. 
    
19. LispScript = {
    
20.   Run : run
    
21. };
    
22. 
    
23. function run(code)
    
24. {
    
25.   if(code instanceof Array)
    
26.   {
    
27.    var elements = new Array();
    
28.    for (var i = 0; i < code.length; i++)
    
29.    {
    
30.     code[i] = run(code[i]); //递归向下读取
    
31.     if(code[i] instanceof Function)  //解析表达式
    
32.     {
    
33.      if(code[i].length <= 0) //无参函数可省略[]直接以函数名称调用
    
34.      {
    
35.       code[i] = code[i].call(null);
    
36.      }
    
37.      else if(i == 0)  //调用带参数的函数[funcall,args...]
    
38.      {
    
39.       return code[i].apply(null, code.slice(1));
    
40.      }
    
41.     }
    
42.    }
    
43. 
    
44.    return code;
    
45.   }
    
46.   return Element(code);
    
47. };
    
48. })();
    
49. 
    
50. function Assert(msg, cond)
    
51. {
    
52. if(cond)
    
53.   return true;
    
54. else
    
55.   {
    
56.    alert(msg);
    
57.    throw new Error(msg);
    
58.   }
    
59. };
    
60. 
    
61. function Element(arg)
    
62. {
    
63. if(arg == null)
    
64.   return [];
    
65. else if(arg instanceof Function && arg.length <= 0)
    
66.   return arg.call(null);
    
67. else
    
68.   return arg;
    
69. };
    
70. 
    
71. __funList = new Array();
    
72. 
    
73. 
    
74. /////////////////
    
75. quote = _ = function(args)
    
76. {
    
77. if(arguments.length < 1)
    
78.   return [];
    
79. else if(arguments.length >= 1)
    
80. {
    
81.   return arguments[0];
    
82. }
    
83. };
    
84. 
    
85. //[atom,x]返回原子true如果x的值是一个原子或是空表,否则返回[]. 在Lisp中我们按惯例用原子true表示真, 而用空表表示假.
    
86. atom = function(arg)
    
87. {
    
88. var tmp = LispScript.Run(arg); //先对参数求值
    
89. 
    
90. if(!(tmp instanceof Array) || tmp.length <= 0)
    
91.   return true;
    
92. else
    
93.   return [];
    
94. };
    
95. 
    
96. //[eq,x,y]返回t如果x和y的值是同一个原子或都是空表, 否则返回[].
    
97. equal = eq = function(arg1, arg2)
    
98. {
    
99. var tmp1 = LispScript.Run(arg1);
    
100. var tmp2 = LispScript.Run(arg2);   //先对参数求值
     
101. 
     
102. if(!(tmp1 instanceof Array) && !(tmp2 instanceof Array) &&
     
103.   tmp1.toString() == tmp2.toString() ||
     
104.   (tmp1 instanceof Function) && (tmp2 instanceof Function) && tmp1.toString() == tmp2.toString() ||
     
105.   (tmp1 instanceof Array) && (tmp2 instanceof Array) && (tmp1.length == 0) && (tmp2.length == 0))
     
106.   return true;
     
107. else
     
108.   return [];
     
109. };
     
110. 
     
111. //[car,x]期望x的值是一个表并且返回x的第一个元素.
     
112. car = function(arg)
     
113. {
     
114. var tmp = LispScript.Run(arg);  //先对参数求值
     
115. 
     
116. if(tmp instanceof Array && tmp.length > 0)
     
117.   return tmp[0];
     
118. else
     
119.   return [];
     
120. };
     
121. 
     
122. //[cdr,x]期望x的值是一个表并且返回x的第一个元素之后的所有元素.
     
123. cdr = function(arg)
     
124. {
     
125. var tmp = LispScript.Run(arg);  //先对参数求值
     
126. 
     
127. if(tmp instanceof Array && tmp.length > 0)
     
128.   return tmp.slice(1);
     
129. else
     
130.   return [];
     
131. };
     
132. 
     
133. //[cons,x,y]期望y的值是一个表并且返回一个新表,它的第一个元素是x的值, 后面跟着y的值的各个元素.
     
134. cons = function(arg1, arg2)
     
135. {
     
136. var tmp1 = LispScript.Run(arg1);
     
137. var tmp2 = LispScript.Run(arg2);   //先对参数求值
     
138. 
     
139. if(tmp2 instanceof Array)
     
140. {
     
141.   var list = new Array();
     
142.   list.push(tmp1);
     
143.   return list.concat(tmp2);
     
144. }
     
145. else
     
146.   return [];
     
147. };
     
148. 
     
149. /*
     
150. [cond [...] ...[...]] 的求值规则如下. p表达式依次求值直到有一个返回t. 如果能找到这样的p表达式,相应的e表达式的值作为整个cond表达式的返回值.
     
151. 
     
152. */
     
153. cond = function(args)
     
154. {
     
155. for (var i = 0; i < arguments.length; i++)
     
156. {
     
157.   if(arguments[i] instanceof Array)
     
158.   {
     
159.    var cond = LispScript.Run(arguments[i][0]);  //先对参数求值
     
160.    //alert(cond);
     
161.    if(cond == true && arguments[i][1] != null)
     
162.     return LispScript.Run(arguments[i][1]);
     
163.   }
     
164. }
     
165. return [];
     
166. };
     
167. 
     
168. //则称为函数调用.它的值计算如下.每一个表达式先求值,然后e再求值.在e的求值过程中,每个出现在e中的的值是相应的在最近一次的函数调用中的值.
     
169. lambda = function(args, code)
     
170. {
     
171. if(code instanceof Array)
     
172. {
     
173.   var fun = new Function(args,
     
174.    "for(var i = 0; i < arguments.length; i++) arguments[i] = LispScript.Run(arguments[i]);return LispScript.Run("+code.toEvalString()+");");
     
175. 
     
176.   var globalFuncName = __funList.pop();
     
177.   
     
178.   fun._funName = globalFuncName;
     
179. 
     
180.   if(globalFuncName != null)
     
181.    self[globalFuncName] = fun;
     
182. 
     
183.   return fun;
     
184. }
     
185. 
     
186. return [];
     
187. };
     
188. 
     
189. </script>
     
190. <script>
     
191.         var prompt = '>';
     
192.         function initPrompt()
     
193.         {
     
194.                 if(cmd.value == '')
     
195.                         cmd.value = prompt;
     
196.         }
     
197.         function runLastCmd()
     
198.         {
     
199.                 if(window.event.keyCode == 13)
     
200.                 {
     
201.                         window.event.returnValue = false;
     
202.                        
     
203.                         var idx = cmd.value.lastIndexOf('\n') + 1;
     
204.                         idx += prompt.length;
     
205. 
     
206.                         var strCmd = cmd.value.substr(idx);
     
207.                         var output = '';
     
208.                         try
     
209.                         {
     
210.                                 var lisp = eval(strCmd);
     
211.                                 if(lisp instanceof Array)
     
212.                                 {
     
213.                                          output = LispScript.Run(lisp);
     
214.                                 }
     
215.                                 else
     
216.                                 {
     
217.                                         output = '未知命令';
     
218.                                 }
     
219.                         }
     
220.                         catch(e)
     
221.                         {
     
222.                                 output = '语法错误';
     
223.                         }
     
224.                         if(output instanceof Array)
     
225.                         {
     
226.                                 output = '[' + output + ']';
     
227.                         }
     
228.                         cmd.value += '\n' + output + '\n' + prompt;
     
229.                 }
     
230.                
     
231.         }
     
232. </script>
     
233. <textarea id=cmd style="width:600px;height:600px" onkeydown="runLastCmd()" onclick="initPrompt()">
     
234. </textarea>

复制代码运行代码另存代码

KinK

看得云里雾里的，看来需要先去了解LISP

zhuai

so cool

一叶千鸟

看的好吐血，建议楼主开头写下能具体实现什么让人惊叹的结果。

cosin

研究了 3 个月 用 js 实现 C++ 的可能性（搞VC出身，还是喜欢 C 的风格）
限制太多。。。

ShiningRay

我这里有一种实现方式，不用eval，因为eval的效率比较差，我用了别的办法，大家看看是否可行

1. var NIL = [];
   
2. var __globals = {};
   
3. Array.prototype.eval = function(){
   
4.     var len = this.length;
   
5.     if( len <= 0)
   
6.         return NIL;
   
7.     var f = this.shift();
   
8.     len--;
   
9.     var i = 0;
   
10.     while(i < len){
    
11.         if(this[i] instanceof Array){
    
12.             this[i] = this[i].eval();
    
13.         }
    
14.         i ++;
    
15.     }
    
16.     if(f instanceof Function){
    
17.         return f.apply(null, this);
    
18.     }else if(f instanceof String && typeof __globals[f] == "function" ){
    
19.         return __globals[f].apply(null, this);
    
20.     }else {
    
21.         throw "cannot find function";
    
22.     }
    
23. }
    
24. 
    
25. var quote = _ = function (){
    
26.     var len = arguments.length;
    
27.     var i = 0;
    
28.     var list = [];
    
29.     while(i < len){
    
30.         list.push(arguments[i++]);
    
31.     }
    
32.     return list;
    
33. }
    
34. 
    
35. function say(){
    
36.     WScript.Echo(arguments[0]);
    
37. }
    
38. function define(name, value){
    
39.     if(typeof __globals[name] != "undefined"){
    
40.         throw "name already used";
    
41.     }
    
42.     __globals[name] = value;
    
43. }

复制代码运行代码另存代码

我觉得用JavaScript原生代码执行Lisp确实比较奇怪，http://www.crockford.com/javascript/little.html 上面有一个Scheme解释器，便是用JavaScript实现的。
另外，楼上那位，JavaScript本来是为了嵌在别的语言如C++中执行的，本身不提供这种平台，而你却颠倒过来，想要JavaScript实现C++，分明是本末倒置。

月影

引用内容由 ShiningRay 发表于 2005-11-8 03:32 PM
我这里有一种实现方式，不用eval，因为eval的效率比较差，我用了别的办法，大家看看是否可行
[code]
var NIL = [];
var __globals = {};
Array.prototype.eval = function(){
    var len = this.length;
  ...

eval??
我的代码里也没有用javascript的eval的...
我用LispScript自身实现了它自己的eval函数...

另外我觉得楼上和我说的概念并不完全相同...:)

或许是另外一种思路了...

ShiningRay

你可能并没有看清楚我的代码

月影

引用内容由 ShiningRay 发表于 2005-11-8 10:49 PM
你可能并没有看清楚我的代码

你的Array.prototype.eval()方法基本上是实现了一个递归下降的语法分析器，然而并没有处理所有的问题。

首先，实现基本的操作如"quote","define"(这个似乎没有必要其实...=.=)并不复杂，其实真正有些复杂的是实现闭包，函数声明，_eval，setq，以及foreach...
这里需要考虑许多细节问题。

...
呃...不知道我这样说对不对...
其实单从Array.prototype.eval本身的思路来看和我的并没有太大区别...
我的也没有用到Jscript的eval啊...效率上两者应该是差不多的...

如果有兴趣的话，你可以按你的方法完善一下...也许能给我很大启发呢...

另外...稍微提议下...你的quote函数对于我来说是错误的（可能按你的实现你会认为有道理）...:P
因为我的LispScript中规定[quote,1]应当返回"1"而不是"[1]"
[quote,[1]]才是返回"[1]"
quote只接受一个参数...
至于为什么这样...
是因为我并没有打算让原子操作接受不定数量的参数(cond除外)...尽管我依然可以通过它们定义出可变参数的函数...
其实这里有一个“系统自治”的问题...描述起来还是比较复杂的...:P

[ 本帖由 月影 最后编辑于 2005-11-9 00:17 ]

月影

对不起...另外还得提一下...有一个非常致命的问题...

按你的方法没法实现[cond,[t1,v1],[t2,v2]...]

因为按要求当tn为true的时候应当返回vn并且不再计算v(n+1)的值（这很重要！！对于终止“迭代”来说）

另外“闭包”的实现你也欠考虑...闭包(lambda)比宏(define)要复杂得多.

具体来说，LispScript中应当支持下面这种迭代...

> [[lambda,[f],[f,[_,[b,c]]],[_,[lambda,[x],[cons,[_,a],x]]]
[a,b,c]

也就是说操作符、形参和程序体都应当可以是表达式，这反映了Lisp的一个基本思想——代码也是数据

同样的...LispScript中支持
[defun,[expr1],[expr2],[expr3]]
这里expr1的计算结果为函数名称，expr2的计算结果为形参列表，expr3的计算结果为函数体
而且它们可以重复迭代甚至递归！
也就是说我可以“将一个函数的返回值赋给它的形参列表”，这在任何其他语言中都是做不到的...

再者，Lisp还支持下面这样的...
[_eval,[expr],[maplist]]
实际上可以看作是另外一种函数形式，但是更接近于“闭包”...
你可以把expr看作指令（机器），maplist看作数据（环境），反之亦然（这才是Lisp惊人的地方）！
有了_eval之后，LispScript是自我解析的...也就是说它可以自我解释数据为指令，从而构成一个自治的完整系统。

[ 本帖由 月影 最后编辑于 2005-11-9 00:34 ]

ShiningRay

呵呵，我不精通Lisp

cosin

终于看完，看的有点明白
的确精练，简洁

山外青山楼外楼

灌水高手

本人在大学很是喜欢这类语言
人工智能语言主要使用递归方式（优化后）进行匹配而求解
不错，精华
（Javascript模拟其他程序或界面，基本上都列为精华，关键在于把Javascript运用的凌厉尽致）

dreamfly1024

如题

Rimifon

不解：

(function(){
LispScript = {
  Run : run
};

function run(code)
{
  return code;
};
})();

跟这一段：

LispScript=new Object;
LispScript.Run=function(code)
{
  return code;
}

有什么区别？

[ 本帖由 Rimifon 最后编辑于 2006-5-23 21:50 ]