Author: larry
Date: Sat Jun 3 19:45:11 2006
New Revision: 9463
Modified:
doc/trunk/design/syn/S03.pod
Log:
Change default lvalue parsing to default to list, with short list of scalars.
Modified: doc/trunk/design/syn/S03.pod
==============================================================================
--- doc/trunk/design/syn/S03.pod (original)
+++ doc/trunk/design/syn/S03.pod Sat Jun 3 19:45:11 2006
@@ -12,9 +12,9 @@
Maintainer: Larry Wall <[EMAIL PROTECTED]>
Date: 8 Mar 2004
- Last Modified: 19 May 2006
+ Last Modified: 3 Jun 2006
Number: 3
- Version: 35
+ Version: 36
=head1 Changes to existing operators
@@ -109,22 +109,35 @@
loop ($a = 1, $b = 2; ; $a++, $b++) {...}
-still works fine. The distinction between scalar and list assignment
-is similar to the way Perl 5 does it. If there are parens around
-the left side, or if the variable is an array or hash, it's a list
-assignment. Otherwise it's a scalar assignment. One difference from
-Perl 5 is that Perl 6 does not attempt to intuit whether an lvalue
-slice is meant to be one element or several, so you must use parens
-in that case. This is true even if you put something that is obviously
-a list as the subscript:
-
- @x[1,2,3] = 4,5,6; # WRONG
- (@x[1,2,3]) = 4,5,6; # correct
-
-These parens actually apply list context on both sides:
-
- @x[foo()] = bar(); # foo() and bar() both in scalar context
- (@x[foo()]) = bar(); # foo() and bar() both in list context
+still works fine. The distinction between scalar and list
+assignment is similar to the way Perl 5 does it, but has to be a
+little different because we can no longer decide on the basis of
+the sigil. The following forms are defined as "obviously simple",
+and imply scalar assignment:
+
+ $a # simple scalar variable
+ @a[123] # single literal subscript
+ %a{'x'} # single literal subscript
+ %a<x> # single literal subscript
+ @a[+TERM] # single term coerced to numeric for array
+ %a{~TERM} # single term coerced to string for hash
+ @a[SIMPLE] # any of these simples used as subscript recursively
+ %a[SIMPLE] # any of these simples used as subscript recursively
+
+All other forms imply list assignment, and will evaluate both sides
+of the assignment in list context (eventually). However, this is
+primarily a syntactic distinction, and no semantic or type information
+is used, since it influences subsequent parsing. In particular, even
+if a function is known to return a scalar value from its declaration,
+you must use C<+> or or C<~> to use it as a scalar within a subscript:
+
+ @a[foo()] = bar(); # foo() and bar() called in list context
+ @a[+foo()] = bar(); # foo() and bar() called in scalar
context
+
+(But note that the first form still works fine if C<foo()> and C<bar()>
+are scalar functions that are not context sensitive. The difference
+in parsing is only an issue if C<bar()> is followed by a comma or
+some such.)
=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
