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

Author: larry
Date: Fri Apr 21 22:41:58 2006
New Revision: 8907

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

Log:
Lots of tweaks and clarifications, mostly stuff discussed but not yet codified.


Modified: doc/trunk/design/syn/S03.pod
==============================================================================
--- doc/trunk/design/syn/S03.pod	(original)
+++ doc/trunk/design/syn/S03.pod	Fri Apr 21 22:41:58 2006
@@ -12,14 +12,14 @@
 
   Maintainer: Larry Wall <larry@wall.org>
   Date: 8 Mar 2004
-  Last Modified: 7 Apr 2006
+  Last Modified: 21 Apr 2006
   Number: 3
-  Version: 18
+  Version: 19
 
-=head1 Operator renaming
+=head1 Changes to existing operators
 
 Several operators have been given new names to increase clarity and better
-Huffman-code the language:
+Huffman-code the language, while others have changed precedence.
 
 =over
 
@@ -28,10 +28,12 @@
 =item * The string concatenation C<.> becomes C<~>.  Think of it as
 "stitching" the two ends of its arguments together.
 
-=item * Unary C<~> now imposes a string context on its argument,
-and C<+> imposes a numeric context (as opposed to being a no-op
-in Perl 5).  Along the same lines, C<?> imposes a boolean context,
-and C<*> imposes a list context.
+=item * Unary C<~> now imposes a string context on its argument, and
+C<+> imposes a numeric context (as opposed to being a no-op in Perl 5).
+Along the same lines, C<?> imposes a boolean context, and C<*> imposes
+a list context.   Unary sigils impose the container context implied
+by their sigil.  As with Perl 5, however, C<$$foo[bar]> parses as
+C<$($foo)[bar]>, 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
@@ -42,13 +44,17 @@
 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.
+true.  Bitwise string operators may only be applied to Buf types or
+similar compact integer arrays, and treat the entire chunk of memory
+as a single huge integer.
 
 =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 
-repetitions of a list or scalar).
+repetitions of a list or scalar).  Conjecture: the C<xxx> "infix" operator
+takes no right argument and is equivalent to C<xx Inf>.
 
-=item * Trinary C<? :> becomes C<?? !!>.
+=item * Trinary C<? :> becomes C<?? !!>.  It is a syntax error to use an
+operator in the middle that binds looser in precedence, such as C<=>.
 
 =item * C<qw{ ... }> gets a synonym: C< < ... > >, and an interpolating
 variant, C<«...»>.
@@ -69,6 +75,29 @@
 either end to exclude either the beginning or ending.  There is
 also a corresponding C<fff> operator with Perl 5's C<...> semantics.
 
+=item * All comparison operators are unified at the same precedence level.
+See Chained Comparisons below.
+
+=item * The list assignment operator now parses on the right like
+any other list operator, so you don't need parens on the right side of:
+
+    @foo = 1,2,3;
+
+You do still need them on the left for
+
+    ($a,$b,$c) = 1,2,3;
+
+since list assignment operators are of assignment precedence to their left.
+
+=item * The scalar assignment operator still parses as it did before, so
+
+    loop ($a = 1, $b = 2; ; $a++, $b++) {...}
+
+still works fine.  The distinction between scalar and list assignment
+is pretty much identical to the way Perl 5 does it.  If there are
+parens around the left side, or if the sigil of the variable is C<@>
+or C<%>, it's a list assignment.  Otherwise it's a scalar assignment.
+
 =back
 
 =head1 New operators
@@ -118,9 +147,8 @@
 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.)
 
-=item * "Unary" C<.> calls its single argument (which must be a method, or a
-dereferencer for a hash or array) on C<$_>.  (It's not really a unary operator,
-so we put it in quotes.)
+=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.)
 
 =item * The C<..> range operator has variants with C<^> on either
 end to indicate exclusion of that endpoint from the range.  It always
@@ -136,19 +164,30 @@
 as well.)
 
 Because C<Range> objects are lazy, they do not automatically generate
