C# Datum.ToArray方法代码示例

 public override Continuation Evaluate(Continuation s, Datum args)
 {
     var argArray = args.ToArray();
     var expression = argArray[0];
     var environment = (Environment) argArray[1].CastObject();
     return s.Evaluate(environment, expression);
 }

 public override Continuation Evaluate(Continuation oldContinuation, Datum args)
 {
     // Replace the old continuation with the new continuation - but pass in the
     // supplied argument as the 'return value' of the new continuation.
     var returnValue = args.ToArray()[0];
     return c.PushResult(returnValue);
 }

 public Datum Evaluate(Datum args)
 {
     var argArray = args.ToArray();
     var names = argArray.Select(x => x.CastString()).ToArray();
     var fullname = string.Join(".", names);
     return GetTypeEx(fullname).ToAtom();
 }

 private static Datum evaluate(Continuation c, Datum args)
 {
     var argList = args.ToArray();
     if (argList.Length != 1)
         throw c.error("invalid syntax '{0}'", args);
     return argList[0];
 }

 public Datum Evaluate(Datum args)
 {
     var argArray = args.ToArray();
     if (argArray.Length != 1)
         throw DatumHelpers.error("Expected a single argument. Got {0}", argArray.Length);
     return eval(argArray[0]);
 }

 public Datum Evaluate(Datum args)
 {
     var argDatums = args.ToArray();
     if (argDatums.Length != 2)
         throw DatumHelpers.error("Exactly 2 arguments expected");
     return eval(argDatums[0], argDatums[1]);
 }

 public static Datum GetSingle(Datum args)
 {
     var argArray = args.ToArray();
     if (argArray.Length != 1)
         throw DatumHelpers.error("Expected a single argument. Got {0}", argArray.Length);
     return argArray[0];
 }

 public override Continuation Evaluate(Continuation c, Datum args)
 {
     var argArray = args.ToArray();
     if (argArray.Length != 2)
         throw DatumHelpers.error("Invalid syntax. ArgCount ({0}) != 2. Usage: (execute-with-error-handler <error-function> <fn>)", argArray.Length);
     var errorHandler = makeErrorHandler(c.ErrorHandler, (StackFunction)argArray[0]);
     var fn = (StackFunction)argArray[1];
     return fn.Evaluate(c.NewErrorHandler(errorHandler), DatumHelpers.compound());
 }

            public Datum Evaluate(Datum args)
            {
                var argArray = args.ToArray();

                var target = unwrapDatum(argArray[0]);
                var methodArgs = unwrap(args.Enumerate().Skip(1));
                var result = target.GetType().InvokeMember(name, BindingFlags.Default | BindingFlags.InvokeMethod, null, target, methodArgs);
                return result.ToAtom();
            }

 public override Continuation Evaluate(Continuation c, Environment env, Datum args)
 {
     var argList = args.ToArray();
     if (argList.Length != 2)
         throw c.error("Expected 2 arguments: (set! <symbol> <expression>). Got {0} instead", argList.Length);
     var name = argList[0].CastIdentifier();
     var expression = argList[1];
     c = c.PushTask(new SetName(env, name));
     return c.Evaluate(env, expression);
 }

 public override Continuation Evaluate(Continuation c, Datum args)
 {
     var datumArgs = args.ToArray();
     if (datumArgs.Length != 2)
         throw c.error("Apply expects 2 arguments. {0} passed", datumArgs.Length);
     var function = datumArgs[0] as StackFunction;
     if (function == null)
         throw c.error("'{0}' is not a function", datumArgs[0]);
     return function.Evaluate(c, datumArgs[1]);
 }

 public Datum Evaluate(Datum args)
 {
     var a = args.ToArray();
     if (a.Length != 1)
         // TODO: Move this error boiler plate into DatumHelpers
         throw error("Incorrect arguments. Expected {0}, got {1}", 1, a.Length);
     var function = a[0] as StackFunction;
     if (function == null)
         throw error("Expected function argument");
     return ToMacro(function);
 }

 public override Continuation Evaluate(Continuation oldContinuation, Datum args)
 {
     // Replace the old continuation with the new continuation - but pass in the
     // supplied argument as the 'return value' of the new continuation.
     var argArray = args.ToArray();
     // We allow calling a "continuation" with 0 args. Such a continuation
     // only arises from the error function.
     // TODO: we should differentiate the two with an "expected args" member which we can error check.
     if (argArray.Length == 0)
         return c;
     return c.PushResult(argArray[0]);
 }

 public override Continuation Evaluate(Continuation c, LexicalEnvironment env, Datum args)
 {
     var argList = args.ToArray();
     if (argList.Length != 2)
         throw c.error("Expected 2 arguments: (define <symbol> <expression>). Got {0} instead", argList.Length);
     var name = argList[0].CastSymbol();
     var expression = argList[1];
     c = c.PushTask(
         tc => { env.Define(name, tc.Result);
                 return tc;},
         "define '{0}'", name);
     return c.Evaluate(env, expression);
 }

        private static Datum evaluate(Continuation c, Environment env, Datum args)
        {
            var macroArgs = args.ToArray();
            if (macroArgs.Length % 2 != 0)
                throw c.error("Invalid macro syntax for lambda. Argument count for '{0}' is not even ({1}). Syntax is (lambda [args body]+)", args, macroArgs.Length);

            var argBodies = new List<ArgBody>();
            for (var i = 0; i < macroArgs.Length; i += 2)
            {
                var closureArgs = macroArgs[i];
                var body = macroArgs[i + 1];
                argBodies.Add(new ArgBody(closureArgs, body));
            }
            return new Closure(env, argBodies);
        }