develooper Front page | perl.perl6.language | Postings from July 2006

[svn:perl6-synopsis] r10077 - doc/trunk/design/syn

Thread Next
July 10, 2006 13:48
[svn:perl6-synopsis] r10077 - doc/trunk/design/syn
Message ID:
Author: larry
Date: Mon Jul 10 13:48:24 2006
New Revision: 10077


Disallow postfix after listops without intervening (), .() or \.().

Modified: doc/trunk/design/syn/S02.pod
--- doc/trunk/design/syn/S02.pod	(original)
+++ doc/trunk/design/syn/S02.pod	Mon Jul 10 13:48:24 2006
@@ -12,9 +12,9 @@
   Maintainer: Larry Wall <>
   Date: 10 Aug 2004
-  Last Modified: 1 July 2006
+  Last Modified: 10 July 2006
   Number: 2
-  Version: 48
+  Version: 49
 This document summarizes Apocalypse 2, which covers small-scale
 lexical items and typological issues.  (These Synopses also contain
@@ -1713,8 +1713,8 @@
 If it is not, it is compiled as a provisional function call of
 the list operator form, which may or may not have an argument list.
 When in doubt, the attempt is made to parse an argument list.  As with
-any list operator, an immediate postfix operator means there are no
-arguments, whereas anything following whitespace will be interpreted
+any list operator, an immediate postfix operator is illegal unless it is a
+form of parentheses, whereas anything following whitespace will be interpreted
 as an argument list if possible.
 Based on the signature of the subroutine declaration, there are only
@@ -1747,16 +1747,16 @@
 or a method call in dot form.  (It is also allowed on a label when a
 statement is expected.) So for any undeclared identifier "C<foo>":
-		# foo().bar	-- postfix prevents args
+		# foo().bar	-- illegal postfix, must use foo().bar
     foo .bar		# foo($	-- no postfix starts with whitespace
-    foo\ .bar		# foo().bar	-- long dot, so postfix
-    foo++		# foo()++	-- postfix
+    foo\ .bar		# foo().bar	-- illegal long dot, use foo()\ .bar
+    foo++		# foo()++	-- illegal postfix, must use foo()++
     foo 1,2,3		# foo(1,2,3)	-- args always expected after listop
     foo + 1		# foo(+1)	-- term always expected after listop
     foo;		# foo();	-- no postfix, but no args either
     foo:		#   label	-- must be label at statement boundary.
 					-- illegal otherwise
-    foo: bar:		#   two labels in a row
+    foo: bar:		#   two labels in a row, okay
     .foo:		# $ 1 	-- must be "dot" method with : args
     .foo(1)		# $ 	-- must be "dot" method with () args
     .foo		# $ 	-- must be "dot" method with no args

Modified: doc/trunk/design/syn/S03.pod
--- doc/trunk/design/syn/S03.pod	(original)
+++ doc/trunk/design/syn/S03.pod	Mon Jul 10 13:48:24 2006
@@ -12,9 +12,9 @@
   Maintainer: Larry Wall <>
   Date: 8 Mar 2004
-  Last Modified: 1 Jul 2006
+  Last Modified: 10 Jul 2006
   Number: 3
-  Version: 44
+  Version: 45
 =head1 Changes to existing operators
@@ -224,18 +224,23 @@
 =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
+to the left a list operator look like term, while to the right it looks like
+an operator that is 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.)
+and the next token will be taken as the first term of the list (or
+if there are no terms, as the expression terminator).
+If there is no whitespace, the operator is never taken as a list
+operator, but always as a functional operator.  Postfixes are
+specifically disallowed right after the operator except for the
+parenthetical forms delimiting the argument list.  The parentheses
+are optional if and only if there are no arguments.  If there are
+parentheses, they may be followed by any postfix operator.  Unlike
+postfix operators, infix operators and expression terminators are
+allowed without intervening whitespace, and will be taken to indicate
+that the operator is a function with no arguments.
@@ -244,18 +249,18 @@
     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		illegal, need foo()[]
+    say foo.[$bar+1],$baz		illegal, need foo().[]
     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		illegal, need foo(){}
+    say foo.{$bar+1},$baz		illegal, need foo().{}
     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		illegal, need foo()<>
+    say foo.<$bar+1>,$baz		illegal, need foo().<>
     say foo <$bar+1>,$baz		say(foo(<$bar+1>, $baz));
     say foo .<$bar+1>,$baz		say(foo($_.<$bar+1>, $baz));
@@ -263,10 +268,10 @@
 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
+    any <a b c>			any('a','b','c')	# term
+    any()<a b c>		(any).{'a','b','c'}	# postfix
+    any() < $x			(any) < $x		# infix
+    any<a b c>			    [syntax error]	# illegal postfix
 This will seem unfamiliar and "undwimmy" to Perl 5 programmers, who
 are used to a grammar that sloppily hardwires a few postfix operators
@@ -278,6 +283,18 @@
 that is not followed by a comma or colon.  (And a semicolon is implied if
 the closure is the final thing on a line.)
+=item * A function predeclared as 0-ary is never considered list
+operator, though it allows an optional set of empty parentheses.
+Unlike functions and list operators with arguments (see above),
+a 0-ary function does not require parentheses even if followed
+immediately by a postfix.
+=item * A non-multi sub predeclared with an arity of exactly 1 parses
+as a named unary in precedence.  All other subs with arguments
+parse as list operators.  (In other words, a named unary operator
+may be declared to take extra arguments only if they are named-only
 =head1 New operators

Thread Next Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at | Group listing | About