public override LispNode Evaluate(Env env) { LispNode func = null; LambdaNode lambdaNode = null; func = What.Evaluate(env); if (!(func is LambdaNode)) { return(null); } lambdaNode = func as LambdaNode; if (lambdaNode.Arguments.Count != Arguments.Count) { return(null); } Env newEnv = new Env(lambdaNode.Env); // use the lambda env, not the global env, for lexical closures for (int i = 0; i < Arguments.Count; i++) { newEnv.Add(lambdaNode.Arguments[i], Arguments[i].Evaluate(env)); } return(lambdaNode.Call(newEnv)); }
public override LispNode Evaluate(Env env) { if (env.Find(VariableName) == null) { return(null); } LispNode exp = Expression.Evaluate(env); env.Set(VariableName, exp); return(exp); // probably not ideomatic scheme but we can chain set!s. }
public LispNode a, b, c; // if a then b else c public override LispNode Evaluate(Env env) { object test = a.Evaluate(env); if (!(test is BoolNode)) { return(null); } else if ((test as BoolNode).Value) { return(b.Evaluate(env)); } else { return(c.Evaluate(env)); } }
public object Execute(String exp) { LispNode program = Read(TokenizeStream(exp)); Env env = CreateGlobals(); LispNode result = program.Evaluate(env); if (result is IntNode) { return((result as IntNode).Value); } else if (result is BoolNode) { return((result as BoolNode).Value); } else if (result is QuoteNode) { return((result as QuoteNode).Value); } else { return(null); } }
public virtual LispNode Call(Env env) { return(Body.Evaluate(env)); }
public override LispNode Evaluate(Env env) { env.Add(Name, Expression.Evaluate(env)); return(this); // return this??? }