!7 cmodule PhilosophyBot extends DynPrintLog { transient S program = [[ "memory" memory can mean RAM RAM has a size I have RAM input is x & x can mean y => pretend (input is y) input is x => activate facts containing x I have x => Ask something about (my x) I have x => (my x) exists // General patterns in flight now: // my * // Ask something about * // pretend * // input is * // (and more) Procedures ---------- Ask something about x => proc { if (x exists): ask (what is x?) else: ask (does x exist?) for (y | x has a y): assume ((the y of x) exists) ask something about (the y of x) } the answer to x is y => the answer to x is known ask x & the answer to x is known => don't (ask x) Ask x => proc { print x on input: if (input is a valid answer to x): store (the answer to x is input) } (x exists) is a valid answer to (does x exist) (x doesn't exist) is a valid answer to (does x exist) (x is y) is a valid answer to (what is x) ]]; record LogicRule(lhs, rhs) {} record And(a, b) {} record If(condition, thenBlock, elseBlock) {} record For(var, condition, body) {} transient Set facts = linkedCISet(); transient new L logicRules; transient new AllOnAll rulesOnFacts; transient new LS proceduresToRun; transient Set vars = litciset("x", "y"); void addFact(S fact) { print("Got fact: " + fact); if (facts.add(fact)) { rulesOnFacts.newB(fact); // to combine it with the rules // Check if it's a procedure LS tok = javaTokWithBrackets(fact); if (countCodeTokens(tok) == 2 && eqic(getCodeToken(tok, 0), "proc") && isCurlyBracketed(getCodeToken(tok, 1))) { // It's a procedure! S proc = uncurly_keepSpaces(getCodeToken(tok, 1)); if (proceduresToRun.add(proc)) { print("Got procedure:"); print(indentx("> ", proc)); } } } } void runProcedure(S proc) { print("Running procedure."); L commands = parseProcedure(proc); for (O cmd : commands) { if cmd is If(condition, thenBlock, elseBlock) { } else fail("Unknown command: " + cmd); } } L parseProcedure(S proc) { //printStruct(proc); proc = withoutLinesEmptyAfterTrim(proc); //printStruct(proc); proc = autoUnindent(proc); //printStruct(proc); print(indentx("> ", proc)); LS l = groupPythonStyleIndents(proc); pnl("unpythonized ", l); new L out; for i over l: { S s = l.get(i); LS tok = javaTokWithBrackets(s); if (eqic(firstCodeToken(tok), "if")) { assertEquals(s, ":", getCodeToken(tok, 2)); out.add(new If(deRoundBracket(getCodeToken(tok, 1)), joinSubList(tok, 3*2), null)); } else if (eqic(firstCodeToken(tok), "else")) { O last = last(out); if (!last instanceof If) fail("Else without if"); assertEquals(s, ":", getCodeToken(tok, 1)); ((If) last).elseBlock = joinSubList(tok, 2*2); } else if (eqic(firstCodeToken(tok), "for")) { assertEquals(s, ":", getCodeToken(tok, 2)); S cond = getCodeToken(tok, 1); // cond looks like: "(y | x has a y)" cond = deRoundBracket(cond); LS tok2 = javaTok(cond); assertEquals(cond, "|", getCodeToken(tok2, 1)); S var = assertIdentifier(cond, getCodeToken(tok2, 0)); S actualCondition = trimJoinSubList(tok2, 2*2+1); out.add(new For(var, actualCondition, joinSubList(tok, 3*2))); } else out.add(s); } pnl("Parsed procedure ", out); ret out; } O splitAtAmpersand2(S s) { LS l = tok_splitAtAmpersand(s); if (l(l) == 1) ret s; ret new And(first(l), splitAtAmpersand2(join(" & ", dropFirst(l)))); } void applyLogicRuleToFact(LogicRule rule, S fact) { O lhs = rule.lhs, rhs = rule.rhs; O cond, remaining; if lhs is And(O a, O b) { cond = a; remaining = b; } else cond = lhs; // now we match the condition with the fact SS map = gazelle_zip((S) cond, fact); if (map == null) ret; // no match print("gazelle zip => " + map); // are only variables changed? if (!allKeysAreInSet(map, vars)) ret /*with print("Non-variable changes, exiting")*/; // Now we have a proper mapping with the keys being variables! print("Match."); // Apply mapping to right hand side S rhs_replaced = join(replaceCodeTokensUsingMap(javaTok((S) rhs), map)); print(+rhs_replaced); // Add as fact addFact(rhs_replaced); } start-thread { // split into paragraphs and unindent LS paragraphs = map autoUnindent(map rtrim(splitAtEmptyLines(program))); print("Got " + n2(paragraphs, "parapraph")); // print the parapraphs print(joinWithEmptyLines(map(s -> indentx("> ", s), paragraphs))); // throw away comment-only and quoted paragraphs (assume it's a title) LS paragraphs2 = antiFilter(paragraphs, s -> isSingleLine(trim(s)) && isQuoted(trim(s)) || countJavaTokens(s) == 0 || endsWith(rtrim(s), "----")); print("Got " + n2(paragraphs2, "filtered paragraph")); print(joinWithEmptyLines(map(s -> indentx("> ", s), paragraphs2))); // find fact paragraphs print(map allLinesAreUnindented(paragraphs2)); Pair p1 = filterAntiFilter(s -> !isSingleLine(trim(s)) && allLinesAreUnindented(s), paragraphs2); LS multiFactParagraphs = p1.a, paragraphs3 = p1.b; for (S para : multiFactParagraphs) for (S s : tlft(para)) addFact(s); // find logic rules new LS paragraphs4; for (S para : paragraphs3) { PairS p = splitAtDoubleArrow_pair(para); if (p == null) continue with paragraphs4.add(para); logicRules.add(print("Got logic rule", new LogicRule(splitAtAmpersand2(p.a), splitAtAmpersand2(p.b)))); } pnlStruct("Unparsed", paragraphs4); // Parsing done, now THINK think(); } void think { rulesOnFacts.newAs(logicRules); // add logic rules Pair p; int round = 0; bool anyAction; while (round++ < 100) { print("Logic round " + round); anyAction = false; while not null (p = rulesOnFacts.next()) { set anyAction; //print("Combination: " + p); applyLogicRuleToFact(p.a, p.b); } if (!anyAction) break; for (S proc : getAndClearList(proceduresToRun)) runProcedure(proc); } } }