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

Author: audreyt
Date: Sun Jul 23 10:24:56 2006
New Revision: 10381

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

Log:
* S03: Apply Agent Zhang's patch as well as some more typo fixes.

Modified: doc/trunk/design/syn/S03.pod
==============================================================================
--- doc/trunk/design/syn/S03.pod	(original)
+++ doc/trunk/design/syn/S03.pod	Sun Jul 23 10:24:56 2006
@@ -170,7 +170,7 @@
     SIMPLE OP
     SIMPLE OP SIMPLE
 
-where C<OP> is includes any standard scalar operators in the five
+where C<OP> includes any standard scalar operators in the five
 precedence levels autoincrement, exponentiation, symbolic unary,
 multiplicative, and additive; but these are limited to standard
 operators that are known to return numbers, strings, or booleans.
@@ -383,7 +383,7 @@
 Two values are never equivalent unless they are of exactly the same type.  By
 contrast, C<eq> always coerces to string, while C<==> always coerces to
 numeric.  In fact, C<$a eq $b> really means "C<~$a === ~$b>" and C<$a == $b>
-means "C<+$a === +$b>.
+means C<+$a === +$b>.
 
 Note also that, while string hashes use C<eq> semantics by default,
 object hashes use C<===> semantics.
@@ -442,8 +442,9 @@
 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.)
+=item * "Unary" C<.> calls its single argument (which must be 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
@@ -475,7 +476,7 @@
 supports the C<Ordered> role.
 
     0..*	# 0 .. +Inf
-    'a'..*	# 'a' .. 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzz...
+    'a'..*	# 'a' .. 'zzzzzzzzzzzzzzzzzzzzzzzzzzzzz...'
     *..0	# -Inf .. 0
     *..*	# "-Inf .. +Inf", really Ordered
     1.2.3..*	# Any version higher than 1.2.3.
@@ -569,7 +570,7 @@
     Any     .method   method truth*            match if $_.method
     Any     Regex     pattern match            match if $_ ~~ /$x/
     Any     subst     substitution match*      match if $_ ~~ subst
-    Any     boolean   simple expression truth* match if true given $_
+    Any     boolean   simple expression truth* match if $x.true given $_
     Any     undef     undefined                match unless defined $_
     Any     Whatever  default                  match anything
     Any     Any       run-time dispatch        match if infix:<~~>($_, $x)
@@ -894,7 +895,7 @@
 
     [[;] 1,2,3]   # equivalent to [1;2;3]
 
-Builtin reduce operators return the following identity operations:
+Builtin reduce operators return the following identity values:
 
     [**]()      # 1     (arguably nonsensical)
     [*]()       # 1
@@ -933,11 +934,11 @@
     [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::False   (also for 1 arg)
     [===]()     # Bool::True    (also for 1 arg)
-    [!===]()    # Bool::False    (also for 1 arg)
+    [!===]()    # Bool::False   (also for 1 arg)
     [eqv]()     # Bool::True    (also for 1 arg)
-    [!eqv]()    # Bool::False    (also for 1 arg)
+    [!eqv]()    # Bool::False   (also for 1 arg)
     [&&]()      # Bool::True
     [||]()      # Bool::False
     [^^]()      # Bool::False
@@ -1079,8 +1080,8 @@
     my $y := $x;
     $y = 'Perl Hacker';
 
-After this, both C<$x> and C<$y> contain the string "Perl Hacker," since
-they are really just two different names for the same variable.
+After this, both C<$x> and C<$y> contain the string C<"Perl Hacker">,
+since they are really just two different names for the same variable.
 
 There is another variant, spelled C<::=>, that does the same thing at
 compile time.
@@ -1131,7 +1132,7 @@
     my :($b, $c);		# okay
     sub foo :($a,$b) {...}	# okay
 
-The C<< -> >> "pointy sub" token also introduces a signature, but
+The C<< -> >> "pointy block" token also introduces a signature, but
 in this case you must omit both the colon and the parens.  For instance,
 if you're defining the "loop variable" of a loop block:
 
@@ -1184,7 +1185,7 @@
 
 =head1 Argument List Interpolating
 
-Perl 5 forced interpolation of a functions argument list by use of
+Perl 5 forced interpolation of a function's argument list by use of
 the C<&> prefix.  That option is no longer available in Perl 6, so
 instead the C<[,]> reduction operator serves as an
 interpolator, by casting its operands to C<Capture> objects
@@ -1229,8 +1230,8 @@
     @$bar = 1,2,3;
     $bar[] = 1,2,3;
 
-Some lvalues can be rather lengthy, so that second form can help keep
-the "arrayness" of the lvalue close to the assignment operator:
+For long lvalue expressions, the second form can keep the "arrayness"
+of the lvalue close to the assignment operator:
 
     $foo.bar.baz.bletch.whatever.attr[] = 1,2,3;
 
@@ -1243,8 +1244,8 @@
 The empty C<[]> and C<.[]> postfix operators are interpreted as
 zero-dimensional slices returning the entire array, not null slices
 returning no elements.  Likewise for C<{}> and C<.{}> on hashes,
-not to mention the C<< <> >>, C<< .<> >>, C<«»>, and C<.«»>
-constant and interpolating slice subscripting forms.
+as well as the C<< <> >>, C<< .<> >>, C<«»>, and C<.«»> constant and
+interpolating slice subscripting forms.
 
 The C<[,]> operator interpolates lazily for C<Array> and C<Range> objects.
 To get an immediate interpolation like Perl 5 does, add the C<eager> list
@@ -1255,7 +1256,7 @@
 
 To interpolate a function's return value, you must say:
 
-    push [,] func()
+    push [,] func();
 
 Within the argument list of a C<[,]>, function return values are
 automatically exploded into their various parts, as if you'd said:
@@ -1346,7 +1347,7 @@
         print "Name: $name;   Zip code: $zip\n";
     }
 
-C<zip> has an infix synonym, the Unicode operator C<¥>, and its the ASCII
+C<zip> has an infix synonym, the Unicode operator C<¥>, and its ASCII
 equivalent C<Y>.
 
 To read arrays in parallel like C<zip> but just sequence the values

• [svn:perl6-synopsis] r10381 - doc/trunk/design/syn by audreyt