Examples with SwitchNode suite.node.io.SwitchNode used on opensource projects

Example 1 with SwitchNode

use of suite.node.io.SwitchNode in project suite by stupidsing.

the class CompileBinderImpl method binder.

public Bind_ binder(Node node) {
    FunCreator<Bind_> fc = FunCreator.of(Bind_.class, false);
    return fc.create(new BinOp<>() {

        private FunExpr env, trail, b;

        public FunExpr apply(FunExpr bindEnv, FunExpr target) {
            this.env = bindEnv.field("env");
            this.trail = bindEnv.field("trail");
            return f.declare(ok, b -> {
                this.b = b;
                return compile_(node, target);
            });
        }

        private FunExpr compile_(Node node, FunExpr target) {
            FunExpr br = bind(f.object_(node, Node.class), target);
            FunExpr brc = bindClone(node, target);
            return new // 
            SwitchNode<FunExpr>(// 
            node).applyIf(Atom.class, n -> {
                return f.ifEquals(target, f.object(node), ok, br);
            }).applyIf(Int.class, n -> {
                return f.ifInstance(Int.class, target, i -> f.ifEquals(i.field("number"), f.int_(n.number), ok, fail), br);
            }).applyIf(Reference.class, n -> {
                FunExpr ref = env.field("refs").index(f.int_(mapper().computeIndex(n)));
                return f.invokeStatic(Binder.class, "bind", target, ref.cast_(Node.class), trail);
            }).applyIf(Str.class, n -> {
                return f.ifInstance(Str.class, target, s -> f.object(n.value).invoke("equals", s.field("value").cast_(Object.class)), br);
            }).applyIf(Tree.class, tree -> {
                return f.declare(f.invokeStatic(Tree.class, "decompose", target, f.object(tree.getOperator())), t -> {
                    Node lt = tree.getLeft();
                    Node rt = tree.getRight();
                    return f.ifNonNull(t, compile_(lt, t.invoke("getLeft"), compile_(rt, t.invoke("getRight"), ok)), brc);
                });
            }).applyIf(Tuple.class, n -> {
                return f.ifInstance(Tuple.class, target, tuple -> f.declare(tuple.field("nodes"), targets -> {
                    Node[] nodes = n.nodes;
                    FunExpr fe = ok;
                    for (int i = 0; i < nodes.length; i++) fe = compile_(nodes[i], targets.index(f.int_(i)), fe);
                    return f.if_(targets.length(), fe, brc);
                }), brc);
            }).applyIf(Node.class, n -> {
                Clone_ cloner = cloner(n);
                return f.invokeStatic(Binder.class, "bind", target, f.object(cloner).invoke("apply", env), trail);
            }).nonNullResult();
        }

        private FunExpr compile_(Node node, FunExpr target, FunExpr cps) {
            return f.assign(b, compile_(node, target), f.if_(b, cps, fail));
        }

        private FunExpr bindClone(Node node, FunExpr target) {
            if (isBindTrees)
                return bind(f.object(cloner(node)).apply(env), target);
            else
                return fail;
        }

        private FunExpr bind(FunExpr node, FunExpr target) {
            return f.ifInstanceAnd(Reference.class, target, ref -> f.seq(trail.invoke("addBind", ref, node), ok));
        }
    }).apply(Map.ofEntries());
}

Example 2 with SwitchNode

use of suite.node.io.SwitchNode in project suite by stupidsing.

the class CompileClonerImpl method cloner.

@Override
public Clone_ cloner(Node node) {
    FunCreator<Clone_> fc = FunCreator.of(Clone_.class, false);
    return fc.create(new Iterate<>() {

        private FunExpr env;

        public FunExpr apply(FunExpr env) {
            this.env = env;
            return compile_(node);
        }

        private FunExpr compile_(Node node_) {
            return new // 
            SwitchNode<FunExpr>(// 
            node_).applyIf(Atom.class, n -> {
                return f.object(node_);
            }).applyIf(Dict.class, n -> {
                FunExpr[] exprs = // 
                Read.from2(// 
                n.map).map(// 
                (key, value) -> f.invokeStatic(Pair.class, "of", compile_(key), compile_(value))).toArray(FunExpr.class);
                return f.invokeStatic(Dict.class, "of", f.array(Pair.class, exprs));
            }).applyIf(Int.class, n -> {
                return f.object(node_);
            }).applyIf(Reference.class, n -> {
                return env.field("refs").index(f.int_(vm.computeIndex(n)));
            }).applyIf(Str.class, n -> {
                return f.object(node_);
            }).applyIf(Tree.class, tree -> {
                FunExpr fe0 = compile_(tree.getLeft()).cast_(Node.class);
                FunExpr fe1 = compile_(tree.getRight()).cast_(Node.class);
                return f.invokeStatic(Tree.class, "of", f.object(tree.getOperator()), fe0, fe1);
            }).applyIf(Tuple.class, n -> {
                FunExpr[] exprs = Read.from(n.nodes).map(this::compile_).toArray(FunExpr.class);
                return f.invokeStatic(Tuple.class, "of", f.array(Node.class, exprs));
            }).nonNullResult();
        }
    }).apply(Map.ofEntries());
}

Example 3 with SwitchNode

use of suite.node.io.SwitchNode in project suite by stupidsing.

the class CompileProverImpl method prover.

