On 2008 Oct 1, at 22:14, Timothy S. Nelson wrote:

The Perl6 way to do this is grammars; using an XML grammar to pull data out

of an XML document is one of Larry's favorite examples.

Hi all. I've enjoyed(?) reading over the February/March thread

entitled "Musings on operator overloading". I've brought a few

thoughts along; if they're old news, please tell me

here to do more reading on it ­.

On Wed, 1 Oct 2008, Brandon S. Allbery KF8NH wrote:

Ok, great. While I see how this does a great job of converting the

string of data into a plex, it doesn't solve the problem of

selecting the data from the plex in a glob-like (or XPath-like)

fashion, which is what I'm talking about here. Have I missed

something that will do that?

On 2008 Oct 1, at 22:23, Timothy S. Nelson wrote:

I could have sworn there was a short and elegant example of using a grammar

to extract arbitrary information from an XML document, but I don't see it

in the documentation. I recall Trey Harris showing such an example on IRC

but not in a logged channel; maybe he'll see this message and jump in, or

if not I'll see if I can get him to write another example.

On Wed, Oct 01, 2008 at 11:24:04PM -0400, Brandon S. Allbery KF8NH wrote:

The key point Brandon is making, that I'm not sure you're answering,

is that he wants to extract elements of a tree-like data structure

(think DOM), not simply from a string representation of a structure

(such as an XML document in a string).

Thinking in terms of grammars, I'd ask the question: could grammars be

used to match tree-like data structures? I think the current answer is no.

Grammars are too tightly bound to the concept of a position in a linear

string.

But I have a nagging suspicion that this is a very powerful idea.

Applying the expressive power of a grammar-like mechanism to

search, backtrack, and match within a tree-like data structure.

Is this new or has anyone discussed it before?

On Thu, 2 Oct 2008, Tim Bunce wrote:

You probably mean "OtherTim" (ie. me) instead of "Brandon" here ­.

I think Grammars would be great for turning a string into a tree. But I

agree with you in that I don't see how they apply to what I'm talking about

­.

Not sure what you mean by "backtrack" in this context;

I was envisioning that the thing return an array of tree nodes

(although, now that I think about it, it could be useful as an

iterator too ­ ). But that doesn't seem to be quite what you're

thinking, and so I'd be interested in hearing more about that too.

Yeap, sorry Tim.

I'm suggesting that the same kind of logic used to find those sequences

of characters in a string that match a pattern (including backtracking

http://perldoc.perl­.org/perlre.html#Bac­ktracking) could be applied to

finding those sub-trees in a tree-like data structure which match a

pattern.

Like applying XPath to an XML DOM, only more general and taken further.

By "more general and taken further" I'm thinking of the same kind of

evoltion from simple regular expressions in perl5 to grammars in perl6.

An XPath query is like a perl5 regular expression.

The grammar concept in perl6 has taken the perl5 regular expression

"mini language" and extended it up into the perl6 langauge as classes

with method calls and features like hypothetical variables.

But perl6 grammars are tied to the concept of searching through a

sequence of characters. At any point the grammar is trying to match

against the current character position with lookahead or lookbehind.

I'm imagining a way of expressing a search through a tree-like data

structure with the same kind of richness and features as grammars

(methods, backtracking, hypothetical variables etc). Instead of

matching against "current character position" you'd be matching the

current node.

Perhaps I'm just daydreaming, or perhaps I'm thinking of bringing an

extended form of the Parrot Tree Grammar Engine to perl6:

"TGE is a tool for transforming trees. Think of it as a good

old-fashioned substitution, but instead of taking and returning strings,

it takes and returns trees."

http://search.cpan.­org/~pmic/parrot-0.7­.1/compilers/tge/TGE­.pir

I've not looked at it closely enough to tell.

But I have a nagging suspicion that this is a very powerful idea.

Applying the expressive power of a grammar-like mechanism to

search, backtrack, and match within a tree-like data structure.

Is this new or has anyone discussed it before?

Hi all. I've enjoyed(?) reading over the February/March thread

entitled "Musings on operator overloading". I've brought a few thoughts

along; if they're old news, please tell me where to do more reading on it ­.

Over the last year or two, I've discovered XPath. I've always thought

XML a little annoying, but I'm very impressed with XPath (which I regard as

"the glob() of XML"), and I've been wondering how to get the power of XPath in

relation to *all* data, not just XML.

My eventual thought was that what would be useful is a role called

Plex (for those who aren't familiar with a Plex, just think "Tree" and you'll

have the right idea). The basic idea is that the Plex role could have a

variety of implementors depending on the data desired (much like the DBI/DBD

split, but for trees instead of tables). The backends could of course include

filesystems, but also XML, LDAP, OO databases, and DNS domains.

Tabular data could also be mapped into trees if desired. This could

be anything from SQL to text files.

As an additional idea, backend conversion could be performed. This

would be especially useful in the case of files. For example:

$root/etc/fstab <convert to text table> / "/boot"

...which would select the row from fstab that contains the "/boot"

partition; admittedly I've fudged the conversion here.

Btw, it was quite a long time before I was able to find the operator

overloading documentation; "Subroutines" was not an intuitive place to look

­. Is there any chance we could add something to S03 that says something

like "see S06 and S13 for operator overloading"?

It sounds like a perfect idea for a very general library or rather

library framework. Perl 6 has all the hooks to install stuff like this.

When you know that operators are mostly[1] just weirdly named subs, it

is ­

That would be mainly Larry's decision.

Other ways to search in the Synopsis are

* check out a copy of the svn repo, and grep/ack in them

* ask in #perl6 where some particular item is documented

Sadly we have next to no user-level documentation at them moment. The

closest might be the open sourced version of "Perl 6 and Parrot

Essentials", but it's rather incomplete and some parts are quite out of

date.

Thinking in terms of grammars, I'd ask the question: could grammars be

used to match tree-like data structures? I think the current answer is no.

Grammars are too tightly bound to the concept of a position in a linear

string.

But I have a nagging suspicion that this is a very powerful idea.

Applying the expressive power of a grammar-like mechanism to

search, backtrack, and match within a tree-like data structure.

Is this new or has anyone discussed it before?