C# Datum类代码示例

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