@Override
public Prove_ prover(Node node) {
    FunExpr rt = f.input();
    Fun<FunExpr, ProveRt> cf = cps -> FunCreator.of(ProveRt.class, false).create(rt_ -> cps).apply(Map.ofEntries());
    FunExpr compiled = new Object() {

        private FunExpr compile_(Node node, FunExpr cps) {
            return new // 
            SwitchNode<FunExpr>(// 
            node).match(".0, .1", m -> {
                return compile_(m[0], compile_(m[1], cps));
            }).match(".0; .1", m -> {
                FunExpr cps1;
                if (Boolean.TRUE) {
                    ProveRt proveRt_ = cf.apply(cps);
                    cps1 = f.object(proveRt_).invoke("test", rt);
                } else
                    cps1 = cps;
                FunExpr f0 = compile_(m[0], cps1);
                FunExpr f1 = compile_(m[1], cps1);
                return f.seq(f0, f1);
            }).match("fail", m -> {
                return f._void();
            }).match("yes", m -> {
                return cps;
            }).nonNullResult();
        }
    }.compile_(node, rt.fieldSet("ok", ok));
    ProveRt proveRt = cf.apply(compiled);
    return proverConfig -> {
        Runtime_ rt_ = new Runtime_();
        rt_.proverConfig = proverConfig;
        proveRt.test(rt_);
        return rt_.ok;
    };
}

Example 4 with SwitchNode

use of suite.node.io.SwitchNode in project suite by stupidsing.

the class CompileExpressionImpl method evaluator.

public Evaluate_ evaluator(Node node) {
    FunCreator<Evaluate_> fc = FunCreator.of(Evaluate_.class, false);
    return fc.create(new Iterate<>() {

        private FunExpr env;

        public FunExpr apply(FunExpr env) {
            this.env = env;
            return compile_(node);
        }

        private FunExpr compile_(Node node) {
            return new // 
            SwitchNode<FunExpr>(// 
            node).match2(".0 + .1", (a, b) -> {
                return compileOperator(a, b, "+");
            }).match2(".0 - .1", (a, b) -> {
                return compileOperator(a, b, "-");
            }).match2(".0 * .1", (a, b) -> {
                return compileOperator(a, b, "*");
            }).match2(".0 / .1", (a, b) -> {
                return compileOperator(a, b, "/");
            }).match2(".0 and .1", (a, b) -> {
                return compileOperator(a, b, "&&");
            }).match2(".0 or .1", (a, b) -> {
                return compileOperator(a, b, "||");
            }).match2(".0 shl .1", (a, b) -> {
                return compileOperator(a, b, "<<");
            }).match2(".0 shr .1", (a, b) -> {
                return compileOperator(a, b, ">>");
            }).applyIf(Int.class, i -> {
                return f.int_(i.number);
            }).applyIf(Node.class, i -> {
                Clone_ n_ = clonerFactory.cloner(node);
                Evaluate_ evaluate = env -> TreeUtil.evaluate(n_.apply(env));
                return f.object(evaluate).invoke("evaluate", env);
            }).nonNullResult();
        }

        private FunExpr compileOperator(Node a, Node b, String op) {
            FunExpr fe0 = compile_(a);
            FunExpr fe1 = compile_(b);
            return f.bi(op, fe0, fe1);
        }
    }).apply(Map.ofEntries());
}

Example 5 with SwitchNode

use of suite.node.io.SwitchNode in project suite by stupidsing.

the class SewingBinderImpl method binder.

public Bind_ binder(Node node) {
    return new // 
    SwitchNode<Bind_>(// 
    node).applyIf(Atom.class, n -> {
        return compileBindAtom(n);
    }).applyIf(Int.class, n -> {
        return compileBindInt(n);
    }).applyIf(Reference.class, n -> {
        int index = mapper().computeIndex(n);
        return (be, n_) -> Binder.bind(n_, be.env.get(index), be.trail);
    }).applyIf(Str.class, n -> {
        return compileBindStr(n);
    }).applyTree((operator, l, r) -> {
        Clone_ f = cloner(node);
        Bind_ c0 = binder(l);
        Bind_ c1 = binder(r);
        return (be, n) -> {
            Node n_ = n.finalNode();
            Tree t;
            if (n_ instanceof Reference)
                if (isBindTrees) {
                    be.trail.addBind((Reference) n_, f.apply(be.env));
                    return true;
                } else
                    return false;
            else
                return // 
                (t = Tree.decompose(n_, operator)) != null && // 
                c0.test(be, t.getLeft()) && c1.test(be, t.getRight());
        };
    }).applyIf(Tuple.class, tuple -> {
        Clone_ f = cloner(node);
        Bind_[] cs = Read.from(tuple.nodes).map(this::binder).toArray(Bind_.class);
        int length = cs.length;
        return (be, n) -> {
            Node n_ = n.finalNode();
            if (n_ instanceof Tuple) {
                Node[] nodes = ((Tuple) n_).nodes;
                if (nodes.length == length) {
                    for (int i = 0; i < length; i++) if (!cs[i].test(be, nodes[i]))
                        return false;
                    return true;
                } else
                    return false;
            } else if (n_ instanceof Reference)
                if (isBindTrees) {
                    be.trail.addBind((Reference) n_, f.apply(be.env));
                    return true;
                } else
                    return false;
            else
                return false;
        };
    }).applyIf(Node.class, n -> {
        Clone_ f = cloner(node);
        return (be, n_) -> Binder.bind(n_, f.apply(be.env), be.trail);
    }).result();
}