I'm thinking aloud here, so please bear with me. A number of languages have a "with ..." construct that's intended to cut down on repetitive typing, by factoring the invocant out of every method call. Perl 6 also has this, in the form of "given ...":
given $foo.bar.baz { .dothis(); .dothat(); .doanother(); } (same as) $foo.bar.baz.dothis(); $foo.bar.baz.dothat(); $foo.bar.baz.doanother(); I'm wondering if something similar could be done for optional arguments - something along the lines of "within the following block, assign value V to argument X of routine R by default." This would allow for a similar "factoring out" of repetitive flags. So instead of: say qq:!c" ... { ... } ..."; say qq:!c" ... { ... } ..."; say qq:!c" ... { ... } ..."; and so on, you might do something like: with &qq :(c => false) { say "... { ... } ..."; say "... { ... } ..."; say "... { ... } ..."; } Or maybe it could be a pragma (which, by definition, lasts only until the end of the current scope): { use defaults { qq => :!c } say "... { ... } ..."; say "... { ... } ..."; say "... { ... } ..."; } The core concept here is to allow the programmer to easily change the default behavior of a routine within a given scope so that he doesn't have to repeatedly override the default behavior every time it comes up. -- Is this reasonable, or is this too much of a corner case to be worth the effort? -- Jonathan "Dataweaver" Lang