获取树节点的子节点数

Question

docs for Node只提到以下方法：

Equal、GreaterThan、GreaterThanOrEqual、LessThan、LessThanOrEqual、NotEqual、Slice、Subscription

它确实提到了如何使用 Subscription 通过索引访问子节点，但是我如何找出子节点的计数必须迭代它们？

这是我的用例：

Exp parsed = parse(#Exp, "2+(4+3)*48");
println("the number of root children is: " + size(parsed));

但它会产生错误，因为 size() 似乎只适用于 List。

Answer 1

到目前为止这似乎有效，但它很糟糕：

int getChildrenCount(Tree parsed) {
    int infinity = 1000;
    for (int i <- [0..infinity]) {
        try parsed[i];
        catch: return i;
    }
    return infinity;
}

void main() {
    Exp parsed = parse(#Exp, "132+(4+3)*48");
    println("the number of root children is: ");
    println(getChildrenCount(parsed));
}

Answer 2

不同的答案，不同的方面是好是坏。这里有一些：

import ParseTree;

int getChildrenCount1(Tree parsed) {
   return (0 | it + 1 | _ <- parsed.args);
}

getChildrenCount1 遍历解析树节点的原始子节点。这包括空格和注释节点 (layout) 和关键字 (literals)。您可能想过滤掉那些，或按除法补偿。

另一方面，这似乎有点间接。我们也可以直接询问子列表的长度：

import List;
import ParseTree;

int getChildrenCount2(Tree parsed) {
   return size(parsed.args) / 2 + 1; // here we divide by two assuming every other node is a layout node
}

还有meta-data的方法。每个解析树节点都有直接的生产的声明性描述，可以查询和探索：

import ParseTree;
import List;

// immediately match on the meta-structure of a parse node:
int getChildrenCount3(appl(Production prod, list[Tree] args)) {
    return size(prod.symbols);
}

此符号长度应与参数长度相同。

// To filter for "meaningful" children in a declarative way:
int getChildrenCount4(appl(prod(_, list[Symbol] symbols, _), list[Tree] args)) {
    return (0 | it + 1 | sort(_) <- symbols);
}

sort 过滤器用于 context-free non-terminals，如使用 syntax 规则声明的那样。词法子项将匹配 lex，布局和文字将匹配 layouts 和 lit。

没有所有模式匹配：

int getChildrenCount4(Tree tree) {
    return (0 | it + 1 | s <- tree.prod.symbols, isInteresting(s));
}

bool isInteresting(Symbol s) = s is sort || s is lex;

获取树节点的子节点数

Get children count of a tree node

rascal