chg p6 to raku; chg '.perl' to '.raku'

Author: tbrowder

doc/Language/operators.pod6

@@ -655,7 +655,7 @@ L<hash|/routine/hash> routine instead:
 The X<L<Array|/type/Array> constructor> returns an itemized L<Array|/type/Array> that does not flatten
 in list context. Check this:
 
-    say .perl for [3,2,[1,0]]; # OUTPUT: «3␤2␤$[1, 0]␤»
+    say .raku for [3,2,[1,0]]; # OUTPUT: «3␤2␤$[1, 0]␤»
 
 This array is itemized, in the sense that every element constitutes an item, as
 shown by the C<$> preceding the last element of the array, the
@@ -681,10 +681,10 @@ Universal interface for positional access to zero or more elements of a
     say @alphabet[*-1];                 # OUTPUT: «z␤»
     say @alphabet[100]:exists;          # OUTPUT: «False␤»
     say @alphabet[15, 4, 17, 11].join;  # OUTPUT: «perl␤»
-    say @alphabet[23 .. *].perl;        # OUTPUT: «("x", "y", "z")␤»
+    say @alphabet[23 .. *].raku;        # OUTPUT: «("x", "y", "z")␤»
 
     @alphabet[1, 2] = "B", "C";
-    say @alphabet[0..3].perl            # OUTPUT: «("a", "B", "C", "d")␤»
+    say @alphabet[0..3].raku;           # OUTPUT: «("a", "B", "C", "d")␤»
 
 See L<Subscripts|/language/subscripts>, for a more detailed explanation of this
 operator's behavior and for how to implement support for it in custom types.
@@ -699,7 +699,7 @@ Universal interface for associative access to zero or more elements of a
 
     my %color = kiwi => "green", banana => "yellow", cherry => "red";
     say %color{"banana"};                 # OUTPUT: «yellow␤»
-    say %color{"cherry", "kiwi"}.perl;    # OUTPUT: «("red", "green")␤»
+    say %color{"cherry", "kiwi"}.raku;    # OUTPUT: «("red", "green")␤»
     say %color{"strawberry"}:exists;      # OUTPUT: «False␤»
 
     %color{"banana", "lime"} = "yellowish", "green";
@@ -720,10 +720,10 @@ it independent of the container type.
 =begin code
 use JSON::Tiny;
 
-my $config = from-json('{ "files": 3, "path": "/home/perl6/perl6.pod6" }');
-say $config.perl;      # OUTPUT: «${:files(3), :path("/home/perl6/perl6.pod6")}»
+my $config = from-json('{ "files": 3, "path": "/home/some-user/raku.pod6" }');
+say $config.raku;      # OUTPUT: «${:files(3), :path("/home/some-user/raku.pod6")}»
 my %config-hash = $config<>;
-say %config-hash.perl; # OUTPUT: «{:files(3), :path("/home/perl6/perl6.pod6")}»
+say %config-hash.raku; # OUTPUT: «{:files(3), :path("/home/some-user/raku.pod6")}»
 =end code
 
 It's a C<Hash> in both cases, and it can be used like that; however, in the
@@ -738,7 +738,7 @@ that quotes its argument using the same rules as the L«quote-words operator|
 
     my %color = kiwi => "green", banana => "yellow", cherry => "red";
     say %color<banana>;               # OUTPUT: «yellow␤»
-    say %color<cherry kiwi>.perl;     # OUTPUT: «("red", "green")␤»
+    say %color<cherry kiwi>.raku;     # OUTPUT: «("red", "green")␤»
     say %color<strawberry>:exists;    # OUTPUT: «False␤»
 
 Technically, not a real operator; it's syntactic sugar that's turned into the
@@ -753,7 +753,7 @@ of the same name.
 
     my %color = kiwi => "green", banana => "yellow", cherry => "red";
     my $fruit = "kiwi";
-    say %color«cherry "$fruit"».perl;   # OUTPUT: «("red", "green")␤»
+    say %color«cherry "$fruit"».raku;   # OUTPUT: «("red", "green")␤»
 
 Technically, not a real operator; it's syntactic sugar that's turned into the
 C<{ }> postcircumfix operator at compile-time.
@@ -1148,7 +1148,7 @@ Flattens objects of type L<Capture|/type/Capture>, L<Pair|/type/Pair>, L<List|/t
 L<Hash|/type/Hash> into an argument list.
 
     sub slurpee( |args ){
-        say args.perl
+        say args.raku
     };
     slurpee( <a b c d>, { e => 3 }, 'e' => 'f' => 33 )
     # OUTPUT: «\(("a", "b", "c", "d"), {:e(3)}, :e(:f(33)))␤»
@@ -1618,7 +1618,7 @@ X<|Any junction operator>
 Creates an I<any> L<Junction|/type/Junction> from its arguments.
 
     my $three-letters = /<[a b c]>/ | /<[i j k]>/ | /<[x y z]>/;
-    say $three-letters.perl; # OUTPUT: «any(/<[a b c]>/, /<[i j k]>/, /<[x y z]>/)␤»
+    say $three-letters.raku; # OUTPUT: «any(/<[a b c]>/, /<[i j k]>/, /<[x y z]>/)␤»
     say 'b' ~~ $three-letters; # OUTPUT: «True␤»
 
 This first creates an C<any> C<Junction> of three regular expressions
@@ -2938,7 +2938,7 @@ Constructs a higher-order L<Cool|/type/Cool> from its arguments.
     my @list = :god('Þor'), ['is',"mighty"];
     say @list;      # OUTPUT: «[god => Þor [is mighty]]␤»
     my %hash = :god('Þor'), :is("mighty");
-    say %hash.perl; # OUTPUT: «{:god("Þor"), :is("mighty")}␤»
+    say %hash.raku; # OUTPUT: «{:god("Þor"), :is("mighty")}␤»
     my %a = :11a, :22b;
     say %(%a, :33x);  # OUTPUT: «{a => 11, b => 22, x => 33}␤»
 
@@ -2982,7 +2982,7 @@ one of the operands runs out of elements prematurely, the zip operator will
 stop.
 
 =for code
-say (1, 2 Z <a b c> Z <+ ->).perl;
+say (1, 2 Z <a b c> Z <+ ->).raku;
 # OUTPUT: «((1, "a", "+"), (2, "b", "-")).Seq␤»
 for <a b c> Z <1 2 3 4> -> [$l, $r] {
     say "$l:$r"