go
--

Initiates the execution of productions in Soar and controls its duration.
This is the most general command for running Soar.  It takes two optional
arguments, one specifying how many things to run, and one specifying what
type of things to run.

SYNTAX

(go [integer | `forever'] [type])

type ::= `p' | `e' | `d' | `g' | `ps' | `s' | `o' | context-variable
context-variable ::= `<g>'   | `<p>'   | `<s>'   | `<o>'   |
                     `<sg>'  | `<sp>'  | `<ss>'  | `<so>'  |
                     `<ssg>' | `<ssp>' | `<sss>' | `<sso>'

The following types are available:

[p] run Soar for n phases.  A phase is either an input phase, preference     
     phase, working memory phase, output phase, or quiescence phase.
     
[e] run Soar for n elaboration cycles.  (For purposes of this command,     
     quiescence phase is counted as an elaboration cycle.)
     
[d] run Soar for n decision cycles.     
     
[g] run Soar until the nth time a goal is selected.     
     
[ps] run Soar until the nth time a problem space is selected.     
     
[s] run Soar until the nth time a state is selected.     
     
[o] run Soar until the nth time an operator is selected.     
     
[context-variable] run Soar until the nth time a selection is made for that     
     particular context slot, or until the context stack pops to above that
     context.  For example, <ss> will stop when a new state is selected for
     the superstate slot.

Go remembers each argument you give it each time.  If you don't give
arguments next time, it uses the ones from the previous time.

Examples:

(go 5 d)   --> run for 5 decision cycles
(go e)     --> run for another 5 elaboration cycles
(go 1 g)   --> run until the next goal is selected (i.e., until the
               next time an impasse arises)
(go <so>)  --> run until the next superoperator is selected (or until
               the supergoal goes away)
(go 3 <o>) --> run for 3 operator selections at this level (continuing
               through any subgoals that arise)