use full word.

Author: coke

doc/Language/5to6-nutshell.pod6

@@ -469,7 +469,7 @@ In Perl 6, the curly braces are changed to parentheses.
         say keys %($hashref   );
         say      &($subref    );
 
-Note that in both Perl 5 and Perl 6, the surrounding curly braces or parens can
+Note that in both Perl 5 and Perl 6, the surrounding curly braces or parentheses can
 often be omitted, though the omission can reduce readability.
 
 In Perl 5, the arrow operator, C«->» , is used for single access to a
@@ -660,8 +660,8 @@ Mnemonic: x is short and xx is long, so xx is the one used for lists.
         @ones = (5) x @ones;        # Set all elements to 5
     # Perl 6
         print '-' x 80;             # Unchanged
-        @ones = 1 xx 80;            # Parens no longer needed
-        @ones = 5 xx @ones;         # Parens no longer needed
+        @ones = 1 xx 80;            # Parentheses no longer needed
+        @ones = 5 xx @ones;         # Parentheses no longer needed
 
 
 =head2 C<..> C<...> Two Dots or Three Dots, Range op or Flipflop op
@@ -687,7 +687,7 @@ In Perl 6, simply extend the curly braces to include the sigil too: C<"{$foo}s"
 
 =head3 C<if> C<elsif> C<else> C<unless>
 
-Mostly unchanged; parens around the conditions are now optional, but if
+Mostly unchanged; parentheses around the conditions are now optional, but if
 used, must not immediately follow the keyword, or it will be taken as a function
 call instead.  Binding the conditional expression to a variable is also a little different:
 
@@ -737,7 +737,7 @@ See also the warnings on the smart-match op above.
 
 =head3 C<while> C<until>
 
-Mostly unchanged; parens around the conditions are now optional, but if
+Mostly unchanged; parentheses around the conditions are now optional, but if
 used, must not immediately follow the keyword, or it will be taken as a function
 call instead.  Binding the conditional expression to a variable is also a little different:
 
@@ -786,18 +786,18 @@ Note first this common misunderstanding about the C<for> and C<foreach>
 keywords. Many programmers think that they distinguish between the C-style
 three-expression form and the list-iterator form; they do not! In fact,
 the keywords are interchangeable; the Perl 5 compiler looks for the
-semi-colons within the parens to determine which type of loop to parse.
+semi-colons within the parentheses to determine which type of loop to parse.
 
 The C-style three-factor form now uses the C<loop> keyword, and is
-otherwise unchanged. The parens *are* still required.
+otherwise unchanged. The parentheses *are* still required.
 
     for  ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 5
     loop ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 6
 
 
 The loop-iterator form of C<for> or C<foreach> is named C<for> in Perl 6.
 C<foreach> is no longer a keyword.
-Parens are optional.
+Parentheses are optional.
 
 The iteration variable, if any, has been moved from before the list, to
 after the list and an added arrow operator.

doc/Language/faq.pod6

@@ -184,7 +184,7 @@ languages.
 Example:
 
     my $foo
-    say $foo # (Any) note the parens indicate type object
+    say $foo # (Any) note the parentheses indicate type object
     say $foo.^name # Any
 
 (Any) shouldn't be used to check for definedness. In Perl 6, definedness is a

doc/Language/objects.pod6

@@ -49,7 +49,7 @@ say @words.L<join>: '--';
 # Abe--Lincoln--said--Fourscore--and--seven--years--ago
 
 Since you have to put a C<:> after the method if you want to pass arguments
-without parentheses, a method call without a colon or parens is
+without parentheses, a method call without a colon or parentheses is
 unambiguously a method call without an argument list:
 
     say 4.log:   ; # 1.38629436111989 ( natural logarithm of 4 )

doc/Language/operators.pod6

@@ -397,7 +397,7 @@ The X<grouping operator>.
 
 X<|(),empty list>
 An empty group C<()> creates an empty L<List> .
-Parens around non-empty expressions simply structure the expression, but
+Parentheses around non-empty expressions simply structure the expression, but
 not have additional semantics.
 
 In an argument list, putting parenthesis around an argument prevents it from
@@ -508,9 +508,9 @@ C<{ }> postcircumfix operator at compile-time.
 =head2 postcircumfix C«( )»
 
 The X<call operator>. Treats the invocant as a L<Callable> and invokes it,
-using the expression between the parens as arguments.
+using the expression between the parentheses as arguments.
 
-Note that an identifier followed by a pair of parens is always parsed as a
+Note that an identifier followed by a pair of parentheses is always parsed as a
 subroutine call.
 
 If you want your objects to respond to the call operator, you need to

doc/Language/packages.pod6

@@ -98,7 +98,7 @@ C<::($expr)> where you'd ordinarily put a package or variable name. The
 string is allowed to contain additional instances of C<::>, which will be
 interpreted as package nesting. You may only interpolate entire names,
 since the construct starts with C<::>, and either ends immediately or is
-continued with another C<::> outside the parens. Most symbolic references
+continued with another C<::> outside the parentheses. Most symbolic references
 are done with this notation:
 
     $foo = "Bar";

doc/Language/rb-nutshell.pod6

@@ -554,7 +554,7 @@ can be used instead of scalar values.
 
 =head3 C<while> C<until>
 
-Mostly unchanged; parens around the conditions are optional, but if used, must
+Mostly unchanged; parentheses around the conditions are optional, but if used, must
 not immediately follow the keyword, or it will be taken as a function call
 instead. Binding the conditional expression to a variable is also a little
 different:

doc/Language/subscripts.pod6

@@ -396,7 +396,7 @@ The return value and possible side-effect of a subscripting operation can be
 controlled using adverbs.
 
 Beware of the relatively loose precedence of operator adverbs, which may
-require you to add parens in compound expressions:
+require you to add parentheses in compound expressions:
 
     if $foo || %hash<key>:exists { ... }    # WRONG, tries to adverb the || op
     if $foo || (%hash<key>:exists) { ... }  # correct

doc/Language/terms.pod6

@@ -100,7 +100,7 @@ with the exception of C<< 'quoted string' => $value >>.
     «a b c»
     qw/a b c/
 
-L<List> literals are: the empty pair of parens C<()>, a comma-separated
+L<List> literals are: the empty pair of parentheses C<()>, a comma-separated
 list, or several quoting constructs.
 
 =head2 term *

doc/Language/variables.pod6

@@ -108,7 +108,7 @@ expression determines the type of assignment:
     say $num.perl;                   # 42 (a Num)
 
     my ( @foo, $bar );
-    @foo = ($bar) = 42, "str";       # list assignment: uses parens
+    @foo = ($bar) = 42, "str";       # list assignment: uses parentheses
     say @foo.perl;                   # [42, "str"] (an Array)
     say $bar.perl;                   # $(42, "str")  (a List)
 

doc/Type/Bag.pod6

@@ -65,7 +65,7 @@ the (cumulative) values become the associated integer weights:
 Furthermore, you can get a C<Bag> by using bag operators (see next section) on
 objects of other types such as L<List>, which will internally call C<.Bag>
 on them before performing the operation.  Be aware of the tight precedence of
-those operators though, which may require you to use parens around arguments:
+those operators though, which may require you to use parentheses around arguments:
 
     say (1..5) (+) 4;  # bag(1, 2, 3, 4(2), 5)