Author: lwall
Date: 2009-09-07 19:53:06 +0200 (Mon, 07 Sep 2009)
New Revision: 28199

[S10] specify time of execution of package blocks and module (non)mainline code
[S12] give example of use of yada classes

Modified: docs/Perl6/Spec/S04-control.pod
--- docs/Perl6/Spec/S04-control.pod     2009-09-07 17:43:11 UTC (rev 28198)
+++ docs/Perl6/Spec/S04-control.pod     2009-09-07 17:53:06 UTC (rev 28199)
@@ -823,7 +823,7 @@
 sets the topic in its signature can be broken out of.  At run time,
 C<break> uses a control exception to scan up the dynamic chain to
 find the activation record belonging to that same outer block, and
-when it has found that scope, it does a C<.leave> on it to unwinde
+when it has found that scope, it does a C<.leave> on it to unwind
 the contexts.  If any arguments are supplied to the C<break> function,
 they are passed out via the C<leave> method.  Since leaving a block is
 considered a successful return, breaking out of one is also considered

Modified: docs/Perl6/Spec/S10-packages.pod
--- docs/Perl6/Spec/S10-packages.pod    2009-09-07 17:43:11 UTC (rev 28198)
+++ docs/Perl6/Spec/S10-packages.pod    2009-09-07 17:53:06 UTC (rev 28199)
@@ -13,8 +13,8 @@
     Created: 27 Oct 2004
-    Last Modified: 13 Feb 2009
-    Version: 9
+    Last Modified: 7 Sep 2009
+    Version: 10
 =head1 Overview
@@ -85,6 +85,44 @@
 syntax that lets you do a lookup in a particular symbol table.  In this case,
 the key is not parsed for C<::>.  It's just a hash lookup.
+All package bodies (including module and class bodies) execute at the
+normal execution time of the code in which they are embedded.  For normal
+mainline code, this is the normal flow of execution; if this is too late
+to initialize something in the package that you want to be initialized, 
+use of a MAIN subroutine, which is invoked at the end of normal execution.
+See L<S06/Declaring a C<MAIN> subroutine>.
+For packages (modules, classes, roles, etc.) defined in separate files
+from the mainline code, there can be no mainline code by definition,
+but the top-level code in the used module needs to be executed at
+some point in case things need initialization.  Invocation of this
+pseudo-mainline code in the module notionally happens no later than at
+the point of the C<use> or C<need> call in the process of compilation,
+but the module's code is assumed to be sufficiently uninteresting that
+it need be executed only once regardless of how many times the module
+is used subsequently in the compilation.  (In fact, it might not need
+to run at all if the result of some previous compilation's run has
+been cached.)
+If it is desired to have code that varies in meaning from run to run,
+then you should put such code into an INIT block.  (Likewise, you
+could put code into a CHECK block that has inconsistent semantics
+from compilation to compilation, but that's probably a bad idea.)
+In any case, it is erroneous for any external module to depend
+on any knowledge of its user with respect to compilation order or
+other contextual information, since other users may also depend on
+this single "first-use" execution and expect consistent semantics.
+(Really, all such contextual dependencies should be passed in at run
+time to the routines or methods of your module as normal parameters or
+contextual variables.  For instance, you cannot know at module compile
+time whether your caller is going to be using 'fatal' semantics or not.
+That is dynamically scoped info.)
+If you wish to have a module that does something extra if invoked
+standalone, define a MAIN subroutine, which will be ignored if
+the module is merely used/needed elsewhere.
 =head1 Package nesting
 A declaration of any object of the form C<A::B::c> also creates (if needed)

Modified: docs/Perl6/Spec/S12-objects.pod
--- docs/Perl6/Spec/S12-objects.pod     2009-09-07 17:43:11 UTC (rev 28198)
+++ docs/Perl6/Spec/S12-objects.pod     2009-09-07 17:53:06 UTC (rev 28199)
@@ -13,8 +13,8 @@
     Created: 27 Oct 2004
-    Last Modified: 29 Jun 2009
-    Version: 86
+    Last Modified: 7 Sep 2009
+    Version: 87
 =head1 Overview
@@ -42,23 +42,43 @@
 There are two basic class declaration syntaxes:
     class Foo;          # rest of file is class definition
-    ...
+    has $.foo;
-    class Bar {...}     # block is class definition
+    class Bar { has $.bar }     # block is class definition
 The first form is allowed only as the first declaration in a compilation
 unit (that is, file or eval string).
-In either case, the code represented by C<...> executes at compile
-time as the body of a method of the metaclass, which is responsible
-for interpreting the keywords of the class definition.  (And since a
-class is also a module, it also handles any module-oriented keywords.
-You can export subs from a class at "use" time, for instance.)
+If the class body consists of a single statement consisting of 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
+forward-declare your classes:
-If the class body consists only of a  literal C<...> (yada) term, it is
-interpreted as a forward declaration that just tells the compiler that the
-class name is a type name, to be defined later on.
+    class A {...}     # introduce A as a class name without definition
+    class B {...}     # introduce B as a class name without definition
+    my A $root .= new(:a(B));
+    class A { 
+        has B $.a;
+    }
+    class B { 
+        has A $.b;
+    }
+As this example demonstrates, this allows for mutually recursive class
+definitions (though, of course, it can't allow recursive inheritance).
+It is also possible to extend classes via the C<augment> declarator,
+but that is considered somewhat antisocial and should not be used
+for forward declarations.
+[Conjecture: we may also allow the C<proto> and C<multi> modifiers
+to explicitly declare classes with multiple bodies participating in
+a single definition intentionally.]
 A named class declaration can occur as part of an expression, just like
 named subroutine declarations.

Reply via email to