Here's some more sleuthing and differences between STD.pm and Synopsis
3:
Methodcall precedence operators in STD.pm seem to include this set:
.meth - single call
.?meth - 0 or 1 call
.+meth - 1 or more call
.*meth - 0 or more call
.=meth - mutating call
.:meth - ?? what is this
.^meth - meta call
!meth - private call
.^!meth - private meta call
S03 doesn't have the private versions.
S03 defines .:prefix as the dotted form of a prefix operator, but that
is clearly not what STD.pm parses.
?? What does <.:> mean?
Now, meth is really <dottyop>, which can be one of three things:
a method name (or variable with such in it)
a postfix operator
which in this context is just <++>, <-->, <i> and their hyper
forms
?? I think I heard that in this context, <i> won't be considered an
operator
though STD.pm parses it this way for now
a postcircumfix
while is one of (~) [~] {~} <~> <<~>> «~»
S03 doesn't explain that the postcircumfix form can be used with any
of the Methodcall operators, it only calls out <.>.
STD.pm actually treats <!> differently here - it only takes a method
name.
?? Is <.^!> meant to be different in this regard from <!>?
?? Also, only <!> matches the token privop -- shouldn't <.^!> match
that production as well?
The expansion for a method name (really <methodop>) includes not only
the name of the method, but also optionally the arguments, via either
'(' ~ ')' form, '.(' ~ ')' form, or ':' invocant marker form. This
later one has me stumped: Won't it mean that the ':' as invocant
marker will have different precedence depending on if it is preceded
by an explicit dotted method call vs. a computed expression... I'm not
sure I can think of a case that the parses would in fact be different,
but why the two different ways to parse this use of <:>?
- mark
