Author: lwall
Date: 2009-11-20 09:39:12 +0100 (Fri, 20 Nov 2009)
New Revision: 29144
Modified:
docs/Perl6/Spec/S02-bits.pod
docs/Perl6/Spec/S03-operators.pod
docs/Perl6/Spec/S04-control.pod
Log:
[Specs] more constant cleanups
add 'anon' declarator in place of 'my'/'our' misuse
Modified: docs/Perl6/Spec/S02-bits.pod
===================================================================
--- docs/Perl6/Spec/S02-bits.pod 2009-11-20 07:10:40 UTC (rev 29143)
+++ docs/Perl6/Spec/S02-bits.pod 2009-11-20 08:39:12 UTC (rev 29144)
@@ -1492,14 +1492,11 @@
$lay = sub of Egg {...}; # of type
$lay = sub (--> Egg) {...}; # of type
-but you can use a scope modifier to introduce an C<of> prefix type:
+but you can use the C<anon> scope declarator to introduce an C<of> prefix type:
- $lay = my Egg sub {...}; # of type
- $hat = my Rabbit sub {...}; # of type
+ $lay = anon Egg sub {...}; # of type
+ $hat = anon Rabbit sub {...}; # of type
-Because they are anonymous, you can change the C<my> modifier to C<our>
-without affecting the meaning.
-
The return type may also be specified after a C<< --> >> token within
the signature. This doesn't mean exactly the same thing as C<as>.
The C<of> type is the "official" return type, and may therefore be
Modified: docs/Perl6/Spec/S03-operators.pod
===================================================================
--- docs/Perl6/Spec/S03-operators.pod 2009-11-20 07:10:40 UTC (rev 29143)
+++ docs/Perl6/Spec/S03-operators.pod 2009-11-20 08:39:12 UTC (rev 29144)
@@ -16,7 +16,7 @@
Created: 8 Mar 2004
Last Modified: 19 Nov 2009
- Version: 177
+ Version: 178
=head1 Overview
@@ -4273,7 +4273,6 @@
our $foo # lexically scoped alias to package variable
has $foo # object attribute
state $foo # persistent lexical (cloned with closures)
- constant $foo # "our" scoped compile-time constant
Variable declarators such as C<my> now take a I<signature> as their
argument. (The syntax of function signatures is described more fully in S06.)
@@ -4282,11 +4281,20 @@
simple declaration that declares a single variable, along with its
associated type, traits and the initializer:
- constant Dog $foo is woof = 123; # okay: initializes $foo to 123
- constant (Dog $foo is woof = 123); # same thing (with explicit parens)
- constant :(Dog $foo is woof = 123); # same thing (full Signature form)
- constant (Dog $foo is woof) = 123; # wrong: constants cannot be assigned
to
+ my Dog $foo is woof = 123; # okay: initializes $foo to 123
+ my (Dog $foo is woof = 123); # same thing (with explicit parens)
+ my :(Dog $foo is woof = 123); # same thing (full Signature form)
+The C<constant> declarator can declare either variables or names
+as compile-time constants:
+
+ constant $foo = 1; # compile-time constant variable
+ constant bar = 2; # compile-time constant symbol
+
+Because it can declare names in "type" space, the C<constant>
+declarator may not declare using the signature, which would be
+ambiguous.
+
Each declarator can take an initializer following an equals
sign (which should not be confused with a normal assignment, because
the timing of the initialization depends on the natural lifetime of the
@@ -4315,17 +4323,17 @@
List-context pseudo-assignment is supported for simple declarations but
not for signature defaults:
- constant @foo = 1,2,3; # okay: initializes @foo to (1,2,3)
- constant (@foo = 1,2,3); # wrong: 2 and 3 are not variable names
+ my @foo = 1,2,3; # okay: initializes @foo to (1,2,3)
+ my (@foo = 1,2,3); # wrong: 2 and 3 are not variable names
When parentheses are omitted, you may use any infix assignment operator
instead of C<=> as the initializer. In that case, the left hand side of
the infix operator will be the variable's prototype object:
- constant Dog $fido .= new; # okay: a constant Dog object
- constant Dog $fido = Dog.new; # same thing
- constant Dog $fido = $fido.new; # wrong: invalid self-reference
- constant (Dog $fido .= new); # wrong: cannot use .= with parens
+ my Dog $fido .= new; # okay: a constant Dog object
+ my Dog $fido = Dog.new; # same thing
+ my Dog $fido = $fido.new; # wrong: invalid self-reference
+ my (Dog $fido .= new); # wrong: cannot use .= inside signature
Note that very few mutating operators make sense on a type object, however,
since type objects are a kind of undefined object. (Those operators with
@@ -4396,6 +4404,8 @@
class Foo
role Foo
subset Foo
+ enum Foo
+ constant Foo
and code declarators:
@@ -4412,6 +4422,17 @@
These all have their uses and are explained in subsequent Synopses.
+Note that since C<constant> is parsed as a type declarator (essentially
+declaring a type with a single value), it can actually take a scope
+declarator in front:
+
+ my constant companion = 'Fido';
+ has constant $.pi = 22/7;
+ state constant $latch = snapshot();
+
+In these cases the explicit scoping determines when the initializer is
+evaluated.
+
=head1 Argument List Interpolating
Perl 5 forced interpolation of a function's argument list by use of
Modified: docs/Perl6/Spec/S04-control.pod
===================================================================
--- docs/Perl6/Spec/S04-control.pod 2009-11-20 07:10:40 UTC (rev 29143)
+++ docs/Perl6/Spec/S04-control.pod 2009-11-20 08:39:12 UTC (rev 29144)
@@ -157,14 +157,16 @@
As in Perl 5, "C<our $foo>" introduces a lexically scoped alias for
a variable in the current package.
-The new C<constant> declarator introduces an "our"-scoped name
-for a compile-time constant, either a variable or named value, which
+The new C<constant> declarator introduces a
+compile-time constant, either a variable or named value, which
may be initialized with a pseudo-assignment:
constant Num $pi = 3;
constant Num π = atan2(2,2) * 4;
-The initializing expression is evaluated at C<BEGIN> time.
+The initializing expression is evaluated at C<BEGIN> time. Constants
+(and enums) default to C<our> scoping so they can be accessed from
+outside the package.
There is a new C<state> declarator that introduces a lexically scoped
variable like C<my> does, but with a lifetime that persists for the
