Adverbs are confusing me mightily lately. It may be that Larry's A12 revision just needs a few examples *with* parenthesis to straighten me out.
Here are some semi-coherent attempts to sort it out in my mind. Please correct me where I have made mistakes. What is the rule(s) for when :foo is an adverb, and when :foo is just a pair constructor? So far I think that :foo is an adverb where an operator is expected, but :for is a pair constructor where a term is expected. Why is this difference important? Perhaps because an adverb goes looking for something to apply itself to. How does it decide what to apply itself to? > 4) Adverbs apply to the previous unparenthesized prefix, infix, > or postfix operator, bypassing simple terms and other "pill" > operators such as circumfix or postcircumfix. But what about the rules for "additional arguments as adverbs"? > 1d) Additional [function] arguments may occur as adverbs *only* if > there are explicit parens. > 2d) Given 2c, additional [method] arguments may occur as adverbs > whether or not there is an argument "pill": I assume rule 1d only applies to arglist parenthesis, and not grouping parenthesis? The legal syntaxes below all mean the same thing, right? func(1,2,3,:foo); # ok func 1,2,3,:foo ; # ok func(1,2,3):foo ; # ok func(1,2,3 :foo); # ok (explicit parens) func 1,2,3 :foo ; # ILLEGAL (according to A12 revision) And for 2d, these are the same: .meth(1,2,3):foo ; .meth(1,2,3 :foo); Does rule 1d or rule 4 does apply inside this parenthesized arglist? func( eeney, meeny, miney :moe ); Does :moe apply to func (rule 1d) or miney (rule 4)? Does it depend on the declaration of miney? sub miney {...} # simple term: moe applies to func sub miney(*%adv) {...} # does a slurpy hash make a function a list operator? sub miney($+moe) {...} # I'll take that moe sub miney($+curly) {...} # Arg OK, but not that one! Is this correct according to 2d, assuming func and meth are 0-ary: say func :foo; # say( func, foo=>1 ) say .meth :foo; # say( .meth( foo=>1 ) ) but if func is 2-or-more-ary, then: say func :foo; # say( func( foo=>1 ) ) A unary function cannot take an adverb, because it has no slurpy hash. Is a function with a slurpy hash automatically a list operator, even if it has 0 or 1 positional arguments? Do I have my whitespace rules right below? say foo :bar; # say( foo( bar=>1 ) ) assuming foo is listy say .foo :bar; # say( .foo( bar=>1 ) ) say foo: bar; # foo.say(bar) say foo:bar ; # ?? say foo :bar ?? Adverbs are still passed to the function as "just a pair", so they have to come after positional parameters. But that's kinda ugly in some cases. Are there ways to get around it? If I know the names of the positional parameters, I can put the adverb (aka pair constructor) first, and pass all the parameters in via names. sub foo( $bar, $baz, %*advs) {...} foo :expletive bar=>3, baz=>42; If I think my function would look better with the :adverb next to the function, and still have positional parameters, I can just declare foo with no named positional parameters, and any parameters after the adverb will go in the slurpy array. Larry also shows this example: > @a.sort:quick:{ +$_ } # both adverbs apply to .sort Would that work for the functional form too? sort :quick :{ +$_ } @a; Does adverbial block find its way into the block parameter, which was actually declared as an optional positional parameter (of type Criteria)? ~ John Williams