remove space between sub/method names and opening paren

Author: tbrowder

doc/Language/5to6-nutshell.pod

@@ -97,7 +97,7 @@ designed to be more concise in concepts than in keystrokes.
 
 As a result, there are various places in the syntax where whitespace is
 optional in Perl 5, but is either mandatory or forbidden in Perl 6. Many of
-those restrictions are unlikely to concern much real-life Perl code (e.g.
+those restrictions are unlikely to concern much real-life Perl code (e.g.,
 whitespace being disallowed between the sigil and name of a variable), but
 there are a few that will unfortunately conflict with some Perl hackers'
 habitual coding styles:
@@ -602,15 +602,15 @@ expect Pairs. However, this requires you to change all sub calls at once.
     # Note: no curly braces in this sub call
     get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 );
     # Perl 6, original API
-    sub get_the_loot ( $loot, *%options ) { # The * means to slurp everything
+    sub get_the_loot( $loot, *%options ) { # The * means to slurp everything
         ...
     }
     get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 ); # Note: no curly braces in this API
 
     # Perl 6, API changed to specify valid options
     # The colon before the sigils means to expect a Pair,
     # with the key having the same name as the variable.
-    sub get_the_loot ( $loot, :$quiet_level?, :$quantity = 1 ) {
+    sub get_the_loot( $loot, :$quiet_level?, :$quantity = 1 ) {
         # This version will check for unexpected arguments!
         ...
     }
@@ -1117,7 +1117,7 @@ Switch parsing is now done by the parameter list of the C<MAIN> subroutine.
     5
 
     # Perl 6
-        sub MAIN ( Int :$xyz ) {
+        sub MAIN( Int :$xyz ) {
             say $xyz if $xyz.defined;
         }
     perl6 example.p6 --xyz=5
@@ -1436,7 +1436,7 @@ Switch parsing is now done by the parameter list of the C<MAIN> subroutine.
         Died at c.pl line 3.
 
     # Perl 6
-        sub MAIN ( Int :$length = 24, :file($data) = 'file.dat', Bool :$verbose ) {
+        sub MAIN( Int :$length = 24, :file($data) = 'file.dat', Bool :$verbose ) {
             say $length if $length.defined;
             say $data   if $data.defined;
             say 'Verbosity ', ($verbose ?? 'on' !! 'off');

doc/Language/5to6-perlfunc.pod

@@ -1453,11 +1453,11 @@ C<study> is no more.
 
 =item sub NAME BLOCK
 
-=item sub NAME (PROTO) BLOCK
+=item sub NAME(PROTO) BLOCK
 
 =item sub NAME : ATTRS BLOCK
 
-=item sub NAME (PROTO) : ATTRS BLOCK
+=item sub NAME(PROTO) : ATTRS BLOCK
 
 Unsurprisingly, we still have subroutines! You can have a signature in
 your subroutine which allows you to specify arguments. Nevertheless, in

doc/Language/faq.pod

@@ -153,7 +153,7 @@ Example:
 
     say 1/0 # Attempt to divide 1 by zero using div
 
-    sub foo ( Int $a, Int $b ) {...}
+    sub foo( Int $a, Int $b ) {...}
     foo(1) # ===SORRY!=== Error while compiling ...
 
 =head2 What is C<(Any)>?

doc/Language/functions.pod

@@ -43,15 +43,15 @@ C<sub foo {...}> is the same as C<my sub foo {...}> and is only
 defined within the current scope.
 
 =begin code :allow<L>
-sub escape ($str) {
+sub escape($str) {
     # Puts a slash before non-alphanumeric characters
     S:g[<-alpha -digit>] = "\\$/" given $str
 }
 
 say escape 'foo#bar?'; # foo\#bar\?
 
 {
-    sub escape ($str) {
+    sub escape($str) {
         # Writes each non-alphanumeric character in its hexadecimal escape
         S:g[<-alpha -digit>] = "\\x[{ $/.ord.base(16) }]" given $str
     }
@@ -259,12 +259,12 @@ be broken out element-by-element using a **@ slurpy, with two nuances:
 
 This can be achieved by using a slurpy with a C<+> or C<+@> instead of C<**>:
 
-    sub grab (+@a) { "grab $_".say for @a }
+    sub grab(+@a) { "grab $_".say for @a }
 
 ...which is shorthand for something very close to:
 
-    multi sub grab (**@a) { "grab $_".say for @a }
-    multi sub grab (\a) {
+    multi sub grab(**@a) { "grab $_".say for @a }
+    multi sub grab(\a) {
         a ~~ Iterable and a.VAR !~~ Scalar ?? nextwith(|a) !! nextwith(a,)
     }
 
@@ -286,14 +286,15 @@ one sublist, or many:
 
 It is worth noting that mixing binding and sigilless variables
 in these cases requires a bit of finesse, because there is no Scalar
-intermediary used during binding.
+intermediary used during binding. (Notice the space before the opening '('
+which is normally not a good practice.)
 
     my $a = (1, 2);  # Normal assignment, equivalent to $(1, 2)
-    grab ($a);       # grab 1 2
+    grab($a);       # grab 1 2
     my $b := (1, 2); # Binding, $b links directly to a bare (1, 2)
-    grab ($b);       # grab 1 grab 2
+    grab($b);       # grab 1 grab 2
     my \c = (1, 2);  # Sigilless variables always bind, even with '='
-    grab (c);        # grab 1 grab 2
+    grab(c);        # grab 1 grab 2
 
 =head1 Functions are First-Class Objects
 
@@ -313,7 +314,7 @@ Or you can reference an existing named function by using the C<&> in front of
 it.
 
 =begin code
-sub square ($x) { $x * $x };
+sub square($x) { $x * $x };
 
 # get hold of a reference to the function:
 my $func = &square
@@ -323,7 +324,7 @@ This is very useful for I<higher order functions>, that is, functions that
 take other functions as input. A simple one is L<map|/type/List#routine_map>,
 which applies a function to each input element:
 
-    sub square ($x) { $x * $x };
+    sub square($x) { $x * $x };
     my @squared = map &square,  1..5;
     say join ', ', @squared;        # 1, 4, 9, 16, 25
 
@@ -757,7 +758,7 @@ and its signature is the means by which command line arguments can be parsed.
 Multi methods are supported and a usage method is automatically generated and
 displayed if no command line arguments are provided.
 
-    sub MAIN ( Int :$length = 24,
+    sub MAIN( Int :$length = 24,
                :file($data) where { .IO.f // die "file not found in $*CWD" } = 'file.dat',
                Bool :$verbose )
     {

doc/Language/modules.pod

@@ -132,7 +132,7 @@ As with all traits, if applied to a routine, "is export" should appear after
 any argument list.
 
     =begin code
-    sub foo (Str $string) is export { ... }
+    sub foo(Str $string) is export { ... }
     =end code
 
 You can pass named parameters to C<is export> to group symbols for exporting

doc/Language/objects.pod

@@ -599,7 +599,7 @@ C<Automobile>, for things that you can drive.
     }
     class Automobile {
         has $.direction;
-        method steer ($!direction) { }
+        method steer($!direction) { }
     }
     class Taurus is Bull is Automobile { }
 
@@ -620,7 +620,7 @@ case, it may have been better to use roles:
     }
     role Steerable {
         has Real $.direction;
-        method steer (Real $d = 0) {
+        method steer(Real $d = 0) {
             $!direction += $d;
         }
     }
@@ -636,7 +636,7 @@ This check will save you and your customers a lot of headaches and you can
 simply define your class instead as:
 
     class Taurus does Bull-Like does Steerable {
-        method steer ($direction?) {
+        method steer($direction?) {
             self.Steerable::steer($direction?)
         }
     }
@@ -819,8 +819,8 @@ Mixins can happen at any time of your object's life.
     # A counter for Table of Contents
     role TOC-Counter {
         has Int @!counters is default(0);
-        method Str () { @!counters.join: '.' }
-        method inc ($level) {
+        method Str() { @!counters.join: '.' }
+        method inc($level) {
             @!counters[$level - 1]++;
             @!counters.splice($level);
             self

doc/Language/performance.pod

@@ -93,10 +93,10 @@ L<camelia|/glossary#camelia>.
 With multidispatch you can drop in new variants of routines "alongside" existing ones:
 
     # existing code generically matches a two arg foo call:
-    multi sub foo (Any $a, Any $b) { ... }
+    multi sub foo(Any $a, Any $b) { ... }
 
     # new variant takes over for a foo("quux", 42) call:
-    multi sub foo ("quux", Int $b) { ... }
+    multi sub foo("quux", Int $b) { ... }
 
 The call overhead of having multiple C<foo> definitions is generally insignificant (though see discussion
 of C<where> below), so if your new definition handles its particular case more quickly/leanly than the

doc/Language/subscripts.pod

@@ -630,7 +630,7 @@ separately like this:
     method AT-KEY     ($key) is rw { %!fields{normalize-key $key}        }
     method EXISTS-KEY ($key)       { %!fields{normalize-key $key}:exists }
     method DELETE-KEY ($key)       { %!fields{normalize-key $key}:delete }
-    method push (*@_) { #`[not shown, for brevity] }
+    method push(*@_) { #`[not shown, for brevity] }
 
     sub normalize-key ($key) { $key.subst(/\w+/, *.tc, :g) }
 
@@ -671,7 +671,7 @@ others as detailed below.
 
 =head3 method elems
 
-    multi method elems (::?CLASS:D:)
+    multi method elems(::?CLASS:D:)
 
 Expected to return a number indicating how many subscriptable elements
 there are in the object. May be called by users directly, and is also

doc/Language/traps.pod

@@ -177,7 +177,7 @@ last element of an array becomes:
 
 Quite often new users will happen to write something like:
 
-    sub foo (Array @a) { ... }
+    sub foo(Array @a) { ... }
 
 ...before they have gotten far enough in the documentation to realize that
 this is asking for an Array of Arrays.  To say that C<@a> should only accept

doc/Language/variables.pod

@@ -39,7 +39,7 @@ The default type can be set with C<is>.
             callsame
         }
 		
-        method finalize () {
+        method finalize() {
             $!final = True
         }
     }
@@ -592,7 +592,7 @@ be omitted.
 Please note that many operators come with implicit binding, what will lead to actions at a distance. Use C<.clone> or coercion to create a new container that can be bound to.
 
     my @a;
-    sub f () {
+    sub f() {
     	state $i;
     	$i++;
     	@a.push: "k$i" => $i # <-- .clone goes here