Examples with Node suite.node.Node used on opensource projects

Example 96 with Node

use of suite.node.Node in project suite by stupidsing.

the class SeqIntrinsics method deepSeq.

private Node deepSeq(IntrinsicCallback callback, Node node) {
    Node node1 = callback.yawn(node);
    Tree tree;
    if ((tree = Tree.decompose(node1)) != null)
        node1 = Tree.of(tree.getOperator(), deepSeq(callback, tree.getLeft()), deepSeq(callback, tree.getRight()));
    return callback.enclose(Intrinsics.id_, node1);
}

Example 97 with Node

use of suite.node.Node 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;
}

Example 98 with Node

use of suite.node.Node in project suite by stupidsing.

the class TypeChecker method check.

public void check(List<Rule> rules) {
    Map<Prototype, Integer> nElementsByPrototype = checkerUtil.getNumberOfElements(rules);
    Map<Pair<Prototype, Integer>, Reference> types = new HashMap<>();
    Read.from(rules).concatMap(rule -> {
        Generalizer generalizer = new Generalizer();
        Node head = generalizer.generalize(rule.head);
        Node tail = generalizer.generalize(rule.tail);
        return checkerUtil.scan(tail).cons(head);
    }).forEach(pred -> {
        Prototype prototype = Prototype.of(pred);
        Integer nElements = prototype != null ? nElementsByPrototype.get(prototype) : null;
        Node[] ps = nElements != null ? TreeUtil.elements(pred, nElements) : new Node[0];
        try {
            if (nElements != null)
                for (int i = 1; i < nElements; i++) {
                    Pair<Prototype, Integer> key = Pair.of(prototype, i);
                    Node p = ps[i];
                    Node type0 = types.computeIfAbsent(key, k -> new Reference());
                    Node type1 = getType(p);
                    bind(type0, type1);
                }
        } catch (Exception ex) {
            Fail.t("in predicate " + prototype, ex);
        }
    });
    trail.unwindAll();
}

Example 99 with Node

use of suite.node.Node 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 100 with Node

use of suite.node.Node in project suite by stupidsing.

the class Binder method bind.

public static boolean bind(Node n0, Node n1, Trail trail) {
    n0 = n0.finalNode();
    n1 = n1.finalNode();
    if (n0 == n1)
        return true;
    Class<? extends Node> clazz0 = n0.getClass();
    Class<? extends Node> clazz1 = n1.getClass();
    if (clazz0 == Reference.class) {
        trail.addBind((Reference) n0, n1);
        return true;
    } else if (clazz1 == Reference.class) {
        trail.addBind((Reference) n1, n0);
        return true;
    }
    if (clazz0 == Dict.class && clazz1 == Dict.class) {
        Map<Node, Reference> map0 = ((Dict) n0).map;
        Map<Node, Reference> map1 = ((Dict) n1).map;
        boolean b = true;
        for (Node key : List_.concat(map0.keySet(), map1.keySet())) {
            Node v0 = map0.computeIfAbsent(key, k -> new Reference());
            Node v1 = map1.computeIfAbsent(key, k -> new Reference());
            b &= bind(v0, v1, trail);
        }
        return b;
    } else if (clazz0 == Int.class && clazz1 == Int.class)
        return ((Int) n0).number == ((Int) n1).number;
    else if (clazz0 == Str.class && clazz1 == Str.class)
        return Objects.equals(((Str) n0).value, ((Str) n1).value);
    else if (Tree.class.isAssignableFrom(clazz0) && Tree.class.isAssignableFrom(clazz1)) {
        Tree t0 = (Tree) n0;
        Tree t1 = (Tree) n1;
        return // 
        t0.getOperator() == t1.getOperator() && // 
        bind(t0.getLeft(), t1.getLeft(), trail) && bind(t0.getRight(), t1.getRight(), trail);
    } else if (clazz0 == Tuple.class && clazz1 == Tuple.class) {
        Node[] nodes0 = ((Tuple) n0).nodes;
        Node[] nodes1 = ((Tuple) n1).nodes;
        boolean b = nodes0.length == nodes1.length;
        if (b) {
            for (int i = 0; i < nodes0.length; i++) b &= bind(nodes0[i], nodes1[i], trail);
        }
        return b;
    } else
        return false;
}