Author: lwall
Date: 2009-11-20 08:10:40 +0100 (Fri, 20 Nov 2009)
New Revision: 29143

[S03] tweaks from TheDamian++
Various coercion clarifications

Modified: docs/Perl6/Spec/S03-operators.pod
--- docs/Perl6/Spec/S03-operators.pod   2009-11-20 06:12:28 UTC (rev 29142)
+++ docs/Perl6/Spec/S03-operators.pod   2009-11-20 07:10:40 UTC (rev 29143)
@@ -16,7 +16,7 @@
     Created: 8 Mar 2004
     Last Modified: 19 Nov 2009
-    Version: 176
+    Version: 177
 =head1 Overview
@@ -24,8 +24,8 @@
 =head1 Operator precedence
-Not counting terms and terminators, Perl 6 has 23 operator precedence
-levels (same as Perl 5, but differently arranged).  Here we list the
+Perl 6 has about the same number of precedence levels as Perl 5,
+but they're differently arranged in spots.  Here we list the
 levels from "tightest" to "loosest", along with a few examples of
 each level:
@@ -613,9 +613,10 @@
 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.)  For values that do not already do the
-C<Numeric> role, the narrowest appropriate type of C<Int>, C<Num>, or
+C<Numeric> role, the narrowest appropriate type of C<Int>, C<Rat>, C<Num>, or
 C<Complex> will be returned; however, string containing two integers
-separated by a C</> will be returned as a C<Rat>.  Exponential notation
+separated by a C</> will be returned as a C<Rat> (or a C<FatRat> if the
+denominator overflows an C<int64>).  Exponential notation
 and radix notations are recognized.
 =item *
@@ -750,22 +751,18 @@
 C<< infix:<%> >>, modulus
-    $x % $mod
+    $x % $y
-Coerces to C<Num> (or C<Int> as an optimization) before performing C<mod>.
-That is, has results equivalent to:
+If necessary, coerces non-numeric arguments to an appropriate C<Numeric> type,
+then calculates the modulus, which is defines as:
-    floor( Num($x) / Num($y) )
-Also preserves the identity:
     $x % $y == $x - floor($x / $y) * $y
 =item *
 C<< infix:<mod> >>, generic modulus
-    $x mod $mod
+    $x mod $y
 Dispatches to the C<< infix:<mod> >> multi most appropriate to
 the operand types, typically returning a value of the same type.
@@ -912,7 +909,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...)  Note, however, that an
-infinite string may be emulated with C<cat($string xx *)>.
+infinite string may someday be emulated with C<cat($string xx *)>,
+in which case C<$string x *> may be a shorthand for that.
 =item *
@@ -1020,22 +1018,17 @@
 C<< prefix:<int> >>
-Coerces to type C<Int>.  Floor semantics are used for fractional
-values, including strings that appear to express fractional values.
-That is, C<int($x)> must have the same result as C<int(+$x)> in all
-cases.  All implicit conversions to integer use the same semantics.
+Deprecated, use the C<Int()> coercion or the C<floor> function.
-(Note that, despite the fact that C<int> is a valid native type
-name, this function does not express conversion to that native type.
-Such subtype conversions are done automatically upon assignment to
-a subtyped container, and fail if the container cannot hold the value.)
 =item *
 C<< prefix:<sleep> >>
-Suspends the current thread of execution for the specified number of seconds,
-which may be fractional.
+Coerces to an appropriate C<Real> type, then suspends the current
+thread of execution for the specified number of seconds, which
+may be fractional.  Remember that although a C<Rat> is capable
+of attosecond precision, your computer is probably not capable of
+attosecond accuracy.
 =item *
@@ -1367,7 +1360,7 @@
 the appearance of being parsed as trailing unary operators at a
 pseudo-precedence level slightly tighter than item assignment.
 (They're not officially "postfix" operators
-because those require the absense of whitespace, and these allow whitespace.
+because those require the absence of whitespace, and these allow whitespace.
 These adverbs insert themselves in the spot where the parser is
 expecting an infix operator, but the parser continues to look for
 an infix after parsing the adverb and applying it to the previous
@@ -1559,6 +1552,10 @@
 explicitly if there is an explicit signature, or pull them out of C<%_>
 rather than C<@_> if there is no explicit signature.
+[It's likely this operator will be removed from the core Perl 6 language
+and only supplied by the translator as a macro, so don't write any new
+code with it.]
 =item *
 C<< infix:<:> >>, the invocant marker
@@ -3192,7 +3189,8 @@
 Since use of C<Range> objects in item context is usually
 non-sensical, a C<Range> object used as an operand for scalar operators
 will generally attempt to distribute the operator to its endpoints and
-return another suitably modified C<Range> instead, much like a junction of two 
items.  (Notable exceptions
+return another suitably modified C<Range> instead, much like a junction of two 
+only with proper interval semantics.  (Notable exceptions to this autothreading
 include C<< infix:<~~> >>, which does smart matching, and C<< prefix:<+> >>
 which returns the length of the range.)  Therefore if you wish to
 write a slice using a length instead of an endpoint, you can say
@@ -3270,7 +3268,7 @@
     Any       undef     undefined               not .defined
     Any       *         block signature match   block successfully binds to |$_
     Any       .foo      method truth            ?X       i.e. ?.foo
-    Any       .foo(...) method truth            ?X       i.e. ?.foo
+    Any       .foo(...) method truth            ?X       i.e. ?.foo(...)
     Any       .(...)    sub call truth          ?X       i.e. ?.(...)
     Any       .[...]    array value slice truth ?all(X)  i.e. ?all(.[...])
     Any       .{...}    hash value slice truth  ?all(X)  i.e. ?all(.{...})
@@ -4256,7 +4254,7 @@
 This is convenient for function application:
     1,1 ... &[+]           # fibonacci series
-    sort &[R<=>], @list    # reversed, numerically
+    sort &[Rleg], @list      # reverse sort as strings
 The C<&[op]> form always refers to a binary function of the operator,
 even if it is underlyingly defined as a variadic list-associative operator.
@@ -4264,7 +4262,7 @@
 There is no corresponding form for unary operators, but those may
 usually be constructed by applying an operator to C<*>:
-    sort +*, @list        # sort numerically
+    sort -*, @list        # sort reversed numerically
 =head1 Declarators
@@ -4438,6 +4436,7 @@
     my $args = \(@foo: @bar);
+    push |$args;
 is instead equivalent to:

Reply via email to