!7

sS script1 = "Assert (True).";
sS script2 = "Assert (False).";

sS script = [[
  Make an empty thought space X.
  Assert (X is empty).
  Add (God is good) to X.
  Assert (Not (X is empty)).
  Add (Remove (God is good)) to X.
  Apply always rules in X.
  Assert (X is empty).
]];

sS bla = [[
  // concepts
  zivsiiacmvqrolto - True
  zqbbvhdeuzyhewed - False
  jamvyfwypzbptvle - Make an empty thought space X.
  matnhiruhwprdiir - Add (X) to Y.
  aaedrmcbfcsubkkf - Apply rule (X) to Y.
  yvmxaacduvvomgqi - X is empty
  rzryqdohxtczvzgn - Assert (X).
  wynynoujiakixjus - Not (X)
]];

// head -> voidfunc(Lisp)
static new HashMap<S, O> executors;

static HashMap<S, ThoughtSpace> thoughtSpaces = new HashMap;

p {
  myTruth(bla);
  lispStandardEvaluators();
  
  // Assert (X).
  executors.put("rzryqdohxtczvzgn", voidfunc(Lisp l) {
    l = l.get(0);
    if (!isTrue(callLispEvaluator(l)))
      fail("Not true: " + l);
  });
  
  // Make an empty thought space X.
  executors.put("jamvyfwypzbptvle", voidfunc(Lisp l) {
    S name = l.raw(0);
    thoughtSpaces.put(name, new ThoughtSpace);
  });
  
  // X is empty (thought space)
  lispEvaluator("yvmxaacduvvomgqi", new F1<Lisp, Bool>() {
    Bool get(Lisp l) {
      ret isEmpty(getThoughtSpace(l.raw(0)).statements);
    }
  });
  
  // Add (X) to Y. (thought space)
  executors.put("matnhiruhwprdiir", voidfunc(Lisp l) {
    getThoughtSpace(l.raw(1)).addStatement(l.get(0));
  });
  
  // Apply rule (X) to Y. (thought space)
  executors.put("aaedrmcbfcsubkkf", voidfunc(Lisp l) {
    applyRule_all_ts(getThoughtSpace(l.raw(1)), l.get(0));
  });
  
  assertScriptSucceeds(script1);
  assertScriptFails(script2);
  assertScriptSucceeds(print(xyzToNewIDs(script)));
  print("OK");
}

svoid assertScriptSucceeds(S script) {
  for (Lisp cmd : linesToLisp(script)) {
    O executor = executors.get(cmd.head);
    if (executor == null) fail("No executor for " + cmd);
    callF(executor, cmd);
  }
}

svoid assertScriptFails(fS script) {
  assertFail_verbose(r { assertScriptSucceeds(script); });
}

static LinkedHashSet<Lisp> getThoughtSpace(S name) {
  ret assertNotNull(thoughtSpaces.get(name));
}