Author: lwall
Date: 2009-10-09 01:51:23 +0200 (Fri, 09 Oct 2009)
New Revision: 28668

[S06,S12] clarify when yada is taken to be a stub
[S06] clarify semantics of package subs
[S06] document that subs default to 'my' scope now

Modified: docs/Perl6/Spec/S06-routines.pod
--- docs/Perl6/Spec/S06-routines.pod    2009-10-08 22:55:49 UTC (rev 28667)
+++ docs/Perl6/Spec/S06-routines.pod    2009-10-08 23:51:23 UTC (rev 28668)
@@ -16,8 +16,8 @@
     Created: 21 Mar 2003
-    Last Modified: 3 Oct 2009
-    Version: 117
+    Last Modified: 8 Oct 2009
+    Version: 118
 This document summarizes Apocalypse 6, which covers subroutines and the
 new type system.
@@ -100,6 +100,14 @@
     my @subs = (sub foo { ... }, sub bar { ... });
+Another difference is that subroutines default to C<my> scope rather
+than C<our> scope.  However, subroutine dispatch searches lexical
+scopes outward, and subroutines are also allowed to be I<postdeclared>
+after their use, so you won't notice this much.  A subroutine that is
+not declared yet may be called using parentheses around the arguments,
+in the absence of parentheses, the subroutine call is assumed to take
+multiple arguments in the form of a list operator.
 =head2 Anonymous subroutines
 The general syntax for anonymous subroutines is:
@@ -248,10 +256,14 @@
 you must explicitly use the "C<supersede>" declarator.  (The compiler may
 refuse to do this if it has already committed to the previous definition.)
-The C<...> is the "yadayadayada" operator, which is executable but returns
-a failure.  You can also use C<???> to produce a warning, or C<!!!> to
-always die.  These also officially define stub blocks if used as the
-only expression in the block.
+The C<...> is the "yadayadayada" operator, which is executable but
+returns a failure.  You can also use C<???> to produce a warning,
+or C<!!!> to always die.  These also officially define stub blocks.
+Any of these yada operators will be taken as a stub if used as the main
+operator of the first statement in the block.  (Statement modifiers
+are allowed on that statement.)  The yada operators differ from their
+respective named functions in that they all default to a message
+such as: "Unimplemented stub of sub foo was executed".
 It has been argued that C<...> as literal syntax is confusing when
 you might also want to use it for metasyntax within a document.
@@ -265,15 +277,18 @@
 =head2 Globally scoped subroutines
-Subroutines and variables can be declared in the global namespace, and are
-thereafter visible everywhere in a program via the GLOBAL package.  They
-may be made directly visible by importation.
+Subroutines and variables can be declared in the global namespace
+(or any package in the global namespace), and are thereafter visible
+everywhere in the program via the GLOBAL package (or one of its
+subpackages).  They may be made directly visible by importation,
+but may not otherwise be called with a bare identifier, since subroutine
+dispatch only looks in lexical scopes.
 Global subroutines and variables are normally referred to by prefixing
 their identifiers with the C<*> twigil, to allow contextual overrides.
     GLOBAL::<$next_id> = 0;
-    sub GLOBAL::saith($text)  { print "Yea verily, $text" }
+    sub GLOBAL::saith($text)  { say "Yea verily, $text" }
     module A {
         my $next_id = 2;     # hides any global or package $next_id
@@ -293,11 +308,21 @@
         saith($next_id);    # Unambiguously the global definitions
+Despite the fact that subroutine dispatch only looks in lexical scopes, you
+can always call a package subroutine directly if there's a lexical alias
+to it, as the C<our> declarator does:
+    module C;
+    our sub saith($text)  { say "Yea verily, $text" }
+    saith("I do!")      # okay
+    C::saith("I do!")   # also okay
 =head2 Dynamically scoped subroutines
 Similarly, you may define contextual subroutines:
     my sub myfunc ($x) is context { ... }
+    my sub &*myfunc ($x) { ... }        # same thing
 This may then be invoked via the syntax for contextual variables:

Modified: docs/Perl6/Spec/S12-objects.pod
--- docs/Perl6/Spec/S12-objects.pod     2009-10-08 22:55:49 UTC (rev 28667)
+++ docs/Perl6/Spec/S12-objects.pod     2009-10-08 23:51:23 UTC (rev 28668)
@@ -49,10 +49,11 @@
 The first form is allowed only as the first declaration in a compilation
 unit (that is, file or eval string).
-If the class body consists of a single statement consisting of a
+If the class body begins with a statement whose main operator is a
 single C<< prefix:<...> >> (yada) listop, the class name is introduced
 without a definition, and a second declaration of that class in the
-same scope does not complain about redefinition.  Thus you may
+same scope does not complain about redefinition.  (Statement modifiers
+are allowed on such a C<...> operator.)  Thus you may
 forward-declare your classes:
     class A {...}     # introduce A as a class name without definition

Reply via email to