-a list.  So smart matching against a Range object smartmatches the
-endpoints in the domain of the object being matched, so C<< 1.5 ~~
-1^..^2 >> is true.  (But C<< 2.1 ~~ 1..2 >> is false.)
+a list.  So smart matching against a C<Range> object smartmatches the
+endpoints in the domain of the object being matched, so fractional
+numbers are C<not> truncated before comparison to integer ranges:
+
+    1.5 ~~ 1^..^2  # true, equivalent to 1 < 1.5 < 2
+    2.1 ~~ 1..2    # false, equivalent to 1 <= 2.1 <= 2
 
 =item * The unary C<^> operator generates a range from C<0> up to
-one less than its argument.  so C<^4> is short for C<0..^4> or C<0..3>.
+one less than its argument.  So C<^4> is short for C<0..^4> or C<0..3>.
 
     for ^4 { say $_ } # 0, 1, 2, 3
 
-=item * C<...> is a unary postfix operator that constructs a semi-infinite
-(and lazily evaluated) list, starting at the value of its single argument.
-It should not have any trailing whitespace, or it will be confused with
-a "long dot".
+If applied to a list, it generates a multidimensional set of subscripts.
+
+    for ^(3,3) { ... } # (0,0)(0,1)(0,2)(1,0)(1,1)(1,2)(2,0)(2,1)(2,2)
+
+If applied to a type name, it indicates the metaclass instance instead,
+so C<^Moose> is short for C<Moose.meta>.  It still kinda means "what
+is this thing's domain" in an abstract sort of way.
+
+=item * C<...> where an operator is expected is either a unary postfix
+or an infix operator that takes no right argument.  It constructs a
+semi-infinite (and lazily evaluated) list, starting at the value of
+its single argument.
 
 =item * However, C<...> where a term is expected is the "yada,
 yada, yada" prefix operator, which is used as the body in function
@@ -156,12 +195,14 @@
 ever executed.  Variant C<???> calls C<warn>, and C<!!!> calls C<die>.
 The argument is optional, but if provided, is passed onto the C<warn>,
 C<fail>, or C<die>.  Otherwise the system will make up a message for
-you based on the context.
+you based on the context.  We can't be responsible for what it might
+say.
 
-=item * In addition, to the ordinary C<.> method invocation, there are
-variants C<.*>, C<.?>, and C<.+> to control how multiple parent methods
+=item * In addition to the ordinary C<.> method invocation, there are
+variants C<.*>, C<.?>, and C<.+> to control how multiple related methods
 of the same name are handled.  The C<.=> operator does inplace modification
-of the object on the left.  The C<.^> operator calls a class metamethod.
+of the object on the left.  The C<.^> operator calls a class metamethod;
+C<foo.^bar> is short for C<foo.meta.bar>.
 
 =item * Unary C<=> reads lines from a filehandle or filename, or in general
 iterates an iterator.
@@ -183,7 +224,7 @@
 
      (3,8,2,9,3,8) >>-<< 1;          # (2,7,1,8,2,7)
 
-When using a unary operator, only put it on the operand's side:
+When using a unary operator, only put it on the side of the single operand:
 
      @negatives = -« @positives;
 
@@ -202,6 +243,12 @@
     [[1, 2], 3] »+« [4, [5, 6]]  #    [[1,2] »+« 4, 3 »+« [5, 6]]
                                  # == [[5, 6], [8, 9]]
 
+You are not allowed to define your own hyper operators, because they are
+supposed to have consistent semantics derivable entirely from the modified
+scalar operator.  If you're looking for a mathematical vector product, this
+isn't where you'll find it.  A hyperoperator is one of the ways that you
+can promise to the optimizer that your code is parallelizable.
+
 =head1 Reduction operators
 
 The other metaoperator in Perl 6 is the reduction operator.  Any
@@ -281,7 +328,7 @@
 take, so these kinds of operators overload the single-argument case
 to return something more meaningful.  All the comparison operators
 return a boolean for either 1 or 0 arguments.  Negated operators,
-return Bool::False, and all the rest return Bool::True.
+return C<Bool::False>, and all the rest return C<Bool::True>.
 
 This metaoperator can also be used on the semicolon second-dimension
 separator:
@@ -407,9 +454,11 @@
 Perl 6 supports the natural extension to the comparison operators,
 allowing multiple operands.
 
