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 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];
 }

 protected override Datum eval(Datum arg1, Datum arg2)
 {
     if ((arg1 as Pair) != null ||
         (arg2 as Pair) != null)
         return DatumHelpers.atom(ReferenceEquals(arg1, arg2));
     return DatumHelpers.atom(arg1.Equals(arg2));
 }

 public static Datum car(Datum d)
 {
     var pair = d as Pair;
     if (pair == null)
         throw error("'{0}' is not a pair", d);
     return pair.First;
 }

 public override Continuation Evaluate(Continuation c, LexicalEnvironment env, Datum args)
 {
     var argArray = DatumHelpers.enumerate(args).ToArray();
     Array.Reverse(argArray);
     c = c.PushTask(new InvokeFunction(function, argArray.Length));
     return argArray.Aggregate(c, (current, arg) => current.Evaluate(env, arg));
 }

 private static Continuation asContinuation(Datum arg)
 {
     var cfunction = arg as CallCC.ContinuationFunction;
     if (cfunction == null)
         throw DatumHelpers.error("'{0}' is not a continuation", arg);
     return cfunction.Continuation;
 }

 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);
 }

 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();
     var names = argArray.Select(x => x.CastString()).ToArray();
     var fullname = string.Join(".", names);
     return GetTypeEx(fullname).ToAtom();
 }

 public static object castObject(Datum d)
 {
     var a = d as Atom;
     if (a == null)
         throw error("Expected '{0}' to be an atom, but got '{1}' instead", d, d.GetType().Name);
     return a.Value;
 }

        public override void Write(Datum aggregatedDatum)
        {
            if (!App.Available) return;

               if (UseLog)
             base.Write(aggregatedDatum);

               var node = ReceiverNode;

               if (node.IsNullOrWhiteSpace()) return;

               string site;
               if (SiteName.IsNotNullOrWhiteSpace())
             site = SiteName;
               else
             site = "{0}::{1}@{2}".Args(App.Name, App.InstanceID, System.Environment.MachineName);

               try
               {
               if (m_Client==null)
                   m_Client = new TelemetryReceiverClient(ReceiverNode);

               m_Client.Send(site, aggregatedDatum);
               }
               catch(Exception error)
               {
               cleanupClient();
               WriteLog(MessageType.Error, error.ToMessageWithType(), from: "{0}.{1}".Args(GetType().Name, "Write(datum)") );
               }
        }

 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 function = UnaryFunction.GetSingle(args) as StackFunction;
     if (function == null)
         throw error("Expected function argument");
     return ToMacro(function);
 }

 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]);
 }

 // Create a "special form" for a symbol that has either "." or "/" inside it.
 private static Datum buildSymbolForm(Datum name, IEnumerable<string> contents)
 {
     // "prefix" with a 'dot' so that higher level macros can interpret it.
     // This means you can't have normal symbols containing dots, which is a
     // small price to pay IMO.
     var args = compound(contents.Select(c => c == "" ? nil : parseSymbol(c)).ToArray());
     return cons(name, args);
 }

 public Datum Evaluate(Environment env, Datum datum)
 {
     var c = StackContinuation.Empty
         .PushTask(null)
         .PushResult(null)
         .Evaluate(env, datum);
     return Evaluate(c);
 }

 /// <summary>
 /// 拷贝构造函数。
 /// </summary>
 /// <param name="datum">大地坐标系对象。</param>
 /// <exception cref="ArgumentNullException">当大地坐标系对象为 Null 时抛出异常。</exception>
 public Datum(Datum datum)
 {
     if (datum == null) throw new ArgumentNullException();
     this.Name = datum.Name;
     if (datum.Spheroid != null)
         this.Spheroid = new Spheroid(datum.Spheroid);
     this.Type = datum.Type;
 }

 public Datum Evaluate(Statistics statistics, LexicalEnvironment env, Datum datum)
 {
     env.Statistics = statistics;
     var c = Continuation.Create(statistics)
         .PushTask(null)
         .PushResult(null)
         .Evaluate(env, datum);
     return Evaluate(c);
 }

 public void Set(string name, Datum newValue)
 {
     IEnvironment p;
     var e = find(name, out p);
     if(e == null)
         p.Set(name, newValue);
     else
         e.value = newValue;
 }

 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());
 }