Examples with Prover suite.lp.doer.Prover used on opensource projects

Example 1 with Prover

use of suite.lp.doer.Prover in project suite by stupidsing.

the class CommandDispatcher method dispatchCommand_.

private boolean dispatchCommand_(String input, Writer writer) throws IOException {
    PrintWriter pw = new PrintWriter(writer);
    boolean code = true;
    Pair<InputType, String> pair = new CommandUtil<>(InputType.values()).recognize(input);
    InputType type = pair.t0;
    input = pair.t1.trim();
    if (input.endsWith("#"))
        input = String_.range(input, 0, -1);
    Node node = Suite.parse(input.trim());
    switch(type) {
        case EVALUATE:
            pw.println(Formatter.dump(evaluateFunctional(node)));
            break;
        case EVALUATEDO:
            node = Suite.applyPerform(node, Atom.of("any"));
            pw.println(Formatter.dump(evaluateFunctional(node)));
            break;
        case EVALUATEDOCHARS:
            node = Suite.applyPerform(node, Suite.parse("[n^Chars]"));
            printEvaluated(writer, node);
            break;
        case EVALUATEDOSTR:
            node = Suite.applyPerform(node, Atom.of("string"));
            printEvaluated(writer, Suite.applyWriter(node));
            break;
        case EVALUATEEFI:
            InterpretFunEager efi = new InterpretFunEager();
            efi.setLazyify(opt.isLazy());
            pw.println(efi.eager(node));
            break;
        case EVALUATELFI0:
            pw.println(new InterpretFunLazy0().lazy(node).get());
            break;
        case EVALUATELFI:
            pw.println(new InterpretFunLazy().lazy(node).get());
            break;
        case EVALUATESTR:
            node = Suite.substitute("string of .0", node);
            printEvaluated(writer, Suite.applyWriter(node));
            break;
        case EVALUATETYPE:
            pw.println(Formatter.dump(Suite.evaluateFunType(opt.fcc(node))));
            break;
        case FACT:
            ruleSet.addRule(Rule.of(node));
            break;
        case OPTION:
            Source<String> source = To.source(("-" + input).split(" "));
            String option;
            while ((option = source.source()) != null) opt.processOption(option, source);
            break;
        case PRETTYPRINT:
            pw.println(new PrettyPrinter().prettyPrint(node));
            break;
        case QUERY:
            code = query(new InterpretedProverBuilder(opt.pc(ruleSet)), ruleSet, node);
            break;
        case QUERYCOMPILED:
            code = query(CompiledProverBuilder.level1(opt.pc(ruleSet)), ruleSet, node);
            break;
        case QUERYCOMPILED2:
            if (builderLevel2 == null)
                builderLevel2 = CompiledProverBuilder.level2(opt.pc(ruleSet));
            code = query(builderLevel2, ruleSet, node);
            break;
        case QUERYELABORATE:
            elaborate(node, new Prover(opt.pc(ruleSet))::prove);
            break;
        case QUERYSEWING:
            code = query(new SewingProverBuilder(opt.pc(ruleSet)), ruleSet, node);
            break;
        case QUERYSEWINGELAB:
            elaborate(node, n -> new SewingProverImpl(ruleSet).prover(n).test(new ProverConfig(ruleSet)));
            break;
        case RESET:
            ruleSet = Suite.newRuleSet();
            importFiles(List.of());
    }
    pw.flush();
    return code;
}

Example 2 with Prover

use of suite.lp.doer.Prover in project suite by stupidsing.

the class FindPredicates method elaborate.

private Stack<Node> elaborate(Prover prover, Node var, Node goal) {
    Stack<Node> stack = new Stack<>();
    Tree subGoal = Tree.of(TermOp.AND___, goal, new Data<Source<Boolean>>(() -> {
        stack.push(new Cloner().clone(var));
        return Boolean.FALSE;
    }));
    new Prover(prover).elaborate(subGoal);
    return stack;
}

Example 3 with Prover

use of suite.lp.doer.Prover in project suite by stupidsing.

the class PredicateUtil method tryProve.

public static boolean tryProve(Prover prover, Predicate<Prover> source) {
    Prover prover1 = new Prover(prover);
    boolean b = false;
    try {
        b = source.test(prover1);
    } finally {
        if (// roll back bindings if overall goal is failed
        !b)
            prover1.unwindAll();
    }
    return b;
}

Example 4 with Prover

use of suite.lp.doer.Prover in project suite by stupidsing.

the class InterpretFunLazy method parse.

private Reference parse(Node node) {
    Prover prover = new Prover(Suite.newRuleSet(List.of("auto.sl", "fc/fc.sl")));
    Reference parsed = new Reference();
    if (!prover.prove(Suite.substitute("fc-parse .0 .1", node, parsed)))
        Fail.t("cannot parse " + node);
    return parsed;
}

Example 5 with Prover

use of suite.lp.doer.Prover in project suite by stupidsing.

the class ImportUtil method importFrom.

public synchronized boolean importFrom(RuleSet ruleSet, Node node) {
    List<Rule> rules = new ArrayList<>();
    for (Node elem : Tree.iter(node, TermOp.NEXT__)) rules.add(Rule.of(elem));
    Prover prover = new Prover(ruleSet);
    boolean b = true;
    IList<Node> importing0 = importing.get();
    try {
        importing.set(IList.cons(node, importing0));
        for (Rule rule : rules) if (rule.head != Atom.NIL)
            ruleSet.addRule(rule);
        else {
            Node goal = SewingGeneralizerImpl.generalize(rule.tail);
            b &= prover.prove(goal);
        }
    } finally {
        importing.set(importing0);
    }
    if (// check after all files are imported
    importing0.isEmpty())
        new Checker().check(ruleSet.getRules());
    return b;
}