Space after commas

As per #624

Author: AlexDaniel

doc/Language/5to6-perlfunc.pod

@@ -1331,7 +1331,7 @@ method I. e. C<sort(@a)> is equivalent to C<@a.sort>.
 
 =item splice EXPR
 
-Available in Perl 6. Can also be used as a method. C<< splice(@foo, 2,3,
+Available in Perl 6. Can also be used as a method. C<< splice(@foo, 2, 3,
 <M N O P>); >> is equivalent to C<< @foo.splice(2, 3, <M N O P>); >>.
 
 =head2 split
@@ -1735,11 +1735,11 @@ a C<List> or C<Array> in a C<Scalar>, simply returning a list may be
 all that is needed:
 
     sub listofstuff {
-        return 1,2,3;
+        return 1, 2, 3;
     }
     my $a = listofstuff();
-    print $a;                     # prints "123"
-    print join("<",listofstuff()) # prints "1<2<3"
+    print $a;                      # prints "123"
+    print join("<", listofstuff()) # prints "1<2<3"
 
 One of the most common use cases is to provide either an array of lines
 or elements, or a prettier string than would be produced by simply
@@ -1751,8 +1751,8 @@ purpose:
             method Str { self.join("<") }
         }
     }
-    print prettylist(1,2,3);  # prints "1<2<3"
-    print join(">", prettylist(3,2,1)); # prints "3>2>1"
+    print prettylist(1, 2, 3);  # prints "1<2<3"
+    print join(">", prettylist(3, 2, 1)); # prints "3>2>1"
 
 In the above example, the returned list may be lazy, and the C<.Str> method
 is not called until stringification happens, so no extra work is done

doc/Language/5to6-perlvar.pod

@@ -132,10 +132,10 @@ $^z)>. Ergo:
 
 =begin code
 
-    sort { $^a cmp $^z }, 1,5,6,4,2,3;
-    # 1,2,3,4,5,6
-    sort { $^g cmp $^a }, 1,5,6,4,2,3;
-    # 6,5,4,3,2,1
+    sort { $^a cmp $^z }, 1, 5, 6, 4, 2, 3;
+    # (1 2 3 4 5 6)
+    sort { $^g cmp $^a }, 1, 5, 6, 4, 2, 3;
+    # (6 5 4 3 2 1)
     for 1..9 { say $^c, $^a, $^b; last }
     # 312
 

doc/Language/containers.pod

@@ -214,12 +214,12 @@ Note that, while supported, one should generally avoid directly binding
 uncontainerized things into array elements.  Doing so may produce
 counter-intuitive results when the array is used later.
 
-    my @a = (1,2,3);
+    my @a = (1, 2, 3);
     @a[0] := 42;         # This is not recommended, use assignment instead.
     my $b := 42;
     @a[1] := $b;         # Nor is this.
     @a[2] = $b;          # ...but this is fine.
-    @a[1,2] := 1,2;      # This is not allowed and will fail.
+    @a[1, 2] := 1, 2;    # This is not allowed and will fail.
 
 Operations that mix Lists and Arrays generally protect against such
 a thing happening accidentally.

doc/Language/control.pod

@@ -99,7 +99,7 @@ expression.  So:
 the expression it is contained in is evaluated:
 
     # This says "(..1 ..2 ..3)" not "(..1 ...2 ....3)"
-    my $f = "."; say do { $f ~= "." } X~ 1,2,3;
+    my $f = "."; say do { $f ~= "." } X~ 1, 2, 3;
 
 In other words, it follows the same reification rules as everything else.
 
@@ -350,9 +350,9 @@ assign them to an array:
 
 =begin code
 
-(for 1,2,3 { $_ * 2 }).say;             # says "(2 4 6)"
-my @a = do for 1,2,3 { $_ * 2 }; @a.say;# says "[2 4 6]"
-my @a = (for 1,2,3 { $_ * 2 }); @a.say; # same thing
+(for 1, 2, 3 { $_ * 2 }).say;              # says "(2 4 6)"
+my @a = do for 1, 2, 3 { $_ * 2 }; @a.say; # says "[2 4 6]"
+my @a = (for 1, 2, 3 { $_ * 2 }); @a.say;  # same thing
 
 =end code
 

doc/Language/faq.pod

@@ -679,7 +679,7 @@ Examples:
     # A perl program which works under both perl5 (with perl -Mbigint)
     # and perl6
 
