Author: larry
Date: Sat Jun  2 14:45:43 2007
New Revision: 14414


First installment of filling out descriptions of operator semantics.

Modified: doc/trunk/design/syn/S03.pod
--- doc/trunk/design/syn/S03.pod        (original)
+++ doc/trunk/design/syn/S03.pod        Sat Jun  2 14:45:43 2007
@@ -97,21 +97,40 @@
 =item *
+    qq:to/END/
+        Dear $recipient:
+        Thanks!
+        Sincerely,
+        $me
+        END
+=item *
 Array composer
+Provides list context inside.
 =item *
 Hash composer
     { a => 42 }
+Inside must be a list of pairs, otherwise you must use C<hash()>
+or C<%()> instead.
 =item *
-    {...}
+    { ... }
+When found where a statement is expected, executes immediately.  Othewise
+always defers evaluation of the inside scope.
 =item *
@@ -119,6 +138,8 @@
+An abstraction representing an argument list that doesn't yet know its context.
 =item *
 Sigiled variables
@@ -128,7 +149,7 @@
-    @@multidim
+    @@slice
     &div:(Int, Int --> Int)
@@ -247,6 +268,9 @@
     $obj.Class::meth    # same thing, assuming Class is predeclared
+As in Perl 5, tells the dispatcher which class to start searching from,
+not the exact method to call.
 =item *
 Mutating method call
@@ -286,7 +310,7 @@
 Dotted postfix form of any other prefix operator
-    $x.'++'       # prefix:<++>($x), fallback to postfix:<++>
+    $x.:<++>       # prefix:<++>($x)
@@ -396,79 +420,109 @@
 prefix:<?>, boolean context
-    ?
+    ?$x
+Evaluates the expression as a boolean and returns C<True> if expression
+is true or C<False> otherwise.
 See "true" below for a low-precedence alternative.
 =item *
 prefix:<!>, boolean negation
-    !
+    !$x
+Returns the opposite of what C<?> would.
 See "not" below for a low-precedence alternative.
 =item *
 prefix:<+>, numeric context
-    +
+    +$x
+Unlike in Perl 5, where C<+> is a no-op, this operator coerces
+to numeric context in Perl 6.  (It coerces only the value, not the
+original variable.)  The narrowest appropriate type of C<Int>, C<Num>,
+or C<Complex> will be returned.  A string containing two integers
+separated by a C</> will be returned as a C<Rat>.  Exponential notation
+and radix notations are recognized.
 =item *
 prefix:<->, numeric negation
-    -
+    -$x
+Coerces to numeric and returns the negation of the resulting number.
 =item *
 prefix:<~>, string context
-    ~
+    ~$x
+Coerces the value to a string.  (It only coerces the value, not the
+original variable.)
 =item *
 prefix:<|>, flatten object into arglist
-    |
+    | $capture
+Interpolates the contents of the C<Capture> (or C<Capture>-like) value
+into the current argument list as if they had been specified literally.
 =item *
 prefix:<+^>, numeric bitwise negation
-    +^
+    +^$x
+Coerces to numeric and then does bitwise negation on the number.
 =item *
 prefix:<~^>, string bitwise negation
-    ~^
+    ~^$x
+Coerces to string buffer and then does bitwise negation on each element.
 =item *
 prefix:<?^>, boolean bitwise negation
-    ?^
+    ?^$x
+Coerces to boolean and then flips the bit.  (Same as C<!>.)
 =item *
 prefix:<\>, Capture constructor
-    \
+    \$x
+    \%x
+    \($invocant: $pos1, $pos2, :named($arg))
+Defers the contextualization of its argument or arguments till it is
+bound into some other context.
 =item *
 prefix:<^>, upto operator
-    ^
+    ^$limit
-Constructs a range or locates a metaclass.  See L</Range semantics>.
+Constructs a range of C<0..^$limit> or locates a metaclass as a shortcut
+for C<$limit.HOW>.  See L</Range semantics>.
 =item *
 prefix:<=>, iterate iterator
-    =
+    =$iterator
 Unary C<=> reads lines from a filehandle or filename, or
 iterates an iterator, or in general causes a scalar to explode its guts
@@ -491,7 +545,9 @@
-    *
+    $x*$y
+Multiplication, resulting in wider type of the two.
 =item *
@@ -499,7 +555,8 @@
     $numerator / $denominator
-Converts both operands to C<Num> and does division returning C<Num>.
+If either operand is of C<Num> type,
+converts both operands to C<Num> and does division returning C<Num>.
 If the denominator is zero, returns either C<+Inf>, C<NaN>, or C<-Inf>
 as the numerator is positive, zero, or negative.  (This is construed
 as the best default in light of the operator's possible use within
@@ -507,6 +564,11 @@
 on an individual scalar division, you can always check the denominator
+If both operands are of integer type, you still get a C<Num>, but the
+C<Num> type is allowed to do the division lazily; internally it may
+store a C<Rat> until the time a value is called for.  If converted
+to C<Rat> directly no division ever need be done.
 =item *
 infix:<div>, generic division
@@ -529,7 +591,7 @@
 infix:<%>, modulus
-    %
+    $x % $mod
 Always floor semantics using C<Num> or C<Int>.
@@ -537,7 +599,7 @@
 infix:<mod>, generic modulus
-    mod
+    $x mod $mod
 Dispatches to the infix:<mod> multi most appropriate to the operand types.
@@ -553,7 +615,8 @@
 If the count is less than 1, returns the null string.
 The count may not be C<*> because Perl 6 does not support
-infinite strings.  (At least, not yet...)
+infinite strings.  (At least, not yet...)  Note, however, that an
+infinite string may be emulated with C<cat($string xx *)>.
 =item *
@@ -562,10 +625,10 @@
     @list xx $count
 Evaluates the left argument in list context, replicates the resulting
-Capture value the number of time specified by the right argument and
+C<Capture> value the number of time specified by the right argument and
 returns the result in a context dependent fashion.  If the operator
 is being evaluated in ordinary list context, the operator returns a
-flattened list.  In C<@@> context, the operator converts each Capture
+flattened list.  In slice (C<@@>) context, the operator converts each 
 to a separate sublist and returns the list of those sublists.
 If the count is less than 1, returns the empty list, C<()>.
@@ -576,7 +639,9 @@
 infix:{'+&'}, numeric bitwise and
-    +&
+    $x +& $y
+Converts both arguments to C<Int> and does a bitwise numeric AND.
 =item *

Reply via email to