public static ContinueToCallAgent Instantiate(CallAgent agent, Context context, IContinuation succ, IFailure fail)
        {
            ContinueToCallAgent continuer = new ContinueToCallAgent(agent, succ);
            continuer.SetResult(new TwoTuple<Context, IFailure>(context, fail), context.Weight, "ContinueToCallAgent: Instantiate");

            return continuer;
        }

        public PatternMatch Match(AmbiguousPhrase phrase, IContinuation succ, IFailure fail)
        {
            //IArena arena = new QueueArena();
            //arena.Call();

            return null;
        }

 public Evaluator(double salience, ArgumentMode argumentMode, IContinuation valuesucc, IContinuation aftersucc, bool isUserInput)
     : base(salience, 2 * 4, 100, valuesucc)
 {
     this.argumentMode = argumentMode;
     this.aftersucc = aftersucc;
     this.isUserInput = isUserInput;
 }

        public int Call(object value, IContinuation succ, IFailure fail)
        {
            if (aborter.IsAborted)
                return 1;   // abort!

            List<IAction> namedacts = plugenv.GetNamedActions(resultType.Name);
            // Remove all actions that have already been used
            int ii = 0;
            while (ii < namedacts.Count)
            {
                if (searched.ContainsKey(namedacts[ii]))
                    namedacts.RemoveAt(ii);
                else
                {
                    searched.Add(namedacts[ii], 1);
                    ii++;
                }
            }

            if (namedacts.Count == 0)
                return arena.Fail(fail, salience, "no matching acts", succ);

            IContinuation next = new ContinueletWrapper(CheckAction, value, succ);
            IFailure more = new FailletWrapper(RecurseConversionAttempt, value, namedacts, succ);

            if (namedacts.Count == 1)
                return arena.Continue(next, salience, namedacts[0], more) + 2;

            TryValues<IAction> tryeach = new TryValues<IAction>();
            return arena.Call(tryeach, salience * .9, namedacts, next, more) + 3;
        }

        public override bool Call(object value, IContinuation succ, IFailure fail)
        {
            if (breakpointCall)
                Console.WriteLine("Breakpoint in MatchProduceAgent");
            Context context = (Context) value;
            bool production = context.LookupDefaulted<bool>("$production", false);
            if (!production)
            {
                object check = context.LookupDefaulted<object>("$check", null);

                if (check == null)
                {
                    // Matcher did not call us
                    List<IContent> contents = new List<IContent>();
                    Context child = new Context(context, contents);
                    // Put us into content stream, for matcher to find
                    contents.Add(new Value(this));
                    // Save this context-- we'll use it later!
                    child.Map["$argctx"] = context;

                    succ.Continue(child, fail);
                    return true;
                }

                Context argctx = context.LookupDefaulted<Context>("$argctx", context);
                // Add our context, shadowing variables in argctx
                Context argctxchild = argctx.ChildRange(0);
                argctxchild.AddMappings(context);

                return Match(check, argctxchild, succ, fail);
            }
            else
                return Produce(context, succ, fail);
        }

 public ContinueCodelet(double salience, Context context, IContinuation succ, IFailure fail)
     : base(context.Coderack, salience, 4 * 4, 5)
 {
     this.context = context;
     this.succ = succ;
     this.fail = fail;
 }

 public CallableAsEvaluable(ICallable callable, object value, IContinuation succ, IFailure fail)
 {
     this.callable = callable;
     this.value = value;
     this.succ = succ;
     this.fail = fail;
 }

        public override bool Call(object value, IContinuation succ, IFailure fail)
        {
            Context context = (Context) value;
            if (principleSource == null || assertionSource == null) {
                fail.Fail("ConceptNet sources missing", succ);
                return true;
            }

            Notion concept;
            if (!principleSource.TryGetValue(StarUtilities.ContentsCode(context, tagger, parser), out concept))
            {
                fail.Fail("Could not find produced in ConceptNet", succ);
                return true;
            }

            List<Assertion> assertions;
            if (!assertionSource.TryGetValue(new KeyValuePair<Notion, string>(concept, relation), out assertions))
                assertions = new List<Assertion>();

            List<IContent> contents = new List<IContent>();

            foreach (Assertion assertion in assertions)
            {
                contents.Add(new Word(assertion.Sentence));
                contents.Add(new Word(" ."));
            }

            succ.Continue(new Context(context, contents), fail);
            return true;
        }

 /// <summary>
 /// Initializes a new instance of the PromiseAsyncExecutionEventArgs
 /// class.
 /// </summary>
 /// <param name="continuation">
 /// The continuation to be invoked when the async operation completes.
 /// </param>
 public PromiseAsyncExecutionEventArgs(IContinuation continuation)
 {
     if (continuation == null)
     {
         throw new ArgumentNullException("continuation");
     }
     this.continuation = continuation;
 }

 public int Call(ICallable callable, double salience, object value, IContinuation succ, IFailure fail)
 {
     if (callable is IAgent)
         ((IAgent)callable).Initialize(this, salience);
     if (salience > 0)
         return callable.Call(value, succ, fail);
     return 1;
 }

 // Don't call this.  Call MatchAgainst
 protected Matcher(double salience, IParsedPhrase input, List<IParsedPhrase> unmatched, IContinuation succ)
     : base(salience, 2 * 4, 10, succ)
 {
     if (input == null)
         throw new NullReferenceException("Input cannot be null.");
     this.input = input;
     this.unmatched = new List<IParsedPhrase>(unmatched);   // make copy, or %opt-fail has effects
 }

        public override bool Match(object check, Context context, IContinuation succ, IFailure fail)
        {
            List<Relations.Relation> kinds = new List<Relations.Relation>();
            kinds.Add(Relations.Relation.AtTime);

            Thinker.SearchForMatch(salience, memory, kinds, (Datum) check, context, succ, fail);

            return true;
        }

        public static bool PrintContents(Context context, IContinuation succ, IFailure fail, params object[] args)
        {
            PluginEnvironment plugenv = (PluginEnvironment) args[0];
            POSTagger tagger = new POSTagger(plugenv);
            GrammarParser parser = new GrammarParser(plugenv);

            Console.WriteLine(StarUtilities.ProducedCode(context, tagger, parser));
            succ.Continue(new Context(context, new List<IContent>()), fail);
            return true;
        }

 public int Fail(IFailure fail, double salience, string reason, IContinuation skip)
 {
     // Clone it!
     fail = (IFailure)fail.Clone();
     if (fail is IAgent)
         ((IAgent)fail).Initialize(this, salience);
     if (salience > 0)
         return fail.Fail(reason, skip);
     return 1;
 }

        public ContinuationAppender(Context master, IContinuation succ)
        {
            this.master = master;
            this.succ = succ;
            indexes = 0;

            // filled upon continuation
            callers = new List<uint>();
            completes = new List<Context>();
        }

 bool FailToTryToRescue(IArena arena, double salience, string reason, IContinuation skip, params object[] args)
 {
     TryToRescueMatch tryToRescueMatch = (TryToRescueMatch) args[0];
     IParsedPhrase input = (IParsedPhrase) args[1];
     PatternTemplateSource patternTemplateSource = (PatternTemplateSource) args[2];
     IContinuation succ = (IContinuation) args[3];
     IFailure fail = (IFailure) args[4];
     Coderack coderack = (Coderack) args[5];
     return tryToRescueMatch.CallRescue(coderack, input, patternTemplateSource, reason, skip, succ, fail);
 }

 public int Continue(IContinuation cont, double salience, object value, IFailure fail)
 {
     // Clone it!
     cont = (IContinuation)cont.Clone();
     if (cont is IAgent)
         ((IAgent)cont).Initialize(this, salience);
     if (salience > 0)
         return cont.Continue(value, fail);
     return 1;
 }

        public override bool Produce(Context context, IContinuation succ, IFailure fail)
        {
            object var = context.LookupDefaulted<object>("$p$" + name, null);

            if (var is IParsedPhrase)
                succ.Continue((IParsedPhrase)var, fail);

            succ.Continue(null, fail);

            return true;
        }

        public PatternTemplateSource(PatternTemplateSource parent, Coderack coderack, double salience, IContinuation succ)
        {
            pattern = parent.pattern;
            template = parent.template;
            score = parent.score;
            source = parent.source;

            this.coderack = coderack;
            this.salience = salience;
            this.succ = succ;
        }

 public Thinker(double salience, Memory memory, List<Relations.Relation> kinds, Datum check, IContinuation succ)
     : base(salience, 4 * 7, timeEach, succ)
 {
     this.memory = memory;
     this.kinds = kinds;
     directchecks = new List<Datum>();
     directchecks.Add(check);
     parentchecks = new Queue<Concept>();
     parentchecks.Enqueue(check.Left);
     parentchecks.Enqueue(check.Right);
 }