Search in sources :

Example 16 with Source

use of suite.util.FunUtil.Source in project suite by stupidsing.

the class SewingProverImpl method compileTr.

private Trampoline compileTr(BinderFactory bf, Node node) {
    List<Node> list;
    Trampoline tr;
    Tree tree;
    Node[] m;
    if (1 < (list = TreeUtil.breakdown(TermOp.AND___, node)).size())
        tr = andTr(Read.from(list).map(n -> compileTr(bf, n)));
    else if (1 < (list = TreeUtil.breakdown(TermOp.OR____, node)).size())
        tr = orTr(Read.from(list).map(n -> compileTr(bf, n)));
    else if ((m = Suite.pattern(".0 = .1").match(node)) != null) {
        boolean b = complexity(m[0]) <= complexity(m[1]);
        Node n0 = b ? m[0] : m[1];
        Node n1 = b ? m[1] : m[0];
        Bind_ p = bf.binder(n1);
        Clone_ f = bf.cloner(n0);
        tr = rt -> p.test(rt, f.apply(rt.env)) ? okay : fail;
    } else if ((m = Suite.pattern("builtin:.0:.1 .2").match(node)) != null) {
        String className = ((Atom) m[0]).name;
        String fieldName = ((Atom) m[1]).name;
        BuiltinPredicate predicate = Rethrow.ex(() -> {
            Class<?> clazz = Class.forName(className);
            return (BuiltinPredicate) clazz.getField(fieldName).get(Object_.new_(clazz));
        });
        tr = compileTrCallPredicate(bf, predicate, m[2]);
    } else if ((m = Suite.pattern("find.all .0 .1 .2").match(node)) != null) {
        Clone_ f = bf.cloner(m[0]);
        Trampoline tr1 = compileTr(bf, m[1]);
        Bind_ p = bf.binder(m[2]);
        List<Node> vs = new ArrayList<>();
        tr = rt -> {
            Restore restore = save(rt);
            rt.pushRem(rt_ -> {
                vs.add(new Cloner().clone(f.apply(rt_.env)));
                return fail;
            });
            rt.pushAlt(rt_ -> {
                restore.restore(rt);
                return p.test(rt, Tree.of(TermOp.AND___, vs)) ? okay : fail;
            });
            return tr1;
        };
    } else if ((m = Suite.pattern("if .0 .1 .2").match(node)) != null) {
        Trampoline tr0 = compileTr(bf, m[0]);
        Trampoline tr1 = compileTr(bf, m[1]);
        Trampoline tr2 = compileTr(bf, m[2]);
        tr = if_(tr0, tr1, tr2);
    } else if ((m = Suite.pattern("let .0 .1").match(node)) != null) {
        Bind_ p = bf.binder(m[0]);
        Evaluate_ eval = new CompileExpressionImpl(bf).evaluator(m[1]);
        tr = rt -> p.test(rt, Int.of(eval.evaluate(rt.env))) ? okay : fail;
    } else if ((m = Suite.pattern("list.fold .0/.1/.2 .3").match(node)) != null) {
        Clone_ list0_ = bf.cloner(m[0]);
        Clone_ value0_ = bf.cloner(m[1]);
        Bind_ valuex_ = bf.binder(m[2]);
        Clone_ ht_ = bf.cloner(m[3]);
        tr = rt -> {
            Node[] ht = Suite.pattern(".0 .1").match(ht_.apply(rt.env));
            Trampoline tr1 = saveEnvTr(compileTrRule(ht[0], ht[1]));
            Mutable<Node> current = Mutable.of(value0_.apply(rt.env));
            rt.pushRem(rt_ -> valuex_.test(rt_, current.get()) ? okay : fail);
            for (Node elem : Tree.iter(list0_.apply(rt.env))) {
                Reference result = new Reference();
                rt.pushRem(rt_ -> {
                    current.update(result.finalNode());
                    return okay;
                });
                rt.pushRem(rt_ -> {
                    rt_.query = Tree.of(TermOp.ITEM__, Tree.of(TermOp.ITEM__, elem, current.get()), result);
                    return tr1;
                });
            }
            return okay;
        };
    } else if ((m = Suite.pattern("list.fold.clone .0/.1/.2 .3/.4/.5 .6").match(node)) != null) {
        Clone_ list0_ = bf.cloner(m[0]);
        Clone_ value0_ = bf.cloner(m[1]);
        Bind_ valuex_ = bf.binder(m[2]);
        Bind_ elem_ = bf.binder(m[3]);
        Bind_ v0_ = bf.binder(m[4]);
        Clone_ vx_ = bf.cloner(m[5]);
        Trampoline tr1 = compileTr(bf, m[6]);
        tr = rt -> {
            Mutable<Node> current = Mutable.of(value0_.apply(rt.env));
            Env env0 = rt.env;
            rt.pushRem(rt_ -> {
                rt_.env = env0;
                return valuex_.test(rt_, current.get()) ? okay : fail;
            });
            for (Node elem : Tree.iter(list0_.apply(rt.env))) {
                rt.pushRem(rt_ -> {
                    current.update(vx_.apply(rt_.env));
                    return okay;
                });
                rt.pushRem(rt_ -> {
                    rt_.env = env0.clone();
                    return elem_.test(rt_, elem) && v0_.test(rt_, current.get()) ? tr1 : fail;
                });
            }
            return okay;
        };
    } else if ((m = Suite.pattern("list.query .0 .1").match(node)) != null) {
        Clone_ l_ = bf.cloner(m[0]);
        Clone_ ht_ = bf.cloner(m[1]);
        tr = rt -> {
            Node[] ht = Suite.pattern(".0 .1").match(ht_.apply(rt.env));
            Trampoline tr1 = saveEnvTr(compileTrRule(ht[0], ht[1]));
            for (Node n : Tree.iter(l_.apply(rt.env))) rt.pushRem(rt_ -> {
                rt_.query = n;
                return tr1;
            });
            return okay;
        };
    } else if ((m = Suite.pattern("list.query.clone .0 .1 .2").match(node)) != null) {
        Clone_ f = bf.cloner(m[0]);
        Bind_ p = bf.binder(m[1]);
        Trampoline tr1 = compileTr(bf, m[2]);
        tr = rt -> {
            Env env0 = rt.env;
            rt.pushRem(rt_ -> {
                rt_.env = env0;
                return okay;
            });
            for (Node n : Tree.iter(f.apply(rt.env))) rt.pushRem(rt_ -> {
                rt_.env = env0.clone();
                return p.test(rt_, n) ? tr1 : fail;
            });
            return okay;
        };
    } else if ((m = Suite.pattern("member .0 .1").match(node)) != null && TreeUtil.isList(m[0], TermOp.AND___)) {
        List<Bind_> elems_ = Read.from(Tree.iter(m[0])).map(bf::binder).toList();
        Clone_ f = bf.cloner(m[1]);
        tr = rt -> {
            Iterator<Bind_> iter = elems_.iterator();
            Trampoline[] alt = new Trampoline[1];
            Restore restore = save(rt);
            return alt[0] = rt_ -> {
                while (iter.hasNext()) {
                    restore.restore(rt);
                    if (iter.next().test(rt_, f.apply(rt.env))) {
                        rt_.pushAlt(alt[0]);
                        return okay;
                    }
                }
                return fail;
            };
        };
    } else if ((m = Suite.pattern("not .0").match(node)) != null)
        tr = if_(compileTr(bf, m[0]), fail, okay);
    else if ((m = Suite.pattern("once .0").match(node)) != null) {
        Trampoline tr0 = compileTr(bf, m[0]);
        tr = rt -> {
            IList<Trampoline> alts0 = rt.alts;
            rt.pushRem(rt_ -> {
                rt_.alts = alts0;
                return okay;
            });
            return tr0;
        };
    } else if ((m = Suite.pattern("suspend .0 .1 .2").match(node)) != null) {
        Clone_ f0 = bf.cloner(m[0]);
        Clone_ f1 = bf.cloner(m[1]);
        Trampoline tr0 = compileTr(bf, m[2]);
        tr = rt -> {
            List<Node> results = new ArrayList<>();
            Env env = rt.env;
            Trampoline tr_ = andTr(Read.each(tr0, rt_ -> {
                results.add(f1.apply(env));
                return fail;
            }));
            Node n0 = f0.apply(rt.env);
            Suspend suspend = new Suspend(() -> {
                Runtime rt_ = new Runtime(rt, tr_);
                rt_.trampoline();
                return Read.from(results).uniqueResult();
            });
            if (n0 instanceof Reference) {
                rt.trail.addBind((Reference) n0, suspend);
                return okay;
            } else
                return fail;
        };
    } else if ((m = Suite.pattern("throw .0").match(node)) != null) {
        Clone_ f = bf.cloner(m[0]);
        tr = rt -> {
            rt.handler.sink(new Cloner().clone(f.apply(rt.env)));
            return okay;
        };
    } else if ((m = Suite.pattern("try .0 .1 .2").match(node)) != null) {
        Trampoline tr0 = compileTr(bf, m[0]);
        Bind_ p = bf.binder(m[1]);
        Trampoline catch0 = compileTr(bf, m[2]);
        tr = rt -> {
            BindEnv be = rt;
            Restore restore = save(rt);
            IList<Trampoline> alts0 = rt.alts;
            Sink<Node> handler0 = rt.handler;
            rt.handler = node_ -> {
                restore.restore(rt);
                if (p.test(be, node_)) {
                    rt.alts = alts0;
                    rt.pushRem(catch0);
                } else
                    handler0.sink(node_);
            };
            rt.pushRem(rt_ -> {
                rt_.handler = handler0;
                return okay;
            });
            return tr0;
        };
    } else if ((m = Suite.pattern(".0 .1").match(node)) != null && m[0] instanceof Atom)
        tr = compileTrCallPredicate(bf, ((Atom) m[0]).name, m[1], node);
    else if (node instanceof Atom) {
        String name = ((Atom) node).name;
        if (node == ProverConstant.cut)
            tr = cutEnd();
        else if (String_.equals(name, ""))
            tr = okay;
        else if (String_.equals(name, "fail"))
            tr = fail;
        else
            tr = compileTrCallPredicate(bf, name, Atom.NIL, node);
    } else if (node instanceof Data<?>) {
        Object data = ((Data<?>) node).data;
        if (data instanceof Source<?>)
            tr = rt -> ((Source<?>) data).source() != Boolean.TRUE ? okay : fail;
        else
            tr = Fail.t("cannot understand " + node);
    } else if (node instanceof Reference) {
        Clone_ f = bf.cloner(node);
        tr = rt -> compileTr(passThru, f.apply(rt.env));
    } else if ((tree = Tree.decompose(node)) != null)
        tr = compileTrCallPredicate(bf, tree.getOperator().getName(), node, node);
    else if (node instanceof Tuple)
        tr = compileTrCallPredicate(bf, node);
    else
        tr = Fail.t("cannot understand " + node);
    return tr;
}
Also used : Prover(suite.lp.doer.Prover) BindEnv(suite.lp.doer.BinderFactory.BindEnv) BuiltinPredicate(suite.lp.predicate.PredicateUtil.BuiltinPredicate) LogUtil(suite.os.LogUtil) Mutable(suite.adt.Mutable) BinderFactory(suite.lp.doer.BinderFactory) Node(suite.node.Node) ProverConstant(suite.lp.doer.ProverConstant) VariableMapper(suite.lp.sewing.VariableMapper) Suspend(suite.node.Suspend) Map(java.util.Map) Prototype(suite.lp.kb.Prototype) RuleSet(suite.lp.kb.RuleSet) Generalizer(suite.lp.doer.Generalizer) Bind_(suite.lp.doer.BinderFactory.Bind_) Cloner(suite.lp.doer.Cloner) Object_(suite.util.Object_) SystemPredicates(suite.lp.predicate.SystemPredicates) Tree(suite.node.Tree) Pair(suite.adt.pair.Pair) Friends.max(suite.util.Friends.max) List(java.util.List) Clone_(suite.lp.doer.ClonerFactory.Clone_) ListMultimap(suite.adt.map.ListMultimap) As(suite.streamlet.As) Int(suite.node.Int) TreeUtil(suite.node.util.TreeUtil) ProverConfig(suite.lp.Configuration.ProverConfig) Read(suite.streamlet.Read) Rule(suite.lp.kb.Rule) HashMap(java.util.HashMap) IList(suite.immutable.IList) ArrayList(java.util.ArrayList) Data(suite.node.Data) Formatter(suite.node.io.Formatter) String_(suite.util.String_) Rethrow(suite.util.Rethrow) Binder(suite.lp.doer.Binder) Tuple(suite.node.Tuple) Reference(suite.node.Reference) Suite(suite.Suite) SuiteException(suite.node.util.SuiteException) Iterator(java.util.Iterator) CompileExpressionImpl(suite.lp.compile.impl.CompileExpressionImpl) Source(suite.util.FunUtil.Source) TermOp(suite.node.io.TermOp) List_(suite.util.List_) Evaluate_(suite.lp.doer.EvaluatorFactory.Evaluate_) Rewrite(suite.node.util.Rewrite) Streamlet(suite.streamlet.Streamlet) Atom(suite.node.Atom) Sink(suite.util.FunUtil.Sink) ProverFactory(suite.lp.doer.ProverFactory) Env(suite.lp.sewing.Env) Fail(suite.util.Fail) Node(suite.node.Node) ArrayList(java.util.ArrayList) CompileExpressionImpl(suite.lp.compile.impl.CompileExpressionImpl) Suspend(suite.node.Suspend) BindEnv(suite.lp.doer.BinderFactory.BindEnv) Env(suite.lp.sewing.Env) BindEnv(suite.lp.doer.BinderFactory.BindEnv) Iterator(java.util.Iterator) Tree(suite.node.Tree) List(java.util.List) IList(suite.immutable.IList) ArrayList(java.util.ArrayList) BuiltinPredicate(suite.lp.predicate.PredicateUtil.BuiltinPredicate) Evaluate_(suite.lp.doer.EvaluatorFactory.Evaluate_) Reference(suite.node.Reference) Atom(suite.node.Atom) Cloner(suite.lp.doer.Cloner) IList(suite.immutable.IList) Bind_(suite.lp.doer.BinderFactory.Bind_) Mutable(suite.adt.Mutable) Clone_(suite.lp.doer.ClonerFactory.Clone_) Tuple(suite.node.Tuple)

