Author: larry Date: Mon May 1 17:13:17 2006 New Revision: 9091 Modified: doc/trunk/design/syn/S03.pod
Log: Explained why any<a b c> has to be different from any <a b c>. Modified: doc/trunk/design/syn/S03.pod ============================================================================== --- doc/trunk/design/syn/S03.pod (original) +++ doc/trunk/design/syn/S03.pod Mon May 1 17:13:17 2006 @@ -12,7 +12,7 @@ Maintainer: Larry Wall <[EMAIL PROTECTED]> Date: 8 Mar 2004 - Last Modified: 2 May 2006 + Last Modified: 1 May 2006 Number: 3 Version: 26 @@ -115,6 +115,61 @@ @x[foo()] = bar(); # foo() and bar() both in scalar context (@x[foo()]) = bar(); # foo() and bar() both in list context +=item * List operators are all parsed consistently. As in Perl 5, +to the left they look like terms, while to the right they look like +operators that are looser than comma. Unlike in Perl 5, the difference +between the list operator form and the function form is consistently +indicated via whitespace between the list operator and the first +argument. If there is whitespace, it is always a list operator, +and the next token will be taken as the first term of the list. +If there is no whitespace, the parser is biased towards taking the +next token as an operator if at all possible. If the next token +can be taken as either an infix or a postfix operator, it indicates +that the list operator has no arguments. (Or more precisely, no +extra arguments that aren't supplied the operator, since C<.()> +is a postfix that supplies arguments to the preceding function.) + +Examples: + + say foo($bar+1),$baz say(foo($bar+1), $baz); + say foo.($bar+1),$baz say(foo($bar+1), $baz); + say foo ($bar+1),$baz say(foo($bar+1, $baz)); + say foo .($bar+1),$baz say(foo($_.($bar+1), $baz)); + + say foo[$bar+1],$baz say((foo[$bar+1]), $baz); + say foo.[$bar+1],$baz say((foo[$bar+1]), $baz); + say foo [$bar+1],$baz say(foo([$bar+1], $baz)); + say foo .[$bar+1],$baz say(foo($_.[$bar+1], $baz)); + + say foo{$bar+1},$baz say((foo{$bar+1}), $baz); + say foo.{$bar+1},$baz say((foo{$bar+1}), $baz); + say foo {$bar+1},$baz say(foo({$bar+1}, $baz)); + say foo .{$bar+1},$baz say(foo($_.{$bar+1}, $baz)); + + say foo<$bar+1>,$baz say((foo<$bar+1>), $baz); + say foo.<$bar+1>,$baz say((foo<$bar+1>), $baz); + say foo <$bar+1>,$baz say(foo(<$bar+1>, $baz)); + say foo .<$bar+1>,$baz say(foo($_.<$bar+1>, $baz)); + +Note that Perl 6 is making a consistent three-way distinction between +term vs postfix vs infix, and will interpret an overloaded character +like C<< < >> accordingly: + + any <a b c> any('a','b','c') # term + any<a b c> (any).{'a','b','c'} # postfix + any()<a b c> (any).{'a','b','c'} # postfix + any() < $x (any) < $x # infix + +This will seem unfamiliar and "undwimmy" to Perl 5 programmers, who +are used to a grammar that sloppily hardwires a few postfix operators +at the price of extensibility. Perl 6 chooses instead to mandate a +whitespace dependency in order to gain a completely extensible class +of postfix operators. + +=item * A list operator's arguments are also terminated by a closure +that is not followed by a comma or colon. (And a semicolon is implied if +the closure is the final thing on a line.) + =back =head1 New operators