Author: larry
Date: Wed Mar  7 17:25:32 2007
New Revision: 14316

Modified:
   doc/trunk/design/syn/S03.pod

Log:
Clarifications requested by TheDamian++
Defined ++ and -- in terms of .succ and .pred so I could write s[] = $0.succ


Modified: doc/trunk/design/syn/S03.pod
==============================================================================
--- doc/trunk/design/syn/S03.pod        (original)
+++ doc/trunk/design/syn/S03.pod        Wed Mar  7 17:25:32 2007
@@ -312,12 +312,40 @@
 
     say $x unless %seen{$x}++;
 
-Increment of a C<Str> (in a suitable container) works as in Perl 5.
-(Use a derived type or a lexical multi to change this.)  Perl 6 also
-supports C<Str> decrement.
+Increment of a C<Str> (in a suitable container) works similarly to
+Perl 5 except that the final alphanumeric sequence in the string is
+incremented regardless of what comes before it.  For its typical use
+of incrementing a filename, you don't have to worry about the path name, but
+you do still have to worry about the extension, so you probably want to say
+
+    my $fh = open $filename++ ~ '.jpg';
+
+Alternately, you can increment a submatch:
+
+    $filename ~~ s[^.* <(\w+)> \.\w+$] = $().succ;
+
+Perl 6 also supports C<Str> decrement.
+
+Increment and decrement are defined in terms of the C<.succ> and
+C<.pred> methods on the type of object in the C<Scalar> container.
+More specifically,
+
+    ++$var
+    --$var
+
+are equivalent to
+
+    $var.=succ
+    $var.=pred
+
+If the type does not support these methods, the corresponding increment
+or decrement operation will fail.  (The optimizer is allowed to assume
+that the ordinary increment and decrement operations on integers will
+not be overridden.)
 
 Increment of a C<Bool> (in a suitable container) turns it true.
-Decrement turns it false.  This is useful if your C<%seen> array is
+Decrement turns it false regardless of how many times it was
+previously incremented.  This is useful if your C<%seen> array is
 actually a C<KeySet>, in which case decrement actually deletes it
 from the C<KeySet>.
 
@@ -872,9 +900,14 @@
 
     ||
 
-Returns the left argument if it's true, otherwise evaluates and
-returns the right argument.  In list context forces a false return
-to mean C<()>.  See C<or> below for low-precedence version.
+Returns the left argument if it's true, otherwise evaluates and returns
+the right argument.  It is specifically allowed to use a list or array
+both as a boolean and as a list value produced if the boolean is true:
+
+    @a = @b || @c;              # broken in Perl 5; works in Perl 6
+
+In list context this operator forces a false return to mean C<()>.
+See C<or> below for low-precedence version.
 
 =item *
 
@@ -1810,7 +1843,7 @@
 
 =item *
 
-A function predeclared as 0-ary is never considered list
+A function predeclared as 0-ary is never considered a list
 operator, though it allows an optional set of empty parentheses.
 Unlike functions and list operators with arguments (see above),
 a 0-ary function does not require parentheses even if followed
@@ -2024,10 +2057,13 @@
 a negative C<:by> causes the C<.minmax> method returns C<(.to,.from)>
 instead.  You may also use C<.min> and C<.max> to produce the individual
 values of the C<.minmax> pair, but again note that they are reversed
-from C<.from> and C<.to> when the step is negative.
+from C<.from> and C<.to> when the step is negative.  Since a reversed
+C<Range> changes its direction, it swaps its C<.from> and C<.to> but
+not its C<.min> and C<.max>.
 
 Because C<Range> objects are lazy, they do not automatically generate
-a list.  So smart matching against a C<Range> object smartmatches the
+a list.  One result of this is that a reversed C<Range> object is still lazy.
+Another is that smart matching against a C<Range> object smartmatches the
 endpoints in the domain of the object being matched, so fractional
 numbers are C<not> truncated before comparison to integer ranges:
 
@@ -2208,13 +2244,13 @@
     Hash      Hash      hash keys same set      $_.keys === X.keys
     Set       Hash      hash keys same set      $_ === X.keys
     Array     Hash      hash slice existence    X.contains(any @$_)
-    Regex     Hash      hash key grep           any($_.keys) === /X/
+    Regex     Hash      hash key grep           any(X.keys).match($_)
     Scalar    Hash      hash entry existence    X.contains($_)
     Any       Hash      hash slice existence    X.contains(any @$_)
 
     Str       Regex     string pattern match    .match(X)
-    Hash      Regex     hash key "boolean grep" .any.match(/X/)
-    Array     Regex     array "boolean grep"    .any.match(/X/)
+    Hash      Regex     hash key "boolean grep" .any.match(X)
+    Array     Regex     array "boolean grep"    .any.match(X)
     Any       Regex     pattern match           .match(X)
 
     Num       Range     in numeric range        X.min <= $_ <= X.max (mod ^'s)
  • [svn:perl6-synopsis] r14316 - doc/trunk/design/syn larry

Reply via email to