Changeset 17701 for docs

Timestamp:

09/06/07 19:43:34 (16 months ago)

Author:

lwall

Message:

s:g/err/orelse/

Location:

docs

Files:

• Perl6/API/Scalar.pod (modified) (1 diff)
• Perl6/Overview/File.pod (modified) (2 diffs)
• Perl6/Spec/Functions.pod (modified) (1 diff)
• notes/precompilation_cache.pod (modified) (1 diff)
• notes/unicode_draft (modified) (1 diff)
• other/porting_howto (modified) (1 diff)
• tutorial/ch04_basic_syntax.pod (modified) (11 diffs)
• tutorial/ch07_grammars.pod (modified) (1 diff)

docs/Perl6/API/Scalar.pod

@@ -57 +57 @@
 warning in doing so. There are two ways to determine if a
 value equal to undef: the C<defined> function (or method) can
-be called or the C<//> (or C<err>) operator can be used.
+be called or the C<//> (or C<orelse>) operator can be used.
 
 C<undef> is also considered to be false in a boolean context.

docs/Perl6/Overview/File.pod

@@ -14 +14 @@
     # if MODE left out it defaults to :r
     
-    my $fh = open "filename", :r err die "Could not open file $!";
+    my $fh = open "filename", :r orelse die "Could not open file $!";
 
     my $row = =$fh;                           # reading a line
@@ -27 +27 @@
 =head2 Directories
 
-    my $dh = opendir "dirname" err die "Could not open directory $!";
+    my $dh = opendir "dirname" orelse die "Could not open directory $!";
 
     my @files = readdir($dh);

docs/Perl6/Spec/Functions.pod

@@ -447 +447 @@
 warning in doing so. There are two ways to determine if a
 value equal to undef: the C<defined> function (or method) can
-be called or the C<//> (or C<err>) operator can be used.
+be called or the C<//> (or C<orelse>) operator can be used.
 
 C<undef> is also considered to be false in a boolean context.

docs/notes/precompilation_cache.pod

