Changeset 22630 for docs

Timestamp:

10/16/08 18:33:01 (3 months ago)

Author:

lwall

Message:

[Differences] various corrections

Files:

• docs/Perl6/Perl5/Differences.pod (modified) (6 diffs)

docs/Perl6/Perl5/Differences.pod

@@ -153 +153 @@
 etc.
 
-Parenthesis don't construct lists any more, they merely group. Lists are
-constructed with the comma operator. It has looser precedence than the list
+Parenthesis don't construct lists, they merely group. Lists are
+constructed with the comma operator. It has tighter precedence than the list
 assignment operator, which allows you to write lists on the right hand side
-wihtout parens:
+without parens:
     
     my @list = 1, 2, 3;     # @list really has three elements
 
-The arrow operator C<< -> >> for dereferncing is gone. Since (nearly)
-everything is a reference, you can directly use the apropriate pair of
-parenthesis for either indexing or method calls:
+The arrow operator C<< -> >> for dereferencing is gone. Since (nearly)
+everything is a reference, you can directly use the appropriate pair of
+parentheses for either indexing or method calls:
     
     my $lol = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
@@ -317 +317 @@
     Now:    $object.method
 
-=head2 Using code references in dynamic method calls is gone.
-
-  Was: $self.$coderef() 
-  Now: $coderef(self:)
+=head2 Dynamic method calls distinguish symbolic refs from hard refs
+
+  Was: $self->$method() 
+  Now: $self.$method()          # hard ref
+  Now: $self."$method"()        # symbolic ref
 
 =cut 
@@ -331 +332 @@
 changing their behaviour for particular types is a simple as adding the
 appropriate multi subs and methods. If you want these to be globally
-available, you have to but them into the C<GLOBAL> namespace, which is
-indicated by an asterisk.
-
-    multi sub *uc(TurkishStr $str) { ... }
+available, you have to but them into the C<GLOBAL> namespace:
+
+    multi sub GLOBAL::uc(TurkishStr $str) { ... }
 
     # "overload" the string concatenation:
@@ -398 +398 @@
 # XXX needs some brave rewrite
 
-=head1 Documentation
-
-You now use <em>kwid</em> for documentation instead of POD. Kwid
-is a wiki-like syntax that is easy to write, and pleasant to read directly.
-
-Here is a side-by-side comparison of some of the major features of Pod and
-Kwid:
-
-     =head1 Big Thing                    = Big Thing
-
-     =head4 Small Thing                  ==== Small Thing
-
-     A paragraph of                      A paragraph of
-     plain text.                         plain text.
-
-         # verbatim                          # verbatim
-         sub v {                             sub v {
-             shift;                              shift;
-         }                                   }
-
-
-     =item * foo                         * foo
-     =item * bar                         * bar
-     =item2 N<> barber                   ++ barber
-     =item2 N<> bard                     ++ bard
-
-
-     Something B<strong>!                Something *strong*!
-
-     Something I<emphatic>!              Something /emphatic/!
-
-     Some code C<E = M * C ^ 2>!         Some code `E = M * C ^ 2`!
-
-     Some V<B<escaped>> markup           Some \*escaped\* markup
-
-     =begin Section_type                 .Section_type
-
-     =end Section_type                   !Section_type
-
-     =for Section_type                   :Section_type
-
-See L<S26> for details.
-
-=cut 
-
-#S29
 
 =head1 Builtin Functions
@@ -490 +444 @@
 =head2 wantarray()
 
-C<wantarray> is superseeded by C<want.list>. Also available are C<want.item>
+C<wantarray> is superseded by C<want.list>. Also available are C<want.item>
 and C<want.count>, the latter gives the number of expected values, if
 applicable.
@@ -512 +466 @@
 distinctly block-related now, so in fact what you've got there is a
 block that returns the value "February".  The C<<>> and C<<<>>> forms
-are in fact just quoting mechanisms (see below).
+are in fact just quoting mechanisms being used as subscripts (see below).
 
 =head2 Built-in functions are now methods
 
-Most (all?) built-in functions are now methods of built-in classes such
+Most built-in functions are now methods of built-in classes such
 as C<String>, C<Array>, etc.