Merge pull request #3244 from tbrowder/p6toraku-variables

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

Author: JJ

doc/Language/variables.pod6

@@ -162,15 +162,15 @@ List C<(42, "str")> is list-assigned to C<@array>:
 
     my @array;
     @array = my $num = 42, "str";   # parsed as @array = ( (my $num = 42), "str )
-    say @array.perl;                # OUTPUT: «[42, "str"]␤» (an Array)
-    say $num.perl;                  # OUTPUT: «42␤» (a Num)
+    say @array.raku;                # OUTPUT: «[42, "str"]␤» (an Array)
+    say $num.raku;                  # OUTPUT: «42␤» (a Num)
 
 Here's a variant:
 
     my ( @foo, $bar );
     @foo = ($bar) = 42, "str";       # parsed as @foo = ( $bar = (42, "str") )
-    say $bar.perl;                   # OUTPUT: «$(42, "str")␤» (a List)#
-    say @foo.perl;                   # OUTPUT: «[(42, "str"),]␤» (an Array)
+    say $bar.raku;                   # OUTPUT: «$(42, "str")␤» (a List)#
+    say @foo.raku;                   # OUTPUT: «[(42, "str"),]␤» (an Array)
 
 In this case, the list contextualizer C<( )> puts C<$bar> in a list context, and
 thus triggers a list assignment to the Scalar variable C<$bar>. This means that
@@ -206,10 +206,10 @@ Sigilless variables do not enforce L<context|/language/contexts>, so they can be
 used to pass something on as-is:
 
     sub logged(&f, |args) {
-        say('Calling ' ~ &f.name ~ ' with arguments ' ~ args.perl);
+        say('Calling ' ~ &f.name ~ ' with arguments ' ~ args.raku);
         my \result = f(|args);
         #  ^^^^^^^ not enforcing any context here
-        say(&f.name ~ ' returned ' ~ result.perl);
+        say(&f.name ~ ' returned ' ~ result.raku);
         return |result;
     }
 
@@ -459,7 +459,7 @@ following are useful:
 X<|$~MAIN>X<|$~Quote>X<|$~Quasi>X<|$~Regex>X<|$~Trans>X<|$~P5Regex>
 
 =begin table
-    $~MAIN       the current main language (e.g. Perl statements)
+    $~MAIN       the current main language (e.g., Raku statements)
     $~Quote      the current root of quoting language
     $~Quasi      the current root of quasiquoting language
     $~Regex      the current root of regex language
@@ -609,7 +609,7 @@ elements are left will result in undefined values according to the type of the
 variables.
 
     my (Str $a, Str $b, Int $c) = <a b>;
-    say [$a, $b, $c].perl;
+    say [$a, $b, $c].raku;
     # OUTPUT: «["a", "b", Int]␤»
 
 To destructure a list into a single value, create a list literal with one
@@ -618,13 +618,13 @@ parentheses around a single variable is sufficient.
 
     sub f { 1,2,3 };
     my ($a) = f;
-    say $a.perl;
+    say $a.raku;
     # OUTPUT: «1␤»
 
 To skip elements in the list use the anonymous state variable C<$>.
 
     my ($,$a,$,%h) = ('a', 'b', [1,2,3], {:1th});
-    say [$a, %h].perl;
+    say [$a, %h].raku;
     # OUTPUT: «["b", {:th(1)}]␤»
 
 =head2 The C<has> declarator
@@ -775,14 +775,14 @@ Furthermore, state variables can be used outside of subroutines. You
 could, for example, use C<$> in a one-liner to number the lines in a file.
 
 =begin code :lang<shell>
-perl6 -ne 'say ++$ ~ " $_"' example.txt
+raku -ne 'say ++$ ~ " $_"' example.txt
 =end code
 
 Each reference to C<$> within a lexical scope is in effect a separate
 variable.
 
 =begin code :lang<shell>
-perl6 -e '{ say ++$; say $++  } for ^5'
+raku -e '{ say ++$; say $++  } for ^5'
 # OUTPUT: «1␤0␤2␤1␤3␤2␤4␤3␤5␤4␤»
 =end code
 
@@ -1488,7 +1488,7 @@ This shows additional information on the operating system and version it's
 using, but as a matter of fact, this variable contains information which is
 useful to create portable programs, such as the path separator:
 
-    say $*DISTRO.perl;
+    say $*DISTRO.raku;
     # OUTPUT: «Distro.new(release => "42.3", is-win => Bool::False,
     #          path-sep => ":", name => "opensuse",
     #          auth => "https://www.opensuse.org/", version => v42.3,
@@ -1548,7 +1548,7 @@ X<|$*PROGRAM-NAME>
 =head4 C<$*PROGRAM-NAME>
 
 This contains the path to the current executable as it was entered on the
-command line, or C<-e> if perl was invoked with the -e flag.
+command line, or C<-e> if raku was invoked with the -e flag.
 
 X<|$*PROGRAM>
 =head4 C<$*PROGRAM>
@@ -1566,15 +1566,15 @@ Raku is embedded in another language runtime (such as Inline::Perl6 in Perl 5).
 X<|$*EXECUTABLE>
 =head4 C<$*EXECUTABLE>
 
-Contains an C<IO::Path> absolute path of the perl executable that is currently
+Contains an C<IO::Path> absolute path of the raku executable that is currently
 running.
 
 X<|$*EXECUTABLE-NAME>
 =head4 C<$*EXECUTABLE-NAME>
 
-Contains the name of the Perl executable that is currently running. (e.g.
-perl6-p, perl6-m). Favor C<$*EXECUTABLE> over this one, since it's not
-guaranteed that the perl executable is in C<PATH>.
+Contains the name of the Raku executable that is currently running. (e.g.
+raku-p, raku-m). Favor C<$*EXECUTABLE> over this one, since it's not
+guaranteed that the raku executable is in C<PATH>.
 
 X<|$*USAGE>
 =head4 C<$*USAGE>
@@ -1648,7 +1648,7 @@ By default this imposes a maximum of 64 threads on the methods C<.hyper>,
 C<.race> and other thread-pool classes that use that scheduler such as
 C<Promise>s or C<Supply>s. This is, however, implementation, dependent and might
 be subject to change. To change the maximum number of threads, you can either
-set the environment variable C<RAKUDO_MAX_THREADS> before running perl6 or
+set the environment variable C<RAKUDO_MAX_THREADS> before running raku or
 create a scoped copy with the default changed before using them:
 
     my $*SCHEDULER = ThreadPoolScheduler.new( max_threads => 128 );
@@ -1669,7 +1669,7 @@ message.
 
 =for code
 sub MAIN($a, :$b, UInt :$ehehe) {
-    say $*USAGE; # OUTPUT: «Usage:␤  perl6.pl6 [-a=<Int>] [-b=<Str>] [--<opts>=...]»
+    say $*USAGE; # OUTPUT: «Usage:␤  my-script.raku [-a=<Int>] [-b=<Str>] [--<opts>=...]»
 }
 
 It is accessible only inside of MAIN sub.