如何在JavaScript中实现lambda/匿名函数

因此，我尝试使用JavaScript实现LISP的一个子集。我被两件与lambdas有关的事情缠住了

如何实现创建lambda的功能，同时向其提供参数并立即对其进行计算？例如：

((lambda(x)(* x 2)) 3)

目前，我在eval循环中硬编码了此功能，如下所示：

else if (isArray(expr)){
      if (expr[0][0] === 'lambda' || expr[0][0] === 'string') { 
         console.log("This is a special lambda");
         var lambdaFunc = evaluate(expr[0], env)
         var lambdaArgs = [];
         for(var i = 1; i < expr.length; i++){
            lambdaArgs.push(expr[i]);
         }         
         return lambdaFunc.apply(this, lambdaArgs);
      }

else if (expr[0] === 'lambda') { // (lambda args body)
        console.log(expr + " is a lambda statement");
        var args = expr[1];
        var body = expr[2];
        return createLambda(args, body, env);
    }

function runLambda(){ var lambdaEnvironment = new environment(env, "lambda 
environment"); for (var i = 0; i < arguments.length; i++){ 
lambdaEnvironment.add(args[i], evaluate(arguments[i], env)); } return 
evaluate(body, lambdaEnvironment); },10

lambda函数是这样创建的：

else if (isArray(expr)){
      if (expr[0][0] === 'lambda' || expr[0][0] === 'string') { 
         console.log("This is a special lambda");
         var lambdaFunc = evaluate(expr[0], env)
         var lambdaArgs = [];
         for(var i = 1; i < expr.length; i++){
            lambdaArgs.push(expr[i]);
         }         
         return lambdaFunc.apply(this, lambdaArgs);
      }

else if (expr[0] === 'lambda') { // (lambda args body)
        console.log(expr + " is a lambda statement");
        var args = expr[1];
        var body = expr[2];
        return createLambda(args, body, env);
    }

function runLambda(){ var lambdaEnvironment = new environment(env, "lambda 
environment"); for (var i = 0; i < arguments.length; i++){ 
lambdaEnvironment.add(args[i], evaluate(arguments[i], env)); } return 
evaluate(body, lambdaEnvironment); },10

创建lambda的单独函数：

function createLambda(args, body, env){ // lambda args body
   function runLambda(){
         var lambdaEnvironment = new environment(env, "lambda environment");
         for (var i = 0; i < arguments.length; i++){
            lambdaEnvironment.add(args[i], evaluate(arguments[i], env));
         }
         return evaluate(body, lambdaEnvironment);
   }  
   return runLambda;
}

我预计以下人员将返回40人：

((repeat twice) 10)

但是，它会返回一个如下所示的列表：

else if (isArray(expr)){
      if (expr[0][0] === 'lambda' || expr[0][0] === 'string') { 
         console.log("This is a special lambda");
         var lambdaFunc = evaluate(expr[0], env)
         var lambdaArgs = [];
         for(var i = 1; i < expr.length; i++){
            lambdaArgs.push(expr[i]);
         }         
         return lambdaFunc.apply(this, lambdaArgs);
      }

else if (expr[0] === 'lambda') { // (lambda args body)
        console.log(expr + " is a lambda statement");
        var args = expr[1];
        var body = expr[2];
        return createLambda(args, body, env);
    }

function runLambda(){ var lambdaEnvironment = new environment(env, "lambda 
environment"); for (var i = 0; i < arguments.length; i++){ 
lambdaEnvironment.add(args[i], evaluate(arguments[i], env)); } return 
evaluate(body, lambdaEnvironment); },10

函数runLambda（）{var lambdaEnvironment=new environment（env），lambda 环境）；for（var i=0；i 你知道这里可能缺少什么吗

全JavaScript

//functions for parsing invoice String

function parse(exp) {
    return readFromTokes(tokenize(exp));//code
}


function isNumeric(arg){
    return !isNaN(arg);
}

function isArray(obj){
    return !!obj && obj.constructor === Array;
}

function readFromTokes(exp){
   //Create abstract syntax tree
   if (exp.length == 0) {
   }
   var token = exp.shift();
   if (token == '('){
      var L = [];
      while (exp[0] != ')') {
         L.push(readFromTokes(exp));
         }         
        exp.shift(); //remove end paranthesis
        return L;
   } else {
         if (token == ')') {
            console.log("Unexpected )");
         } else {
            return atom(token);
         }
   }
}

function tokenize(exp){
   //Convert a program in form of a string into an array (list)
   var re = /\(/g;
   var re2 = /\)/g;
   exp = exp.replace(re, " ( ");
   exp = exp.replace(re2, " ) ");
   exp = exp.replace(/\s+/g, ' ');
   exp = exp.trim().split(" ");
   return exp;
}

function atom(exp){
   if (isNumeric(exp)) {
   return parseInt(exp); //A number is a number
   } else {
      return exp; //Everything else is a symbol
   }
}

function environment(parentEnvironment, name){
    var bindings = [];
    var parent = parentEnvironment;
    var name = name;

    function add(variable, value){
        console.log("variable: " + variable + " value: " + value);
        bindings.push([variable, value]);
    }

    function printName(){
      console.log(name);
    }

    function print() {
        console.log("printing environment: ")
        for (var i = 0; i < bindings.length; i++){
            console.log(bindings[i][0] + " " + bindings[i][1]);
        }
    }

    function get(variable){
        for (var i = 0; i < bindings.length; i++){
            if (variable == bindings[i][0]){
                return bindings[i][1];
            }
        }
        if (parent != null){
            return parent.get(variable);
        } else {
        console.log("No such variable");
            return false;
        }
    }

    function getParent(){
        return parent;
    }

    this.add = add;
    this.get = get;
    this.getParent = getParent;
    this.print = print;
    this.printName = printName;
    return this;
}

function addPrimitives(env){
   env.add("+", function() {var s = 0; for (var i = 0; i<arguments.length;i++){ s += arguments[i];} return s});
   env.add("-", function() {var s = arguments[0]; for (var i = 1; i<arguments.length;i++){ s -= arguments[i];} return s});
   env.add("*", function() {var s = 1; for (var i = 0; i<arguments.length;i++){ s *= arguments[i];} return s});
   env.add("/", function(x, y) { return x / y });
   env.add("false", false);
   env.add("true", true);
   env.add(">", function(x, y){ return (x > y) });
   env.add("<", function(x, y){ return (x < y) }); 
   env.add("=", function(x, y){ return (x === y)});
   env.add(">=", function(x, y){ if (x >= y){return true;} else {return false;}}); 
   env.add("<=", function(x, y){ if (x <= y){return true;} else {return false;}});
   env.add("eq?", function() {var s = arguments[0]; var t = true; for(var i = 1; i<arguments.length; i++){ if (arguments[i] != s) {t = false }} return t;});
   env.add("cons", function(x, y) { var temp = [x]; return temp.concat(y); });
   env.add("car", function(x) { return x[0]; });
   env.add("cdr", function(x) { return x.slice(1); });
   env.add("list", function () { return Array.prototype.slice.call(arguments); });
   env.add("list?", function(x) {return isArray(x); });
   env.add("null", null);
   env.add("null?", function (x) { return (!x || x.length === 0); });
}


function createLambda(args, body, env){ // lambda args body
   function runLambda(){
     var lambdaEnvironment = new environment(env, "lambda environment");
         for (var i = 0; i < arguments.length; i++){
            lambdaEnvironment.add(args[i], evaluate(arguments[i], env));
         }
         return evaluate(body, lambdaEnvironment);
   }  
   return runLambda;
}

function evaluate(expr, env) {
    console.log(expr + " has entered evaluate loop");
    if (typeof expr === 'string') {
        console.log(expr + " is a symbol");
        return env.get(expr);
    } else if (typeof expr === 'number') {
        console.log(expr + " is a number");
        return expr;
    } else if (expr[0] === 'define') { // (define var value)
        console.log(expr + " is a define statement");
        var newVar = expr[1];
        var newVal = evaluate(expr[2], env);
        env.add(newVar, newVal);
        return env;
    } else if (expr[0] === 'lambda') { // (lambda args body)
        console.log(expr + " is a lambda statement");
        var args = expr[1];
        var body = expr[2];
        return createLambda(args, body, env);
    } else if (expr[0] === 'quote') {
        return expr[1];
    } else if (expr[0] === 'cond'){
        console.log(expr + " is a conditional");
        for (var i = 1; i < expr.length; i++){
            var temp = expr[i];
            if (evaluate(temp[0], env)) {
                console.log(temp[0] + " is evaluated as true");
                return evaluate(temp[1], env);
            }
        }
        console.log("no case was evaluated as true");
        return;
    } else if (expr[0] === 'if') {
        console.log(expr + "is an if case");
        return function(test, caseyes, caseno, env){
            if (test) {
                return evaluate(caseyes, env);
            } else {
                return evaluate(caseno, env);
            }
        }(evaluate(expr[1], env), expr[2], expr[3], env); 
    } else if (typeof expr[0] === 'string'){
        console.log(expr + " is a function call");
        var lispFunc = env.get(expr[0]);
        var lispFuncArgs = [];        
        for(var i = 1; i < expr.length; i++){
        lispFuncArgs.push(evaluate(expr[i], env));
       }
       return lispFunc.apply(this, lispFuncArgs);
    } else if (isArray(expr)){
        if (expr[0][0] === 'lambda' || expr[0][0] === 'string') { 
            console.log("This is a special lambda");
            var lambdaFunc = evaluate(expr[0], env)
            var lambdaArgs= [];
            for(var i = 1; i < expr.length; i++){
                lambdaArgs.push(expr[i]);
            }         
            return lambdaFunc.apply(this, lambdaArgs);
        } else { 
             console.log(expr + " is a list");
             var evaluatedList = [];
             for(var i = 0; i < expr.length; i++){
                 evaluatedList.push(evaluate(expr[i], env));
             }
             return evaluatedList;
        }
    } else {
        console.log(expr + " cannot be interpreted");
    }
}


var globalEnvironment = new environment(null, "Global");

addPrimitives(globalEnvironment);

function start(string) {
    return evaluate(parse(string), globalEnvironment);
}

var output = function (string) {
    try {
        document.getElementById('debugdiv').innerHTML = start(string);
    } catch (e) {
        document.getElementById('debugdiv').innerHTML = e.name + ': ' + e.message;
    }
};

//用于分析发票字符串的函数
函数解析（exp）{
返回readFromTokes（标记化（exp））；//代码
}
函数为数值型（arg）{
返回！isNaN（arg）；
}
函数isArray（obj）{
return！！obj&&obj.constructor==数组；
}
函数readFromTokes（exp）{
//创建抽象语法树
如果（exp.length==0）{
}
var token=exp.shift（）；
如果（令牌=='（'）{
var L=[]；
而（exp[0]！='）'）{
L.push（readFromTokes（exp））；
}         
exp.shift（）；//删除结束符
返回L；
}否则{
如果（令牌=='）'）{
console.log（“意外）”）；
}否则{
返回原子（令牌）；
}
}
}
函数标记化（exp）{
//将字符串形式的程序转换为数组（列表）
var re=/\（/g；
var re2=/\）/g；
exp=exp.replace（re，“（”）；
exp=exp.replace（re2，“）”；
exp=exp.replace（/\s+/g'，）；
exp=exp.trim（）.split（“”）；
返回经验；
}
函数原子（exp）{
if（isNumeric（exp））{
return parseInt（exp）；//数字就是数字
}否则{
return exp；//其他所有内容都是一个符号
}
}
函数环境（父环境，名称）{
var绑定=[]；
var parent=parentEnvironment；
变量名称=名称；
函数添加（变量、值）{
console.log（“变量：+variable+”值：+value”）；
push（[变量，值]）；
}
函数printName（）{
console.log（名称）；
}
函数打印（）{
日志（“打印环境：”）
for（var i=0；ienv.add（“您不检查操作数的结构，看它是否是
lambda
您
eval
操作数。
eval
的标准方法是检查它是否是基元类型，然后检查特殊形式和宏，然后在应用之前求值运算符和操作数

只需删除
expr[0][0]=='lambda'| | expr[0][0]=='string'
为真的部分，而不只是返回应用操作数所需的形式求值：

else if（isArray（expr））{
const fn=评估（expr[0]，env）；
const evaluatedList=[]；
对于（变量i=1；i

createLambda
是错误的，因为您在错误的环境中计算参数。这是正确的，因为已经计算了参数：

函数createLambda（args，body，env）{//lambda args body
函数runLambda（）{
const lambdaEnvironment=新环境（env，“lambda环境”）；
for（设i=0；i<代码> >代码（x= > x* 2）（3）< /代码>我想它更容易转换和<代码> EVA/CODE >……这个问题非常接近“太宽”，有点接近“帮助我的代码不起作用”。请考虑把它修剪到问问题的最低限度。