Example 17 with Source

use of suite.util.FunUtil.Source in project suite by stupidsing.

the class ChrFunUtil method suck.

/**
 * Sucks data from a sink and produce into a source.
 */
public static ChrSource suck(Sink<ChrSink> fun) {
    NullableSyncQueue<Character> queue = new NullableSyncQueue<>();
    ChrSink enqueue = c -> enqueue(queue, c);
    Thread thread = Thread_.startThread(() -> {
        try {
            fun.sink(enqueue);
        } finally {
            enqueue(queue, EMPTYVALUE);
        }
    });
    return () -> {
        try {
            return queue.take();
        } catch (InterruptedException ex) {
            thread.interrupt();
            return Fail.t(ex);
        }
    };
}
Also used : ChrTest(suite.primitive.ChrPrimitives.ChrTest) Chr_Obj(suite.primitive.ChrPrimitives.Chr_Obj) ChrSink(suite.primitive.ChrPrimitives.ChrSink) Iterator(java.util.Iterator) LogUtil(suite.os.LogUtil) ChrObjPair(suite.primitive.adt.pair.ChrObjPair) Source2(suite.util.FunUtil2.Source2) Source(suite.util.FunUtil.Source) NullableSyncQueue(suite.util.NullableSyncQueue) Thread_(suite.util.Thread_) Fun(suite.util.FunUtil.Fun) ChrObjSource(suite.primitive.ChrPrimitives.ChrObjSource) Sink(suite.util.FunUtil.Sink) Collections(java.util.Collections) Fail(suite.util.Fail) ChrSource(suite.primitive.ChrPrimitives.ChrSource) NullableSyncQueue(suite.util.NullableSyncQueue) ChrSink(suite.primitive.ChrPrimitives.ChrSink)

