[svn:perl6-synopsis] r10217 - doc/trunk/design/syn

Author: larry
Date: Sat Jul 15 00:15:51 2006
New Revision: 10217

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

Log:
More clarifications, many suggested by dduncan++.


Modified: doc/trunk/design/syn/S03.pod
==============================================================================
--- doc/trunk/design/syn/S03.pod	(original)
+++ doc/trunk/design/syn/S03.pod	Sat Jul 15 00:15:51 2006
@@ -12,9 +12,9 @@
 
   Maintainer: Larry Wall <larry@wall.org>
   Date: 8 Mar 2004
-  Last Modified: 14 Jul 2006
+  Last Modified: 15 Jul 2006
   Number: 3
-  Version: 47
+  Version: 48
 
 =head1 Changes to existing operators
 
@@ -29,7 +29,8 @@
 =item * C<< -> >> becomes C<.>, like the rest of the world uses.
 
 =item * The string concatenation C<.> becomes C<~>.  Think of it as
-"stitching" the two ends of its arguments together.
+"stitching" the two ends of its arguments together.  String append
+is likewise C<~=>.
 
 =item * All postfix operators that do not start with a dot also have
 an alternate form that does.  (The converse does not hold--just because
@@ -50,17 +51,31 @@
 so you need C<$($foo[bar])> to mean the other way.
 
 =item * Bitwise operators get a data type prefix: C<+>, C<~>, or C<?>.
-For example, C<|> becomes either C<+|> or C<~|> or C<?|>, depending on
-whether the operands are to be treated as numbers, strings, or boolean
-values.  Left shift C< << > becomes C< +< >, and correspondingly with
-right shift. Unary C<~> becomes either C<+^> or C<~^> or C<?^>, since a
-bitwise NOT is like an exclusive-or against solid ones.  Note that C<?^>
-is functionally identical to C<!>.  C<?|> differs from C<||> in that
-C<?|> always returns a standard boolean value (either 1 or 0), whereas
-C<||> return the actual value of the first of its arguments that is
-true.  Bitwise string operators may only be applied to C<Buf> types or
-similar compact integer arrays, and treat the entire chunk of memory
-as a single huge integer.
+For example, Perl 5's C<|> becomes either C<+|> or C<~|> or C<?|>,
+depending on whether the operands are to be treated as numbers,
+strings, or boolean values.  Perl 5's left shift C< << > becomes
+C< +< >, and correspondingly with right shift. Perl 5's unary C<~>
+(one's complement) becomes either C<+^> or C<~^> or C<?^>, since a
+bitwise NOT is like an exclusive-or against solid ones.  Note that
+C<?^> is functionally identical to C<!>, but conceptually coerces to
+boolean first and then flips the bit.  Please use C<!> instead.
+
+C<?|> is a logical OR but differs from C<||> in that C<?|> always
+evaluates both sides and returns a standard boolean value.  That is,
+it's equivalent to C<< ?$a + ?$b != 0 >>.  Another difference is that
+it has the precedence of an additive operator.
+
+C<?&> is a logical AND but differs from C<&&> in that C<?&> always
+evaluates both sides and returns a standard boolean value.  That is,
+it's equivalent to C<< ?$a * ?$b != 0 >>.  Another difference is that
+it has the precedence of a multiplicative operator.
+
+Bitwise string operators (those starting with C<~>) may only be
+applied to C<Buf> types or similar compact integer arrays, and treat
+the entire chunk of memory as a single huge integer.  They differ from
+the C<+> operators in that the C<+> operators would try to convert
+the string to a number first on the assumption that the string was an
+ASCII representation of a number.
 
 =item * C<x> splits into two operators: C<x> (which concatenates repetitions 
 of a string to produce a single string), and C<xx> (which creates a list of 
@@ -108,7 +123,7 @@
 
     ($a,$b,$c) = 1,2,3;
 
-since list assignment operators are of assignment precedence to their left.
+since assignment operators are tighter than comma to their left.
 
 =item * The scalar assignment operator still parses as it did before, so
 
@@ -379,7 +394,8 @@
 in terms of C<cmp>, so C<$a leg $b> is now defined as C<~$a cmp ~$b>.
 The sort operator still defaults to C<cmp> rather than C<leg>.  The
 C<< <=> >> operator's semantics are unchanged except that it returns
-an C<Order> value as described above.
+an C<Order> value as described above.  In other words, C<< $a <=> $b >>
+is now equivalent to C<+$a cmp +$b>.
 
 =item * Binary C<< => >> is no longer just a "fancy comma".  It now
 constructs a C<Pair> object that can, among other things, be used to
@@ -393,8 +409,9 @@
 is much more general now.  See "Smart matching" below for details.  (To catch
 "brainos", the Perl 6 parser defines an C<< infix:<=~> >> macro which always
 fails at compile time with a message directing the user either to use C<~~>
-or C<~=> instead, or to put a space between if they really wanted to assign
-a stringified value.)
+or C<~=> (string append) instead, or to put a space between if they
+really wanted to assign a stringified value.)  A negated smart match is
+spelled C<!~~>.
 
 =item * "Unary" C<.> calls its single argument (which must a postfix operator)
 on C<$_>.  (It's not really a unary operator, so we put it in quotes.)
@@ -582,11 +599,22 @@
 =head1 Meta operators
 
 Perl 6's operators have been greatly regularized, for instance, by
-consistently prefixing bitwise, stringwise, and boolean operators
-with C<+>, C<~> and C<?> respectively to indicate operator type.
-But that's just naming conventions.  In addition to those naming
-conventions, Perl 6 has four standard metaoperators for turning a
-given standard operator into a related but more powerful operator.
+consistently prefixing numeric, stringwise, and boolean operators
+with C<+>, C<~> and C<?> respectively to indicate whether the bitwise
+operation is done on a number, a string, or a single bit.
+But that's just a naming convention, and if you wanted to add a new
+bitwise C<¬> operator, you'd have the add the C<+¬>, C<~¬>, and C<?¬>
+operators yourself.  Similarly, the carets that exclude the endpoints
+on ranges are there by convention only.
+
+In contrast to that, Perl 6 has four 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
+metaoperators from user-defined operators as well as from builtins.
+In fact, you're not generally supposed to define the individual
+metaoperations--their semantics are supposed to be self-evident by
+the transformation of the base operator.
 
 Note: spaces are never allowed between any metaoperator and the
 operator it's modifying, because all operators including modified
@@ -608,19 +636,23 @@
 
 Existing forms ending in C<=> may not be modified with this metaoperator.
 
+Regardless of the precedence of the base operator, the precedence
+of any assignment operators is forced to be the same as that of
+ordinary assignment.
+
 =head2 Negated relational operators.
 
 Any infix relational operator may be transformed into its negative
-by prefixing with C<!>.  A few of these have traditional shortcuts:
+by prefixing with C<!>.  A couple of these have traditional shortcuts:
 
     Full form	Shortcut
     ---------	--------
     !==		!=
     !eq		ne
-    !~~		!~
 
 but most of them do not:
 
+    !~~
     !<
     !>=
     !ge
@@ -631,8 +663,7 @@
 To avoid visual confusion with the C<!!> operator, you may not modify
 any operator already beginning with C<!>.
 
-[Conjecture: we could probably do away with C<!~>, but probably not
-C<!=> or C<ne>.]
+The precedence of any negated operator is the same as the base operator.
 
 =head2 Hyper operators
 
@@ -644,6 +675,8 @@
 blunt end (except for postfix operators, which must still follow postfix
 spacing rules, but do allow for an additional dot before the "hyper").
 
+The precedence of any hyperoperator is the same as its base operator.
+This means that you must parenthesize your lists for most operators.
 For example:
 
      (1,1,2,3,5) »+« (1,2,3,5,8);  # (2,3,5,8,13)
@@ -748,7 +781,8 @@
 As with the all metaoperators, space is not allowed inside.  The whole
 thing parses as a single token.
 
-A reduction operator really is a list operator, and is invoked as one.
+A reduction operator has the same precedence as a list operator.  In fact,
+a reduction operator really is a list operator, and is invoked as one.
 Hence, you can implement a reduction operator in one of two ways.  Either
 you can write an explicit list operator:
 
@@ -855,22 +889,26 @@
     [&]()       # all()
     [|]()       # any()
     [^]()       # one()
-    [!=]()      # Bool::False   (also for 1 arg)
+    [!==]()     # Bool::False   (also for 1 arg)
     [==]()      # Bool::True    (also for 1 arg)
     [<]()       # Bool::True    (also for 1 arg)
     [<=]()      # Bool::True    (also for 1 arg)
     [>]()       # Bool::True    (also for 1 arg)
     [>=]()      # Bool::True    (also for 1 arg)
     [~~]()      # Bool::True    (also for 1 arg)
-    [!~]()      # Bool::False   (also for 1 arg)
+    [!~~]()     # Bool::False   (also for 1 arg)
     [eq]()      # Bool::True    (also for 1 arg)
-    [ne]()      # Bool::False   (also for 1 arg)
+    [!eq]()     # Bool::False   (also for 1 arg)
     [lt]()      # Bool::True    (also for 1 arg)
     [le]()      # Bool::True    (also for 1 arg)
     [gt]()      # Bool::True    (also for 1 arg)
     [ge]()      # Bool::True    (also for 1 arg)
     [=:=]()     # Bool::True    (also for 1 arg)
+    [!=:=]()    # Bool::False    (also for 1 arg)
     [===]()     # Bool::True    (also for 1 arg)
+    [!===]()    # Bool::False    (also for 1 arg)
+    [eqv]()     # Bool::True    (also for 1 arg)
+    [!eqv]()    # Bool::False    (also for 1 arg)
     [&&]()      # Bool::True
     [||]()      # Bool::False
     [^^]()      # Bool::False
@@ -971,6 +1009,22 @@
 it indicates to the compiler that there is no coupling between loop
 iterations and they can be run in any order or even in parallel.
 
+Use of negative operators with syntactically recognizable junctions may
+produce a warning on code that works differently in English than in Perl.
+Instead of writing
+
+    if $a != 1 | 2 | 3 {...}
+
+you need to write
+
+    if not $a == 1 | 2 | 3 {...}
+
+However, this is only a syntactic warning, and
+
+    if $a != $b {...}
+
+will not complain if $b happens to contain a junction at runtime.
+
 =head1 Chained comparisons
 
 Perl 6 supports the natural extension to the comparison operators,
@@ -1194,22 +1248,24 @@
     my \$capture := func();
     push [,] =$capture;
 
-=head1 Piping operators
+=head1 Feed operators
 
 The new operators C<< ==> >> and C<< <== >> are akin to UNIX pipes, but
-work with functions that accept and return lists.  For example,
+work with functions that accept and return lists.  Since these lists are
+composed of discrete objects and not liquids, we call these I<feed> operators
+rather than pipes.  For example,
 
      @result = map { floor($^x / 2) },
                  grep { /^ \d+ $/ },
                    @data;
 
-can also now be written:
+can also now be written with rightward feeds as:
 
      @data ==> grep { /^ \d+ $/ }
            ==> map { floor($^x / 2) }
            ==> @result;
 
-or:
+or with leftward feeds as:
 
      @result <== map { floor($^x / 2) }
              <== grep { /^ \d+ $/ }
@@ -1320,28 +1376,46 @@
 
 Perl 6 has 22 precedence levels (which is fewer than Perl 5):
 
-    terms               42 3.14 "eek" $x /abc/ (1+2) a(1) :by(2) .meth listop
-    method postfix      . .+ .? .* .() .[] .{} .<> .«» .:: .=
+    terms               42 3.14 "eek" qq["foo"] [1,2,3] {...} \(@a,$b,%c)
+			    $x @y %z /abc/ MyType @@multidim $^a
+			    (1+2) a(1) :by(2) :!verbose :(Dog $self:)
+			    .meth with implicit invocant
+			    listops leftward
+    method postfix      .meth .+ .? .* .() .[] .{} .<> .«» .:: .= .^
     autoincrement       ++ --
     exponentiation      **
     symbolic unary      ! + - ~ ? $ @ % & +^ ~^ ?^ \ ^ =
-    multiplicative      * / % x xx +& +< +> ~& ~< ~>
-    additive            + - ~ +| +^ ~| ~^
+    multiplicative      * / % x xx +& +< +> ~& ~< ~> ?&
+    additive            + - ~ +| +^ ~| ~^ ?| ?^
     junctive and (all)  &
     junctive or (any)   | ^
     named unary         rand sleep abs etc. -e -r -w -x etc.
-    nonchaining binary  but does cmp <=> .. ^.. ..^ ^..^ ff ^ff ff^ ^ff^ fff ^fff etc.
-    chaining binary     != == < <= > >= ~~ !~ eq ne lt le gt ge =:= ===
+    nonchaining binary  but does <=> leg cmp
+			    .. ^.. ..^ ^..^
+			    ff ^ff ff^ ^ff^
+			    fff ^fff fff^ ^fff^
+    chaining binary     != == < <= > >=
+			    eq ne lt le gt ge
+			    ~~ =:= === eqv
+			    !== !~~ !eq !=:= !=== !eqv etc.
     tight and           &&
     tight or            || ^^ //
     ternary             ?? !!
-    assignment          => := ::= += -= **= xx= .= etc. (also = with simple lvalues)
+    assignment          := ::= =>
+			    (also = with simple lvalues)
+			    += -= **= xx= .= etc.
     loose unary         true not
-    list ops            , print push any all '...' etc. (also list assignment)
+    list ops            , print push say join split substr open etc.
+			    any all one none
+			    die fail warn
+			    !!! ...  ???
+			    [+] [*] [<] [,] [\+] [\*] etc.
+			    (also = as list assignment)
     list infix          ¥ <== ==>
     loose and           and
     loose or            or xor err
     expr terminator     ; {} as control block, statement modifiers
+			    unmatched ), ], }, etc.
 
 Comma is the only listop that is allowed to occur where an operator is
 expected.  All other listops function as a term within the list to the left.

• [svn:perl6-synopsis] r10217 - doc/trunk/design/syn by larry