@@ -122 +122 @@
       die "no precompiled version found" unless $dir ~~ :d;
       for $dir.readdir.sort:{numerically} -> $fn {
-          my ($pugsrev, $parserrev) = $fn ~~ /(\d+)-(\d+)/ err next;
+          my ($pugsrev, $parserrev) = $fn ~~ /(\d+)-(\d+)/ orelse next;
           next if $XXX_handwaving($pugsrev, $parserrev); # against %?CONFIG<pugsrev> etc.
           
-          load_precompiled($fn) err {
+          load_precompiled($fn) orelse {
               $fn.rm;
               die "error loading cached version: $!";

docs/notes/unicode_draft

@@ -215 +215 @@
 
     # but you can handle it with
-    $x err die "..."
+    $x orelse die "..."
     if $x { ... }

docs/other/porting_howto

@@ -241 +241 @@
 
   - open()
-       open my $fh, "<", $filename or die $!;    ->   my $fh = open($filename, :r) err die $!;
+       open my $fh, "<", $filename or die $!;    ->   my $fh = open($filename, :r) orelse die $!;
 
        "<"   -> :r

docs/tutorial/ch04_basic_syntax.pod

@@ -449 +449 @@
 keyword:
 
-  my $pi is constant = 3.14159;
-
-The C<constant> trait specifies that the value of the variable can't
+  my $pi is readonly = 3.14159;
+
+The C<readonly> trait specifies that the value of the variable can't
 be changed.
 
@@ -459 +459 @@
 keyword:
 
-  $true_value = 0 but true;
-
-The C<true> property specifies that the value will evaluate as true in
+  $true_value = 0 but True;
+
+The C<True> property specifies that the value will evaluate as true in
 a boolean context, no matter what the actual value is. This particular
-property means the Perl 6 C<system> call can be checked with a simple
+property means the Perl 6 C<run> call can be checked with a simple
 conditional. It still returns the same numeric values it always has (0
 on success and a numeric error code on failure), but it flags the
@@ -488 +488 @@
 more precisely than Perl 5, but keep in mind that explicit types are
 completely optional. If you choose to use them, you'll gain some
-benefits in optimization and interfacing between languages. The design
-of the type system isn't complete, but the basic groundwork is in
-place.
+benefits in optimization and interfacing between languages.  The biggest
+benefit, however, is that types enable fine-grained control of multiple dispatch
+when you want it, or course-grained contol when you don't care.
 
 Perl 6 makes a distinction between the type of a value and the type of
@@ -508 +508 @@
 
   my Int %hash;
+
+The type of the keys may be declared in a pseudo-subscript.  Since the
+default key type is strings, the preceding declaration is actually short for:
+
+  my Int %hash{Str};
+
+To declare a hash that uses any object type for a key and always returns,
+say, an icon object, say:
+
+  my Icon %hash{Any}
 
 The I<variable> type specifies what kind of container the variable is.
@@ -698 +708 @@
   @range = 3..Inf; # lazy
 
-X<. (dot);... (infinite range);operator>
-The C<...> operator is equivalent to C<..Inf>:
-
-  @range = 3...;
+The C<*> token may be used instead of C<Inf>, which really only makes sense
+for numeric types:
+
+  @range = 3..*;
+  @range = 'a'..*;
 
 =head2 Comparison
@@ -739 +750 @@
 are aliases to the same object. Each returns a true value if the
 relation is true and a false value otherwise. The generic comparison
-operators (C<E<lt>=E<gt>>, C<cmp>) return C<0> if the two arguments are
+operators (C<E<lt>=E<gt>>, C<leg>) return C<0> if the two arguments are
 equal, C<1> if the first is greater, and C<-1> if the second is greater.
 
-  if ($age > 12) {...}
+  if $age > 12 {...}
 
 Comparison operators can also be chained. Chained comparisons 
 evaluate each value in the chain only once.
 
-  if (24 < $age < 42) {...} # 24 < $age and $age < 42
+  if 24 < $age < 42 {...} # 24 < $age and $age < 42
 
 =head2 Logical Operators
@@ -780 +791 @@
   $splat = ($whale or $petunia);
 
-X<err (test defined) operator>
+X<orelse (test defined) operator>
 X</ (slash);// (test defined) operator>
 A variant of the OR relation tests for definedness instead of truth.
-It uses the C<//> operator and the low-precedence C<err> operator. The
+It uses the C<//> operator and the low-precedence C<orelse> operator. The
 left-hand value is returned if it is defined, otherwise the right-hand
 side is evaluated and its value returned:
 
   $splat = $whale // $petunia;
-  $splat = ($whale err $petunia);
+  $splat = ($whale orelse $petunia);
 
 X<xor operator> 
@@ -1095 +1106 @@
 shortly. So while C<||> is a logical operation on two expressions:
 
-  if ($value == 1) || ($value == 2) { ... }
+  if $value == 1 || $value == 2 { ... }
 
 C<|> is the same logical relation between two values:
@@ -1113 +1124 @@
 
   $junc = 1 | 2;
-  if ($value == $junc) { ... }
+  if $value == $junc { ... }
 
 Here, the variable C<$junc> is used in place of C<1 | 2>, and has
@@ -1233 +1244 @@
 operators that's:
 
-  if ($a != $c) && ($a != $d) && ($b != $c) && ($b != $d) { ... }
+  if $a != $c && $a != $d && $b != $c && $b != $d { ... }
 
 If you want to get back a flat list of values from a junction, use the
@@ -1657 +1668 @@
 Z<CHP-4-SECT-3.1.1>
 
-X<if (conditional);statement>
+X<if conditional;statement>
 The C<if> statement checks a condition and executes its associated
 block only if that condition is true. The condition can be any

docs/tutorial/ch07_grammars.pod

@@ -45 +45 @@
 X<~ (tilde);~~ (smart match) operator>
 
-  if ($string ~~ m/\w+/)      {...}
-  if ($string ~~ s/\w+/word/) {...}
-  if ($string ~~ /\w+/)       {...}
+  if $string ~~ m/\w+/      {...}
+  if $string ~~ s/\w+/word/ {...}
+  if $string ~~ /\w+/       {...}
 
 You can substitute other delimiters, like C<#...#>, C<[...]>, and
 C<{...}> for the standard C</.../>, though C<?...?> and C<(...)> are
-not valid delimiters. 
-
-  if ($string ~~ s[\w+][word]) {...}
+not valid delimiters:
+
+  $string ~~ s/\w+/word/
+
+Modifiers now come in front using I<adverb> syntax, so to do multiple
+substitutions on the same string is:
+
+  $string ~~ s:g/\w+/word/
+
+Also, if you use brackets on the first part of a substitution, the second
+part is specified as a pseudoassignment:
+
+  $string ~~ s[\w+] = 'word';
+
+This form also allows assignment operators, so if you want to add one to
+all the number within a string, you can say:
+
+  $string ~~ s:g[\d+] += 1;
 
 =head2 Deferred Matches