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

Reply via email to