-    my ($prev, $current) = (1,0);
+    my ($prev, $current) = (1, 0);
 
     for (0..100_000) {
         ($prev, $current) = ($current, $prev + $current);

doc/Language/functions.pod

@@ -167,16 +167,16 @@ can use it on methods as well. The candidates are all the multi methods of the
 object:
 
     class Congrats {
-        multi method congratulate($reason,$name) {
+        multi method congratulate($reason, $name) {
             say "Hooray for your $reason, $name";
         }
     }
 
     role BirthdayCongrats {
-        multi method congratulate('birthday',$name) {
+        multi method congratulate('birthday', $name) {
             say "Happy birthday, $name";
         }
-        multi method congratulate('birthday',$name,$age) {
+        multi method congratulate('birthday', $name, $age) {
             say "Happy {$age}th birthday, $name";
         }
     }
@@ -230,8 +230,8 @@ C<{*}> always dispatches to candidates with the parameters it's called
 with. Parameter defaults and type coercions will work but are not be passed on.
 
     proto mistake-proto(Str() $str, Int $number = 42) {*}
-    multi mistake-proto($str,$number) { say $str.WHAT }
-    mistake-proto(7,42);   #-> (Int) -- coercions not passed on
+    multi mistake-proto($str, $number) { say $str.WHAT }
+    mistake-proto(7, 42);  #-> (Int) -- coercions not passed on
     mistake-proto('test'); #!> fails -- defaults not passed on
 
 =comment only
@@ -271,29 +271,29 @@ This can be achieved by using a slurpy with a C<+> or C<+@> instead of C<**>:
 This results in the following behavior, which is known as the "single
 argument rule" and is important to understand when invoking slurpy functions:
 
-    grab(1,2);     # grab 1 grab 2
-    grab((1,2));   # grab 1 grab 2
-    grab($(1,2));  # grab 1 2
-    grab((1,2),3); # grab 1 2 grab 3
+    grab(1, 2);      # grab 1 grab 2
+    grab((1, 2));    # grab 1 grab 2
+    grab($(1, 2));   # grab 1 2
+    grab((1, 2), 3); # grab 1 2 grab 3
 
 This also makes user-requested flattening feel consistent whether there is
 one sublist, or many:
 
-    grab(flat (1,2),(3,4));   # grab 1 grab 2 grab 3 grab 4
-    grab(flat $(1,2),$(3,4)); # grab 1 2 grab 3 4
-    grab(flat (1,2));         # grab 1 grab 2
-    grab(flat $(1,2));        # grab 1 2
+    grab(flat (1, 2), (3, 4));   # grab 1 grab 2 grab 3 grab 4
+    grab(flat $(1, 2), $(3, 4)); # grab 1 2 grab 3 4
+    grab(flat (1, 2));           # grab 1 grab 2
+    grab(flat $(1, 2));          # grab 1 2
 
 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.
 
-    my $a = (1,2);  # Normal assignment, equivalent to $(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
-    my \c = (1,2);  # Sigilless variables always bind, even with '='
-    grab (c);       # grab 1 grab 2
+    my $a = (1, 2);  # Normal assignment, equivalent to $(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
+    my \c = (1, 2);  # Sigilless variables always bind, even with '='
+    grab (c);        # grab 1 grab 2
 
 =head1 Functions are First-Class Objects
 

doc/Language/glossary.pod

@@ -147,8 +147,8 @@ do that on a list.  This is separate from the type of elements in the array:
 if they are containers, then they are also mutable, but they don't have to
 be.  Arrays are typically recognizable by the L<#@> L<sigil|#Sigil>.
 
-    my @array = 1,2,3;
-    say @a;             # [1 2 3]
+    my @array = 1, 2, 3;
+    say @array;           # [1 2 3]
 
 =head1 Arity
 
@@ -191,7 +191,7 @@ value of the junction. The result of these calls is assembled in a new
 junction of the same type as the original junction.
 
     sub f($x) { 2 * $x };
-    say f(1|2|3) == 4;    # any(False,True,False)
+    say f(1|2|3) == 4;    # any(False, True, False)
 
 Here C<f()> is a sub with one parameter, and since it has no explicit type,
 it is implicitly typed as C<Any>.  The C<Junction> argument causes the
@@ -249,8 +249,8 @@ See the L<Wikipedia entry|https://en.wikipedia.org/wiki/Class_%28computer_progra
 A colon pair is a shorthand syntax used to create or visually present
 a Pair object.  The two most common forms are:
 
-    :a(4)          # Same as "a" => 4,   same as Pair.new("a",4)
-    :a<4>          # Same as "a" => "4", same as Pair.new("a","4")
+    :a(4)          # Same as "a" => 4,   same as Pair.new("a", 4)
+    :a<4>          # Same as "a" => "4", same as Pair.new("a", "4")
 
 This is also known as the adverbial pair form.  Note: when the part after
 the colon and before the brackets is not a legal identifier, other
@@ -294,7 +294,7 @@ Note that you can also differentiate candidates in a
 L<multi-dispatch|#Multi-Dispatch> by using a different constraint:
 
     multi sub abbreviate(Str $thing where { .chars > 10 }) {
-        "$thing.substr(0,7)..."
+        "$thing.substr(0, 7)..."
     }
     multi sub abbreviate(Str $thing) { $thing }  # no constraint
 
@@ -623,7 +623,7 @@ in Perl 6.  It is what C<self> refers to in a method.
 
 =head1 JIT
 
-L<Just-in-time compilation|https://en.wikipedia.org/wiki/Just-in-time_compilation>,a technique for improving the performance of virtual machines.
+L<Just-in-time compilation|https://en.wikipedia.org/wiki/Just-in-time_compilation>, a technique for improving the performance of virtual machines.
 
 =head1 Junction