r29155 - docs/Perl6/Spec

[pugs-c...@feather.perl6.nl]

Author: lwall
Date: 2009-11-20 21:13:08 +0100 (Fri, 20 Nov 2009)
New Revision: 29155

Modified:
docs/Perl6/Spec/S03-operators.pod
Log:
[S03] destroy two low-powered, obscure, short-circuiting operators
in favor of one high-powered, obscure-but-transparent, S metaoperator

Modified: docs/Perl6/Spec/S03-operators.pod
===================================================================
--- docs/Perl6/Spec/S03-operators.pod 2009-11-20 17:56:13 UTC (rev 29154)
+++ docs/Perl6/Spec/S03-operators.pod 2009-11-20 20:13:08 UTC (rev 29155)
@@ -16,7 +16,7 @@
Created: 8 Mar 2004

Last Modified: 20 Nov 2009
- Version: 179
+ Version: 180

=head1 Overview

@@ -40,7 +40,7 @@
L Additive + - +| +^ ~| ~^ ?| ?^
L Replication x xx
X Concatenation ~
- X Junctive and & also
+ X Junctive and &
X Junctive or | ^
L Named unary sleep abs sin temp let
N Structural infix but does <=> leg cmp .. ..^ ^.. ^..^
@@ -953,17 +953,14 @@

$a & $b & $c ...

-=item *
-
-C<< infix:<also> >>, short-circuit junctional and operator
-
- EXPR also EXPR also EXPR ...
-
-Can be used to construct ANDed patterns with the same semantics as
-C<< infix:<&> >>, but with left-to-right evaluation guaranteed, for use
+By default junctions are allowed to reorder the comparisons in any
+order that makes sense to the optimizer. To suppress this, use
+the C<S> metaoperator for force sequential evaluation, which will
+construct a list of ANDed patterns with the same semantics as C<<
+infix:<&> >>, but with left-to-right evaluation guaranteed, for use
in guarded patterns:

- $target ~~ MyType also *.mytest1 also *.mytest2
+ $target ~~ MyType S& *.mytest1 S& *.mytest2

This is useful when later tests might throw exceptions if earlier
tests don't pass. This cannot be guaranteed by:
@@ -984,21 +981,20 @@

=item *

-C<< infix:<else> >>, short-circuit junctional or operator
-
- EXPR else EXPR else EXPR ...
-
-Can be used to construct ORed patterns with the same semantics as
-C<< infix:<|> >>, but with left-to-right evaluation guaranteed, for use
-in guarded patterns where the left argument is much more easily
+By default junctions are allowed to reorder the comparisons in
+any order that makes sense to the optimizer. To suppress this,
+use the C<S> metaoperator for force sequential evaluation, which
+will construct a list of ORed patterns with the same semantics as
+C<< infix:<|> >>, but with left-to-right evaluation guaranteed, for
+use in guarded patterns where the left argument is much more easily
falsifiable than the right:

- $target ~~ *.mycheaptest else *.myexpensivetest
+ $target ~~ *.mycheaptest S| *.myexpensivetest

This is also useful when you want to perform tests in order
of safety:

- $target ~~ MyType else *.mysafetest else *.mydangeroustest
+ $target ~~ MyType S| *.mysafetest S| *.mydangeroustest

=item *

@@ -1006,6 +1002,9 @@

$a ^ $b ^ $c ...

+The C<S^> variant guarantees left-to-right evaluation, and in boolean
+context short-circuits to false if it sees a second match.
+
=back

=head2 Named unary precedence
@@ -3640,7 +3639,7 @@
operators yourself. Similarly, the carets that exclude the endpoints
on ranges are there by convention only.

-In contrast to that, Perl 6 has six standard metaoperators for
+In contrast to that, Perl 6 has seven standard metaoperators for
turning a given existing operator into a related operator that is
more powerful (or at least differently powerful). These differ from a
mere naming convention in that Perl automatically generates these new
@@ -4252,6 +4251,35 @@

Multidimensional lists should be handled properly.

+=head2 Sequential operators
+
+The sequence metaoperator, C<S>, may be followed by any non-fiddly infix operator.
+It suppresses any explicit or implicit parallelism, and prevents the optimizer
+from reordering the operand evaluations. The 'S' can be thought of as standing
+for Sequential, Serial, Synchronous, Short-circuit, Single-thread, and Safe.
+Among other things. In particular, we can have:
+
+ a S& b S& c short-circuited AND junction
+ a S| b S| c short-circuited OR junction
+ a S^ b S^ c short-circuited XOR junction
+ a S»op« b single-threaded hyperop
+ a SX* b single-threaded X*
+ a SX[*] b single-threaded X*
+ a S[X*] b single-threaded X*
+ a S+ b suppress arg reordering by ignorant optimizer
+
+This metaoperator has the same precedence and associativity as its base operator.
+The compiler is free to discard any C<S> metaoperator that is provably redundant,
+such as the one in C<S||>. The compiler is free to intuit an C<S> on any
+operator involving known volatile operands where that does not otherwise
+change the semantics of the operator.
+
+Conjectural: since metaoperators are notionally applied from inside to outside,
+serializing a reversed operator depends on the order of the metaoperators:
+
+ a SR/ b evaluates b, then a, then does b/a
+ a RS/ b evaluates a, then b, then does b/a
+
=head2 Nesting of metaoperators

Any ordinary infix operator may be enclosed in square brackets