Hi Moritz,
Thanks that was interesting. My investigation into grammars took a while but
here are the results thus far:
Grammar rules and regexes are just methods…
I hadn't thought about what a grammar and rule actually was before. This
inspired me to try:
---
grammar Gram{
has $.x;
rule TOP{
{say $.x}
}
method test{
say $.x
}
}
my Gram $test .= new(:x(hello));
$test.parse(ignore this);
$test.test;
say $test.TOP;
---
which outputs:
Any() #output of TOP in parse
hello#output of test.test
hello#outputted on direct call to rule
Gram.new(x = Any) #the return value of $test.TOP
So rules can't interpolate their grammar's attributes when being called by
'parse' but can when called as a method. Also rules being called directly as
methods return the parent grammar. I'm not sure whether either of these things
are intended…
=
Also I tried rules with arguments and it worked from grammar-parse but not
from calling directly as a method.
---
grammar Gram{
rule TOP{
test_rule('hello')
}
rule test_rule($a){
$a
}
}
my Gram $test .= new();
$test.parse(hello) #returns true
$test.test_rule(hello) #error
---
The error is:
Invalid operation on null string
in any !LITERAL at src/stage2/QRegex.nqp:653
in method INTERPOLATE at src/gen/CORE.setting:9731
(at the line where test_rule starts)
=
Ok now to try the things you mentioned:
First I tried using a parcel instead of an array as the role prototype (array
resulted in error):
---
role roley [$foo]{
token tokeny { $foo }
}
grammar gram {
token TOP { tokeny }
}
---
my gram $gram .= new does roley[('this','or', 'that')];
$gram.parse('this or that'); #returns true
So parcels get joined with spaces into one token
=
Now to try the around about way:
---
role roley [$foo]{
token tokeny:symdynamic { $foo }
}
grammar gram {
token TOP { tokeny[\ tokeny]* }
proto token tokeny {*}
}
my gram $gram .= new;
$gram does roley[$_] for that this;
$gram.parse('this'); #matches
$gram.parse('that'); #nope
---
Each iteration overwrites the previous one in terms of what 'tokeny' resolves
to rather than adding it (symmetrically? is that what sym is short for?)
One more thing I found which seems to be a bug. I defined my nouns/pronouns
like:
---
token PN:symJohn { .sym } #The dot should mean it doesn't get captured
token N:symball { .sym }
---
when my grammar parses this it ends up with a tree like this:
---
sentence = q[John hit the ball]
statement = q[John hit the ball]
NP = q[John]
PN = q[John]
= q[John]
VP = q[hit the ball]
verb = q[hit]
= q[hit]
NP = q[the ball]
D = q[the]
= q[the]
N = q[ball]
= q[ball]
---
Notice the empty slots on the left. Rather than not capturing the sym the
.sym just means it doesn't capture it's name :S
So after all this I have a much better understanding of what grammars really
are but I'm still confused about a few things:
grammars are like classes. They are special because they have a method called
'parse' which applies a rule/token definition (regex) called TOP (or whatever
is set by the :rule argument to parse).
Q: Are grammars meant to be able to have attributes like classes and are they
meant to be able to interpolate them into their rules/token?
rules and tokens are just special types of methods who's body is a regex rather
than perl6 code.
Q: What is the meaning of the return values of tokens/rules when called as
methods?
Q: Is it possible to write a normal method that conforms the the same interface
as rules/tokens (whatever that is). i.e. where we can use normal_method in
rules/tokens which is passed arguments and somehow matches and sets position
etc.
Q: Are rules/tokens meant to be able to have arguments like methods and if so
how do they fit in.
grammars don't check whether the things in their tokens/rules like foo are
actually defined until it comes time to call them
Q: Is this the way it's meant to be?
I saw your post on doc.perl6.org docs. If I can get my head around all this I
would be happy to help document grammars!
Cheers,
Lard
On 27/06/2012, at 12:49 AM, Moritz Lenz wrote:
On 06/26/2012 02:04 PM, Lard Farnwell wrote:
Hi guys,
To understand and play around with perl6 grammars I was trying to do a
simple NLP parts of speech parser in perl6 grammars. This is sort of what I
did:
---
grammar
