Author: larry
Date: Sat Jun 2 14:45:43 2007
New Revision: 14414
Modified:
doc/trunk/design/syn/S03.pod
Log:
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 *
+Heredoc
+
+ qq:to/END/
+ Dear $recipient:
+ Thanks!
+ Sincerely,
+ $me
+ END
+
+=item *
+
Array composer
[1,2,3]
+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 *
Closure
- {...}
+ { ... }
+
+When found where a statement is expected, executes immediately. Othewise
+always defers evaluation of the inside scope.
=item *
@@ -119,6 +138,8 @@
\(@a,$b,%c)
+An abstraction representing an argument list that doesn't yet know its context.
+
=item *
Sigiled variables
@@ -128,7 +149,7 @@
%z
$^a
$?FILE
- @@multidim
+ @@slice
&func
&div:(Int, Int --> Int)
@@ -247,6 +268,9 @@
$obj.::Class::meth
$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)
=back
@@ -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
+ [EMAIL PROTECTED]
+ \%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 @@
infix:<*>
- *
+ $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
yourself.)
+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
C<Capture>
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 *
