Author: larry
Date: Thu Feb 8 13:52:24 2007
New Revision: 13577
Modified:
doc/trunk/design/syn/S04.pod
doc/trunk/design/syn/S05.pod
doc/trunk/design/syn/S06.pod
doc/trunk/design/syn/S12.pod
Log:
Unified proto processing to implicitly allow redeclarations within scope.
This works on most declarators, including regex, token, rule, and variables.
Multiple my declarations warn about redeclaration as suggested by lukastic++.
This may be suppressed with a "proto" declaration of the variable.
The "multi" keyword is now optional in the scope of a proto.
The "unique" keyword now "undoes" an outer "proto".
Modified: doc/trunk/design/syn/S04.pod
==============================================================================
--- doc/trunk/design/syn/S04.pod (original)
+++ doc/trunk/design/syn/S04.pod Thu Feb 8 13:52:24 2007
@@ -12,9 +12,9 @@
Maintainer: Larry Wall <[EMAIL PROTECTED]>
Date: 19 Aug 2004
- Last Modified: 29 Jan 2007
+ Last Modified: 8 Feb 2007
Number: 4
- Version: 50
+ Version: 51
This document summarizes Apocalypse 4, which covers the block and
statement syntax of Perl.
@@ -75,6 +75,15 @@
my $x;
my $x;
+By default the second declaration will get a compiler warning.
+You may suppress this by modifying the first declaration
+with C<proto>:
+
+ my proto $x;
+ ...
+ while my $x = @x.shift {...} # no warning
+ while my $x = @x.shift {...} # no warning
+
If you've referred to C<$x> prior to the first declaration, and the compiler
tentatively bound it to C<$OUTER::x>, then it's an error to declare it, and
the compiler is required to complain at that point. If such use can't
Modified: doc/trunk/design/syn/S05.pod
==============================================================================
--- doc/trunk/design/syn/S05.pod (original)
+++ doc/trunk/design/syn/S05.pod Thu Feb 8 13:52:24 2007
@@ -14,9 +14,9 @@
Maintainer: Patrick Michaud <[EMAIL PROTECTED]> and
Larry Wall <[EMAIL PROTECTED]>
Date: 24 Jun 2002
- Last Modified: 5 Feb 2007
+ Last Modified: 8 Feb 2007
Number: 5
- Version: 50
+ Version: 51
This document summarizes Apocalypse 5, which is about the new regex
syntax. We now try to call them I<regex> rather than "regular
@@ -670,17 +670,19 @@
=item *
-Alternatively, if you predeclare a category, you can write multiple
-rules for the same category, differentiated only by the symbol they
+Alternatively, if you predeclare a proto regex, you can write multiple
+regexes for the same category, differentiated only by the symbol they
match:
- category sigil;
- token sigil { :<$> }
- token sigil { :<@> }
- token sigil { :<@@> }
- token sigil { :<%> }
- token sigil { :<&> }
- token sigil { :<::> }
+ proto token sigil;
+ multi token sigil { :<$> }
+ multi token sigil { :<@> }
+ multi token sigil { :<@@> }
+ multi token sigil { :<%> }
+ multi token sigil { :<&> }
+ multi token sigil { :<::> }
+
+(The C<multi> is optional and generally omitted with a grammar.)
This can be viewed as a form of multiple dispatch, except that it's
based on longest-token matching rather than signature matching. The
@@ -688,6 +690,11 @@
rules to the same category in a derived grammar. All of them will
be matched in parallel when you try to match C<< /<sigil>/ >>.
+If there are formal parameters on multi regex methods, matching
+still proceeds via longest-token rules first. If that results in a
+tie, a normal multiple dispatch is made using the arguments to the
+remaining variants, assuming they can be differentiated by type.
+
=item *
An interpolated hash matches the longest possible token. The match
Modified: doc/trunk/design/syn/S06.pod
==============================================================================
--- doc/trunk/design/syn/S06.pod (original)
+++ doc/trunk/design/syn/S06.pod Thu Feb 8 13:52:24 2007
@@ -58,7 +58,11 @@
B<Prototypes> (keyword: C<proto>) specify the commonalities (such
as parameter names, fixity, and associativity) shared by all multis
-of that name in the scope of the C<proto> declaration.
+of that name in the scope of the C<proto> declaration. A C<proto>
+also forces all routines of the same short name within the scope to
+be considered C<multi> whether they are explicitly declared so or not.
+(This is particularly useful when adding to rule sets or when attempting
+to compose conflicting methods from roles.)
A modifier keyword may occur before the routine keyword in a named routine:
Modified: doc/trunk/design/syn/S12.pod
==============================================================================
--- doc/trunk/design/syn/S12.pod (original)
+++ doc/trunk/design/syn/S12.pod Thu Feb 8 13:52:24 2007
@@ -12,9 +12,9 @@
Maintainer: Larry Wall <[EMAIL PROTECTED]>
Date: 27 Oct 2004
- Last Modified: 3 Feb 2007
+ Last Modified: 8 Feb 2007
Number: 12
- Version: 38
+ Version: 39
=head1 Overview
@@ -729,7 +729,15 @@
of its invocant arguments. The "short name" doesn't. If you put
C<multi> in front of any sub (or method) declaration, it allows
multiple long names to share a short name, provided all of them are
-declared C<multi>. A sub (or method) without a C<multi> doesn't share
+declared C<multi>. (Putting C<proto> on the first such declaration has
+the same effect, but usually you want to put the C<multi> explicitly
+anyway for documentation.) If a sub (or method) is not marked
+with C<multi> or within the scope of a C<proto>, it is considered a
+I<unique> sub. You may mark a sub explicitly as C<unique> as well, if
+you're worried it might be within the scope of a C<proto>, and want there
+to be only one such routine within this scope.
+
+A unique sub (or method) doesn't share
with anything outside of it or declared prior to it. Only one such
sub (or method) can inhabit a given namespace, and it hides any outer
subs (or less-derived methods) of the same short name. It may share
@@ -1066,11 +1074,11 @@
Alternately, if the role's methods are declared C<multi>, they can be
disambiguated based on their long name. If the roles forget to declare
them as multi, you can force a multi on the roles' methods by installing
-a multi stub in the class being constructed:
+a proto stub in the class being constructed:
- multi method shake {...}
+ proto method shake {...}
-A proto method also works, and will be called if the multi fails:
+The proto method will be called if the multi fails:
proto method shake { warn "They couldn't decide" }
@@ -1082,7 +1090,7 @@
class DogTree {
does DogBark;
does TreeBark;
- multi method bark {...}
+ proto method bark {...}
...
}
