Support for node traversal and matching

[jonathanhogg]

Since I ditched queries, I haven't revisited the idea of manipulating a node tree. However, since I have recursive functions now, rewriting a tree ought to be a simpler operation. What's missing is:

• iterating over the children of a node
• matching on a node kind, tags or attributes
• retrieving the value of a node attribute

An additional nice to have would be:

• syntax for binding a name to a tree

Adding these operations would allow for manipulating trees, but also allow nodes to be used as arbitrary data structures.

[jonathanhogg]

Could start off with a bunch of functions for deconstructing nodes:

• kind( node ) - return the kind of the node as a symbol
• children( node ) – return concatenated children of all nodes in the node vector
• tags( node ) - return the tags of a node as a vector of symbols
• attributes( node ) - return the attributes of a node (in order) as a vector of symbols
• getattr( node , attr ) - return the value of a node attribute, specified as a symbol or string

And new functions for constructing nodes:

• new( kind ) - create a new node with kind kind, specified as a symbol or string
• tag( node , tag ) - return copy of node with the addition of tag tag (symbol or string)
• setattr( node , attr , value ) - return copy of node with attr (symbol or string) set to value (null to remove attribute)
• append( node , child ) - return copy of node with child appended

With these, and a new method for checking whether an item is in a vector, that would be enough to do basic matching and reconstruction.

Could see if this is useful for a while and then figure out whether there are particular patterns that merit new grammar.

[jonathanhogg]

One thing that probably would be worth adding new grammar for is a vector search operation, a la:

item in vector – return true or false as to whether item is contained within vector

For consistency this should accept an n-vector for item and should look for whether all of those items appear consecutively in vector.

[jonathanhogg]

Of note here is that the new experimental Rust version of Flitter is using the following syntax for generic construction:

let symbol = :("symbol")
     node = !(:kind) #(:tag) (:attribute)="value"

In the new VM, there is only generic construction and the regular syntax is just shorthand for the generic form.