Example 18 with Source

use of suite.util.FunUtil.Source in project suite by stupidsing.

the class IntFunUtil method suck.

/**
 * Sucks data from a sink and produce into a source.
 */
public static IntSource suck(Sink<IntSink> fun) {
    NullableSyncQueue<Integer> queue = new NullableSyncQueue<>();
    IntSink enqueue = c -> enqueue(queue, c);
    Thread thread = Thread_.startThread(() -> {
        try {
            fun.sink(enqueue);
        } finally {
            enqueue(queue, EMPTYVALUE);
        }
    });
    return () -> {
        try {
            return queue.take();
        } catch (InterruptedException ex) {
            thread.interrupt();
            return Fail.t(ex);
        }
    };
}
Also used : Iterator(java.util.Iterator) LogUtil(suite.os.LogUtil) Source2(suite.util.FunUtil2.Source2) Source(suite.util.FunUtil.Source) NullableSyncQueue(suite.util.NullableSyncQueue) Thread_(suite.util.Thread_) IntObjSource(suite.primitive.IntPrimitives.IntObjSource) Fun(suite.util.FunUtil.Fun) IntSource(suite.primitive.IntPrimitives.IntSource) IntTest(suite.primitive.IntPrimitives.IntTest) Int_Obj(suite.primitive.IntPrimitives.Int_Obj) IntSink(suite.primitive.IntPrimitives.IntSink) IntObjPair(suite.primitive.adt.pair.IntObjPair) Sink(suite.util.FunUtil.Sink) Collections(java.util.Collections) Fail(suite.util.Fail) NullableSyncQueue(suite.util.NullableSyncQueue) IntSink(suite.primitive.IntPrimitives.IntSink)