-     if 3 < $roll <= 6              { print "High roll" }
+    if 1 < $a < 100 { say "Good, you picked a number *between* 1 and 100." }
 
-     if 1 <= $roll1 == $roll2 <= 6  { print "Doubles!" }
+    if 3 < $roll <= 6              { print "High roll" }
+
+    if 1 <= $roll1 == $roll2 <= 6  { print "Doubles!" }
 
 Note: any operator beginning with C<< < >> must have whitespace
 in front of it, or it will be interpreted as a hash subscript instead.
@@ -435,6 +484,79 @@
 are bound to the same underlying variable.  C<$x =:= $y> would return
 true in the above example.
 
+The binding fails if the type of the variable being bound is sufficiently
+inconsistent with the type of the current declaration.
+
+=head1 Declarators
+
+The list of variable declarators has expanded from C<my> and C<our>
+to include:
+
+    my $foo		# ordinary lexically scoped variable
+    our $foo		# lexically scoped alias to package variable
+    has $foo		# object attribute
+    state $foo		# persistent lexical (cloned with closures)
+    constant $foo	# lexically scoped compile-time constant
+
+Variable declarators such as C<my> now take a C<Signature> as their
+argument.  The parentheses around the signature may be omitted for a
+simple declaration that declares a single variable, along with its
+associated type and traits.  Parentheses must always be used when
+declaring multiple parameters:
+
+    my $a;		# okay
+    my ($b, $c);	# okay
+    my $b, $c;		# wrong: "Use of undeclared variable: $c"
+
+The syntax for a C<Signature> when one isn't expected is:
+
+    :(Dog $a, *@c)
+
+The colon (and sometimes the parens) may be omitted within declarators
+where a signature is expected, for instance in the formal list of a loop
+block:
+
+    for @dogpound -> Dog $fido { ... }
+
+If a C<Signature> is assigned to (whether declared or colon form), the
+signature is converted to a list of lvalue variables and the ordinary
+rules of assignment apply, except that the evaluation of the right
+side and the assignment happens at time determined by the declarator.
+(With C<my> this is always when an ordinary assignment would happen.)
+If the signature is too complicated to convert to an assignment,
+a compile-time error occurs.  Assignment to a signature makes the
+same scalar/list distinction as ordinary assignment, so
+
+    my $a = foo();	# foo in scalar context
+    my ($a) = foo();	# foo in list context
+
+If a C<Signature> is bound to an argument list, then the binding of the
+arguments proceeds as if the C<Signature> were the formal parameters for
+a function, except that, unlike in a function call, the parameters
+are bound C<rw> by default rather than C<readonly>.  See Binding below.
+
+There are a number of other declarators that are not variable
+declarators.  These include both type declarators:
+
+    package Foo
+    module Foo
+    class Foo
+    role Foo
+    subset Foo
+
+and code declarators:
+
+    sub foo
+    method foo
+    submethod foo
+    multi foo
+    proto foo
+    regex foo
+    rule foo
+    token foo
+
+These all have their uses and are explained in subsequent synopses.
+
 =head1 Flattening
 
 Since typeglobs are being removed, unary C<*> may now serve as a
@@ -464,8 +586,8 @@
     $bar = @bar;
     push @foo, $bar;
 
-merely pushes a single Array object onto C<@foo>.  You can explicitly flatten
-it in any of these ways:
+merely pushes a single C<Array> object onto C<@foo>.  You can
+explicitly flatten it in any of these ways:
 
     push @foo, *$bar;
     push @foo, @$bar;
@@ -604,7 +726,7 @@
     ternary             ?? !!
     assignment          = := ::= += -= **= xx= etc. (and also =>)
     list item separator , ¥
-    list op (rightward) <== print push any all true not etc.
+    list op (rightward) <== print push any all true not etc. and ()= rightward
     pipe forward        ==>
     loose and           and
     loose or            or xor err

• [svn:perl6-synopsis] r8907 - doc/trunk/design/syn by larry
• Re: [svn:perl6-synopsis] r8907 - doc/trunk/design/syn by Daniel Hulme