Example 19 with Source

use of suite.util.FunUtil.Source in project suite by stupidsing.

the class LngFunUtil method suck.

/**
 * Sucks data from a sink and produce into a source.
 */
public static LngSource suck(Sink<LngSink> fun) {
    NullableSyncQueue<Long> queue = new NullableSyncQueue<>();
    LngSink enqueue = c -> enqueue(queue, c);
    Thread thread = Thread_.startThread(() -> {
        try {
            fun.sink(enqueue);
        } finally {
            enqueue(queue, EMPTYVALUE);
        }
    });
    return () -> {
        try {
            return queue.take();
        } catch (InterruptedException ex) {
            thread.interrupt();
            return Fail.t(ex);
        }
    };
}
Also used : Iterator(java.util.Iterator) LogUtil(suite.os.LogUtil) LngSource(suite.primitive.LngPrimitives.LngSource) Source2(suite.util.FunUtil2.Source2) Lng_Obj(suite.primitive.LngPrimitives.Lng_Obj) Source(suite.util.FunUtil.Source) NullableSyncQueue(suite.util.NullableSyncQueue) Thread_(suite.util.Thread_) LngObjSource(suite.primitive.LngPrimitives.LngObjSource) Fun(suite.util.FunUtil.Fun) Sink(suite.util.FunUtil.Sink) LngObjPair(suite.primitive.adt.pair.LngObjPair) LngTest(suite.primitive.LngPrimitives.LngTest) Collections(java.util.Collections) Fail(suite.util.Fail) LngSink(suite.primitive.LngPrimitives.LngSink) NullableSyncQueue(suite.util.NullableSyncQueue) LngSink(suite.primitive.LngPrimitives.LngSink)

Aggregations

Source (suite.util.FunUtil.Source)19 Node (suite.node.Node)9 Fun (suite.util.FunUtil.Fun)8 Fail (suite.util.Fail)7 Iterator (java.util.Iterator)6 LogUtil (suite.os.LogUtil)6 Sink (suite.util.FunUtil.Sink)6 Thread_ (suite.util.Thread_)6 Collections (java.util.Collections)5 List (java.util.List)5 Data (suite.node.Data)5 Tree (suite.node.Tree)5 Source2 (suite.util.FunUtil2.Source2)5 NullableSyncQueue (suite.util.NullableSyncQueue)5 ArrayList (java.util.ArrayList)4 HashMap (java.util.HashMap)4 RuleSet (suite.lp.kb.RuleSet)4 Map (java.util.Map)3 Test (org.junit.Test)3 Pair (suite.adt.pair.Pair)3