=begin pod

=TITLE Variables

=SUBTITLE Variables in Perl 6

Variable names start with a special character called a I<sigil>, followed
optionally by a second special character named I<twigil> and then an
I<identifier>.

=head1 Sigils
X<|$ (sigil),@ (sigil),% (sigil),& (sigil)>

The sigil serves as a variable indicator and type constraint.

=begin table

    Sigil   Type constraint              Default type  Assignment  Examples
    =====   ===============              ============  ==========  ========
    $       Mu (no type constraint)      Any           item        Int, Str, Array, Hash
    @       Positional                   Array         list        List, Array, Range, Buf
    %       Associative                  Hash          list        Hash, Map, Pair
    &       Callable                     Callable      item        Sub, Method, Block, Routine

=end table

Examples:

    my $square = 9 ** 2;
    my @array  = 1, 2, 3;   # Array variable with three elements
    my %hash   = London => 'UK', Berlin => 'Germany';

X<|is (container type)>
The default type can be set with C<is>.

    class FailHash is Hash {
        has Bool $!final = False;
        multi method AT-KEY ( ::?CLASS:D: Str:D \key ){
            fail X::OutOfRange.new(:what("Hash key"), :got(key), :range(self.keys)) if $!final && !self.EXISTS-KEY(key);
            callsame
        }

        method finalize() {
            $!final = True
        }
    }

    my %h is FailHash = oranges => "round", bananas => "bendy";
    say %h<oranges>;
    # OUTPUT «round␤»
    %h.finalize;
    say %h<cherry>;
    CATCH { default { put .^name, ': ', .Str } }
    # OUTPUT «X::OutOfRange: Hash key out of range. Is: cherry, should be in (oranges bananas)»

Variables without sigils are also possible, see
L<sigilless variables|#Sigilless variables>.

=head2 Item and List Assignment

There are two types of assignment, I<item assignment> and I<list
assignment>.  Both use the equal sign C<=> as operator. The distinction
whether an C<=> means item or list assignment is based on the syntax of the
left-hand side.

Item assignment places the value from the right-hand side into the variable
(container) on the left.

List assignment leaves the choice of what to do to the variable on the left.

For example, L<Array> variables (C<@> sigil) empty themselves on list
assignment and then put all the values from the right-hand side into
themselves.

The type of assignment (item or list) is decided by the first context
seen in the current expression or declarator:

    my $foo = 5;            # item assignment
    say $foo.perl;          # 5

    my @bar = 7, 9;         # list assignment
    say @bar.WHAT;          # (Array)
    say @bar.perl;          # [7, 9]

    (my $baz) = 11, 13;     # list assignment
    say $baz.WHAT;          # (List)
    say $baz.perl;          # (11, 13)

Thus, the behavior of an assignment contained within a list assignment depends
on the expression or declarator that contains it.

For instance, if the internal assignment is a declarator, item assignment
is used, which has tighter precedence than both the comma and the list
assignment:

    my @array;
    @array = my $num = 42, "str";   # item assignment: uses declarator
    say @array.perl;                # [42, "str"] (an Array)
    say $num.perl;                  # 42 (a Num)

Similarly, if the internal assignment is an expression that is being
used as an initializer for a declarator, the context of the internal
expression determines the type of assignment:

    my $num;
    my @array = $num = 42, "str";    # item assignment: uses expression
    say @array.perl;                 # [42, "str"] (an Array)
    say $num.perl;                   # 42 (a Num)

    my ( @foo, $bar );
    @foo = ($bar) = 42, "str";       # list assignment: uses parens
    say @foo.perl;                   # [42, "str"] (an Array)
    say $bar.perl;                   # $(42, "str")  (a List)

However, if the internal assignment is neither a declarator nor an
expression, but is part of a larger expression, the context of the
larger expression determines the type of assignment:

    my ( @array, $num );
    @array = $num = 42, "str";    # list assignment
    say @array.perl;              # [42, "str"] (an Array)
    say $num.perl;                # [42, "str"] (an Array)

This is because the whole expression is C<@array = $num = 42, "str">, while
C<$num = 42> is not is own separate expression.

See L<operators|/language/operators> for more details on precedence.

=head2 Sigilless variables
X<|\ (sigilless variables)>

It is possible to create "variables" in Perl 6 that do not have sigils:

    my \degrees = pi / 180;
    my \θ       = 15 * degrees;

Note, however, that these do not create L<containers|/language/containers>. That means C<degrees>
and C<θ> above actually directly represent C<Num>s. To illustrate, try
assigning to one after you've defined it:

=begin code :skip-test
θ = 3; # Dies with the error "Cannot modify an immutable Num"
=end code

Sigilless variables do not enforce context, so they can be used to pass
something on as-is:

    sub logged(&f, |args) {
        say('Calling ' ~ &f.name ~ ' with arguments ' ~ args.perl);
        my \result = f(|args);
        #  ^^^^^^^ not enforcing any context here
        say(&f.name ~ ' returned ' ~ result.perl);
        return |result;
    }

=head1 Twigils
X<|Twigil>

Twigils influence the scoping of a variable. Please be aware that twigils
have no influence over whether the primary sigil interpolates. That is, if
C<$a> interpolates, so do C<$^a>, C<$*a>, C<$=a>, C<$?a>, C<$.a>, etc.  It
only depends on the C<$>.

=begin table

    Twigil  Scope
    ======  =====
     none   Based only on declarator
     *      Dynamic
     !      Attribute (class member)
     ?      Compile-time variable
     .      Method (not really a variable)
     <      Index into match object (not really a variable)
     ^      Self-declared formal positional parameter
     :      Self-declared formal named parameter
     =      Pod variables
     ~      The sublanguage seen by the parser at this lexical spot

=end table

=head2 The C<*> Twigil
X<|$*>

Dynamic variables are looked up through the caller, not through the outer
scope. For example:

    =begin code
    my $lexical   = 1;
    my $*dynamic1 = 10;
    my $*dynamic2 = 100;

    sub say-all() {
        say "$lexical, $*dynamic1, $*dynamic2";
    }

    # prints 1, 10, 100
    say-all();

    {
        my $lexical   = 2;
        my $*dynamic1 = 11;
        $*dynamic2    = 101;

        # prints 1, 11, 101
        say-all();
    }

    # prints 1, 10, 101
    say-all();
    =end code

The first time C<&say-all> is called, it prints "C<1, 10, 100>" just as one
would expect. The second time though, it prints "C<1, 11, 101>". This is
because C<$lexical> isn't looked up in the caller's scope but in the scope
C<&say-all> was defined in. The two dynamic variables are looked up in the
caller's scope and therefore have the values C<11> and C<101>. The third
time C<&say-all> is called C<$*dynamic1> isn't C<11> anymore, but
C<$*dynamic2> is still C<101>. This stems from the fact that we declared a
new dynamic variable C<$*dynamic1> in the block and did not assign to the
old variable as we did with C<$*dynamic2>.

The dynamic variables differ from other variable types in that referring
to an undeclared dynamic variable is not a compile time error but a
runtime L<failure|/type/Failure>, so a dynamic variable can be used
undeclared as long as it is checked for definedness or used in a
boolean context before using it for anything else:

    =begin code
    sub foo() {
        $*FOO // 'foo';
    }

    say foo; # -> 'foo'

    my $*FOO = 'bar';

    say foo; # -> 'bar'
    =end code


=head2 The C<!> Twigil
X<|$!>

Attributes are variables that exist per instance of a class. They may be
directly accessed from within the class via C<!>:

    my class Point {
        has $.x;
        has $.y;

        method Str() {
            "($!x, $!y)"
        }
    }

Note how the attributes are declared as C<$.x> and C<$.y> but are still
accessed via C<$!x> and C<$!y>. This is because in Perl 6 all attributes are
private and can be directly accessed within the class by using
C<$!attribute-name>. Perl 6 may automatically generate accessor methods for
you though. For more details on objects, classes and their attributes see
L<object orientation|/language/objects>.

=head2 The C<?> Twigil
X<|$?>

Compile-time variables may be addressed via the C<?> twigil. They are known
to the compiler and may not be modified after being compiled in. A popular
example for this is:

    say "$?FILE: $?LINE"; # prints "hello.pl: 23" if this is the 23 line of a
                          # file named "hello.pl".

For a list of these special variables see
L<compile-time variables|/language/variables#Compile-time_variables>.

=head2 The C<.> Twigil
X<|$.>

The C<.> twigil isn't really for variables at all. In fact, something along
the lines of

    my class Point {
        has $.x;
        has $.y;

        method Str() {
            "($.x, $.y)" # note that we use the . instead of ! this time
        }
    }

just calls the methods C<x> and C<y> on C<self>, which are automatically
generated for you because you used the C<.> twigil when the attributes were
declared.  Note, however, that subclasses may override those methods. If you
don't want this to happen, use C<$!x> and C<$!y> instead.

The fact that the C<.> twigil just does a method call also implies that the
following is possible too:

    class SaySomething {
        method a() { say "a"; }
        method b() { $.a; }
    }

    SaySomething.b; # prints "a"

For more details on objects, classes and their attributes and methods see
L<object orientation|/language/objects>.

=head2 The C«<» Twigil

The C<< < >> twigil is just an alias for C<< $/<...> >> where C<$/> is the
match variable. For more information about the match variable see L<#The_$/_Variable> and
L<type Match|/type/Match>.

=head2 The C<^> Twigil
X<|$^>

The C<^> twigil declares a formal positional parameter to blocks or
subroutines.  Variables of the form C<$^variable> are a type of placeholder
variable. They may be used in bare blocks to declare formal parameters to
that block. So the block in the code

    for ^4 {
        say "$^b follows $^a";
    }

    # OUTPUT:
    # 1 follows 0
    # 3 follows 2

has two formal parameters, namely C<$a> and C<$b>. Note that even though C<$^b>
appears before C<$^a> in the code, C<$^a> is still the first formal parameter
to that block. This is because the placeholder variables are sorted in Unicode
order. If you have self-declared a parameter using C<$^a> once, you may refer
to it using only C<$a> thereafter.

Although it is possible to use nearly any valid identifier as a placeholder
variable, it's recommended to use short names or ones that can be trivially
understood in the correct order, to avoid surprise on behalf of the reader.

Subroutines may also make use of placeholder variables but only if they do
not have an explicit parameter list. This is true for normal blocks too.


=begin code :skip-test
sub say-it    { say $^a; } # valid
sub say-it()  { say $^a; } # invalid
              { say $^a; } # valid
-> $x, $y, $x { say $^a; } # invalid
=end code

Placeholder variables syntactically cannot have any type constraints. Be
also aware that one cannot have placeholder variables with a single
upper-case letter. This is disallowed in favor of being to able to catch
some Perl 5-isms.

=head2 The C<:> Twigil
X<|$:>

The C<:> twigil declares a formal named parameter to a block or subroutine.
Variables declared using this form are a type of placeholder variable too.
Therefore the same things that apply to variables declared using the C<^>
twigil also apply here (with the exception that they are not positional and
therefore not ordered using Unicode order, of course). So this:

    say { $:add ?? $^a + $^b !! $^a - $^b }( 4, 5 ) :!add
    # OUTPUT:
    # -1

See L<^> for more details about placeholder variables.

=head2 The C<=> Twigil
X<|$=>

The C<=> twigil is used to access Pod variables. Every Pod block in the
current file can be accessed via a Pod object, such as C<$=data>,
C<$=SYNOPSIS> or C<=UserBlock>. That is: a variable with the same name of
the desired block and a C<=> twigil.

    =begin code
    =begin Foo
    ...
    =end Foo

    #after that, $=Foo gives you all Foo-Pod-blocks
    =end code

You may access the Pod tree which contains all Pod structures as a
hierarchical data structure through C<$=pod>.

Note that all those C<$=someBlockName> support the C<Positional> and the
C<Associative> roles.

=head2 The C<~> Twigil
X<|$~>

Note: Slangs are L<NYI|/language/glossary#NYI> in Rakudo.

The C<~> twigil is for referring to sublanguages (called slangs). The
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)
    $~Quote      the current root of quoting language
    $~Quasi      the current root of quasiquoting language
    $~Regex      the current root of regex language
    $~Trans      the current root of transliteration language
    $~P5Regex    the current root of the Perl 5 regex language
=end table

You C<augment> these languages in your current lexical scope.

=begin code :skip-test
use MONKEY-TYPING;
augment slang Regex {  # derive from $~Regex and then modify $~Regex
    token backslash:std<\Y> { YY };
}
=end code

=head1 Variable Declarators and Scope

Most of the time it's enough to create a new variable using the C<my>
keyword:

    my $amazing-variable = "World";
    say "Hello $amazing-variable!"; # Hello World!

However, there are many declarators that change the details of scoping
beyond what L<#Twigils> can do.

=for table
    Declarator    Effect
    ==========    ======
    my            Introduces lexically scoped names
    our           Introduces package-scoped names
    has           Introduces attribute names
    anon          Introduces names that are private to the construct
    state         Introduces lexically scoped but persistent names
    augment       Adds definitions to an existing name
    supersede     Replaces definitions of an existing name

There are also two prefixes that resemble declarators but act on
predefined variables:

=for table
    Prefix  Effect
    ======  ======
    temp    Restores a variable's value at the end of scope
    let     Restores a variable's value at the end of scope if the block exits unsuccessfully

=head2 The C<my> Declarator

Declaring a variable with C<my> gives it lexical scope. This means it only
exists within the current block. For example:

=begin code :skip-test
{
    my $foo = "bar";
    say $foo; # -> "bar"
}
say $foo; # !!! "Variable '$foo' is not declared"
=end code

This dies because C<$foo> is only defined as long as we are in the same
scope.

Additionally, lexical scoping means that variables can be temporarily
redefined in a new scope:

    my $location = "outside";

    sub outer-location {
        # Not redefined:
        say $location;
    }

    outer-location; # -> "outside"

    sub in-building {
        my $location = "inside";
        say $location;
    }

    in-building; # -> "inside"

    outer-location; # -> "outside"

If a variable has been redefined, any code that referenced the outer
variable will continue to reference the outer variable. So here,
C<&outer-location> still prints the outer C<$location>:

=begin code :skip-test
sub new-location {
    my $location = "nowhere"
    outer-location;
}

new-location; # -> "outside"
=end code

To make C<new-location()> print C<nowhere>, make C<$location> a dynamic
variable using L<the * twigil|#The_*_Twigil>.

C<my> is the default scope for subroutines, so C<my sub x() {}> and
C<sub x() {}> do exactly the same thing.

=head2 The C<our> Declarator

C<our> variables work just like C<my> variables, except that they also
introduce an alias into the symbol table.

    module M {
        our $Var;
        # $Var available here
    }

    # Available as $M::Var here.

=head2 Declaring a list of variables

The declarators C<my> and C<our> take a list of variables in parentheses as argument to declare more then one variable at a time.

    my (@a, $s, %h);

This can be used in conjunction with X«destructuring assignment». Any
assignment to such a list will take the number of elements provided in the left
list and assign corresponding values from the right list to them. Any missing
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;
    # OUTPUT«["a", "b", Int]␤»

To destructure a list into a single value create a list literal with one value
by using C<($var,)>. When used with a variable declarator just providing
parentheses around a single variable is sufficient.

    sub f { 1,2,3 };
    my ($a) = f;
    say $a.perl;
    # 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;
    # OUTPUT«["b", {:th(1)}]␤»

=head2 The C<has> Declarator

C<has> scopes attributes to instances of a class or role, and methods to
classes or roles. C<has> is implied for methods, so C<has method x() {}>
and C<method x() {}> do the same thing.

See L<object orientation|/language/objects> for more documentation and some
examples.

=head2 The C<anon> Declarator

The C<anon> declarator prevents a symbol from getting installed in the lexical
scope, the method table and everywhere else.

For example you can use it to declare subroutines which know their own name,
but still aren't installed in a scope:

    my %operations =
        half   => anon sub half($x) { $x / 2 },
        square => anon sub square($x) { $x * $x },
        ;
    say %operations<square>.name;       # square
    say %operations<square>(8);         # 64

=head2 The C<state> Declarator

C<state> declares lexically scoped variables, just like C<my>. However,
initialization happens exactly once the first time the initialization
is encountered in the normal flow of execution. Thus, state variables
will retain their value across multiple executions of the enclosing
block or routine.

Therefore, the subroutine

    sub a {
        state @x;
        state $l = 'A';
        @x.push($l++);
    };

    say a for 1..6;

will continue to increment C<$l> and append it to C<@x> each time it is
called. So it will output

=begin code :skip-test

[A]
[A B]
[A B C]
[A B C D]
[A B C D E]
[A B C D E F]

=end code

This works per "clone" of the containing code object, as in this example:

    ({ state $i = 1; $i++.say; } xx 3).map: {$_(), $_()}; # says 1 then 2 thrice

Note that this is B<not> a thread-safe construct when the same clone of the same
block is run by multiple threads.  Also remember that methods only have one
clone per class, not per object.


As with C<my>, declaring multiple C<state> variables must be placed
in parentheses and for declaring a single variable, parentheses may
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() {
        state $i;
        $i++;
        @a.push: "k$i" => $i # <-- .clone goes here
    };
    f for 1..3;
    dd @a; # «Array $var = $[:k1(3), :k2(3), :k3(3)]»

All state variables are shared between threads. The result can be undesired or
dangerous.

    sub code(){ state $i = 0; say ++$i; $i };
    await
        start { loop { last if code() >= 5 } },
        start { loop { last if code() >= 5 } };

    # OUTPUT«1␤2␤3␤4␤4␤3␤5␤»
    # OUTPUT«2␤1␤3␤4␤5␤»
    # many other more or less odd variations can be produced

=head3 The C<$> Variable

As well as explicitly declared named state variables C<$> can be used
as an anonymous state variable without an explicit C<state> declaration.

    say "1-a 2-b 3-c".subst(:g, /\d/, {<one two three>[$++]});
    # OUTPUT«one-a two-b three-c␤»

Furthermore, state variables are not required to exist in subroutines. You
could, for example, use C<$> in a one-liner to number the lines in a file.

=begin code :skip-test
perl6 -ne 'say ++$ ~ " $_"' example.txt
=end code

Each reference to C<$> within a lexical scope in effect is a separate
variable.

=begin code :skip-test
perl6 -e '{ say ++$; say $++  } for ^5'
# OUTPUT«1␤0␤2␤1␤3␤2␤4␤3␤5␤4␤»
=end code

If you need to refer to the value of C<$> more than once within the
scope it should be copied to a new variable.

    sub foo() {
        given ++$ {
            when 1 {
                say "one";
            }
            when 2 {
                say "two";
            }
            when 3 {
                say "three";
            }
            default {
                say "many";
            }
        }
    }

    foo() for ^3;
    # OUTPUT«one␤two␤three␤»

=head3 The C<@> Variable

In a similar manner to the C<$> variable there is also a L<Positional>
anonymous state variable C<@>.

    sub foo($x) {
        say (@).push($x);
    }

    foo($_) for ^3;

    # OUTPUT:
    # [0]
    # [0 1]
    # [0 1 2]

The C<@> here is parenthesized in order to disambiguate the expression
from a class member variable named C<@.push>.  Indexed access doesn't
require this disambiguation but you will need to copy the value in order
to do anything useful with it.

    sub foo($x) {
        my $v = @;
        $v[$x] = $x;
        say $v;
    }

    foo($_) for ^3;

    # OUTPUT:
    # [0]
    # [0 1]
    # [0 1 2]

As with C<$> each mention of C<@> in a scope introduces a new anonymous
array.

=head3 The C<%> Variable

Finally there is also an L<Associative> anonymous state variable C<%>.

    sub foo($x) {
        say (%).push($x => $x);
    }

    foo($_) for ^3;

    # OUTPUT:
    # 0 => 0
    # 0 => 0, 1 => 1
    # 0 => 0, 1 => 1, 2 => 2

The same caveat about disambiguation applies. As you may expect, indexed
access is also possible (with copying to make it useful).

    sub foo($x) {
        my $v = %;
        $v{$x} = $x;
        say $v;
    }

    foo($_) for ^3;

    # OUTPUT:
    # 0 => 0
    # 0 => 0, 1 => 1
    # 0 => 0, 1 => 1, 2 => 2

As with the other anonymous state variables each mention of C<%> within a
given scope will effectively introduce a separate variable.

=head2 The C<augment> Declarator

With C<augment>, you can add attributes and methods to existing classes and
grammars, provided you activated the C<MONKEY-TYPING> pragma first.

Since classes are usually C<our> scoped, and thus global, this means modifying
global state, which is strongly discouraged. For almost all situations, there
are better solutions.

    # don't do this
    use MONKEY-TYPING;
    augment class Int {
        method is-answer { self == 42 }
    }
    say 42.is-answer;       # True

(In this case, the better solution would be to use a
L<function|/language/functions>).

=head2 The C<temp> Prefix

Like C<my>, C<temp> restores the old value of a variable at the end of its
scope. However, C<temp> does not create a new variable.

    my $in = 0; # temp will "entangle" the global variable with the call stack
                # that keeps the calls at the bottom in order.
    sub f(*@c) {
        (temp $in)++;
         "<f>\n"
         ~ @c>>.indent($in).join("\n")
         ~ (+@c ?? "\n" !! "")
         ~ '</f>'
    };
    sub g(*@c) {
        (temp $in)++;
        "<g>\n"
        ~ @c>>.indent($in).join("\n")
        ~ (+@c ?? "\n" !! "")
        ~ "</g>"
    };
    print g(g(f(g()), g(), f()));

    # OUTPUT:
    # <g>
    #  <g>
    #   <f>
    #    <g>
    #    </g>
    #   </f>
    #   <g>
    #   </g>
    #   <f>
    #   </f>
    #  </g>
    # </g>

=head2 The C<let> Prefix

Restores the previous value if the block exits unsuccessfully. A
successful exit means the block returned a defined value or a list.

    my $answer = 42;

    {
        let $answer = 84;
        die if not Bool.pick;
        CATCH {
            default { say "it's been reset :(" }
        }
        say "we made it 84 sticks!";
    }

    say $answer;

In the above case, if the C<Bool.pick> returns true, the answer will
stay as 84 because the block returns a defined value (C<say> returns
true). Otherwise the C<die> statement will cause the block to exit
unsuccessfully, resetting the answer to 42.

=comment this is duplicated in operators.pod

=head1 Type Constraints and Initialization

Variables can have a type constraint, which goes between the declarator and
the variable name.

    my Int $x = 42;
    $x = 'a string';
    CATCH { default { put .^name, ': ', .Str } }
    # OUTPUT: X::TypeCheck::Assignment: Type check failed in assignment to $x; expected Int but got Str ("a string")

If a scalar variable has a type constraint but no initial value, it is
initialized with the type object of the constraint type.

    my Int $x;
    say $x.^name;       # Int
    say $x.defined;     # False

Scalar variables without an explicit type constraint are typed as
L<Mu|/type/Mu> but default to the L<Any|/type/Any> type object.

Variables with the C<@> sigil are initialized with an empty
L<Array|/type/Array>; variables with the C<%> sigil are initialized with an
empty L<Hash|/type/Hash>.

The default value of a variable can be set with the C<is default> trait, and
re-applied by assigning C<Nil> to it:

    my Real $product is default(1);
    say $product;                       # 1
    $product *= 5;
    say $product;                       # 5
    $product = Nil;
    say $product;                       # 1

=head2 Default Defined Variables Pragma

To force all variables to have a definedness contraint use the prama C<use
variables :D>. The pragma is lexically scoped and can be switched of with C<use
variables :_>.

=begin code :skip-test
use variables :D;
my Int $i;
# OUTPUT«===SORRY!=== Error while compiling <tmp>␤Variable definition of type Int:D (implicit :D by pragma) requires an initializer ...
my Int $i = 1; # that works
{ use variables :_; my Int $i; } # switch it off in this block
=end code

Please note that assigning L<Nil|/type/Nil> will revert the variable to it's
default value. The default value of a defined constraint type is the type
appended with C<:D> (e.g. C<Int:D>). That means a definedness contraint is no
guarantee of definedness. This only applies to variable initializers, not to
L<Signature|/type/Signature>s. or subsequent assignments to a variable.

=head1 Special Variables

Perl 5 is infamous for its many obscure special variables. Perl 6 also has
special variables but only has three that are extra short due to how often
they're used. Other special variables have longer, more descriptive names.

=head2 Pre-defined lexical variables

There are three special variables that are available in every block:

=begin table

    Variable    Meaning

    $_          topic variable
    $/          regex match
    $!          exceptions

=end table

=head3 The C<$_> Variable

C<$_> is the topic variable. It is the default parameter for blocks that do
not have an explicit signature, so constructs like C<for @array { ... }> and
C<given $var { ... }> bind to C<$_> simply by invoking the block.

    for <a b c> { say $_ }  # sets $_ to 'a', 'b' and 'c' in turn
    say $_ for <a b c>;     # same, even though it's not a block
    given 'a'   { say $_ }  # sets $_ to 'a'
    say $_ given 'a';       # same, even though it's not a block

C<CATCH> blocks set C<$_> to the exception that was caught. The C<~~>
smart-match operator sets C<$_> on the right-hand side expression to the
value of the left-hand side.

Calling a method on C<$_> can be shortened by leaving off the variable name:

    .say;                   # same as $_.say

C<m/regex/> and C</regex/> regex matches and C<s/regex/subst/> substitutions
work on C<$_>:

    say "Looking for strings with non-alphabetic characters...";
    for <ab:c d$e fgh ij*> {
        .say if m/<!alpha>/;
    }

    # OUTPUT:
    # Looking for strings with non-alphabetic characters...
    # ab:c
    # d$e
    # ij*

=head3 The C<$/> Variable

C<$/> is the match variable. It stores the result of the last L<Regex|/language/regexes>
match and so usually contains objects of type L<Match>.

    'abc 12' ~~ /\w+/;  # sets $/ to a Match object
    say $/.Str;         # abc

The C<Grammar.parse> method also sets the caller's C<$/> to the resulting
L<Match> object.  For the following code:

=begin code :skip-test
use XML::Grammar; # panda install XML
XML.Grammar.parse("<p>some text</p>");
say $/;

# OUTPUT:
# ｢<p>some text</p>｣
#  root => ｢<p>some text</p>｣
#   name => ｢p｣
#   child => ｢some text｣
#    text => ｢some text｣
#    textnode => ｢some text｣
#  element => ｢<p>some text</p>｣
#   name => ｢p｣
#   child => ｢some text｣
#    text => ｢some text｣
#    textnode => ｢some text｣
=end code

=head4 X«Positional Attributes|variable,$0;variable,$1;variable,@()»

C<$/> can have positional attributes if the L<Regex|/language/regexes> had
capture-groups in it, which are just formed with parentheses.

    'abbbbbcdddddeffg' ~~ / a (b+) c (d+ef+) g /;
    say $/[0]; # ｢bbbbb｣
    say $/[1]; # ｢dddddeff｣

These can also be accessed by the shortcuts C<$0>, C<$1>, C<$2>, etc.

    say $0; # ｢bbbbb｣
    say $1; # ｢dddddeff｣

To get all of the positional attributes, any of C<$/.list>, C<@$/>, or
C<@()> can be used.

    say @().join; # bbbbbdddddeff

=head4 X«Named Attributes|variable,$<named>;variable,%()»

C<$/> can have named attributes if the L<Regex|/language/regexes> had named
capture-groups in it, or if the Regex called out to another Regex.

    'I.... see?' ~~ / \w+ $<punctuation>=[ <-[\w\s]>+ ] \s* $<final-word> = [ \w+ . ] /;
    say $/<punctuation>; # ｢....｣
    say $/<final-word>;  # ｢see?｣

These can also be accessed by the shortcut C«$<named>».

    say $<punctuation>; # ｢....｣
    say $<final-word>;  # ｢see?｣

To get all of the named attributes, any of C<$/.hash>, C<%$/>, or C<%()> can
be used.

    say %().join;       # "punctuation     ....final-word  see?"

=head3 The C<$!> Variable

C<$!> is the error variable. If a C<try> block or statement prefix catches
an exception, that exception is stored in C<$!>. If no exception was caught,
C<$!> is set to the C<Any> type object.

Note that C<CATCH> blocks I<do not> set C<$!>. Rather they set C<$_> inside
the block to the caught exception.

=head2 Compile-time variables

X<|$?FILE>X<|$?LINE>X<|::?CLASS>X<|&?ROUTINE>X<|&?BLOCK>X<|%?LANG>X<|%?RESOURCES>

=for table
    $?FILE         Which file am I in?
    $?LINE         Which line am I at?
    ::?CLASS       Which class am I in?
    &?ROUTINE      Which routine am I in?
    &?BLOCK        Which block am I in?
    %?LANG         What is the current set of interwoven languages?
    %?RESOURCES    The files associated with the "Distribution" of the current compilation unit.

=begin code :skip-test
for '.' {
    .Str.say when !.IO.d;
    .IO.dir()>>.&?BLOCK when .IO.d # lets recurse a little!
}
=end code

Other compile-time variables:

X<|$?PACKAGE>X<|$?MODULE>X<|$?CLASS>X<|$?ROLE>X<|$?GRAMMAR>X<|$?TABSTOP>X<|$?USAGE>X<|$?ENC>

=for table
    $?PACKAGE   Which package am I in?
    $?MODULE    Which module am I in?
    $?CLASS     Which class am I in? (as variable)
    $?ROLE      Which role am I in? (as variable)
    $?GRAMMAR   Which grammar am I in?
    $?TABSTOP   How many spaces is a tab in a heredoc or virtual margin?
    $?USAGE     The usage message generated from the signatures of MAIN subs.
    $?ENC       Default encoding of Str.encode/Buf.decode/various IO methods.

=head2 Dynamic variables

=comment There should be a better way get this table to be formatted
    properly, but if there is, Rakudo doesn't support it at the moment.

X<|$*ARGFILES>X<|@*ARGS>X<|$*IN>X<|$*OUT>X<|$*ERR>X<|%*ENV>X<|$*REPO>X<|$*TZ>
X<|$*CWD>X<|$*KERNEL>X<|$*DISTRO>X<|$*VM>X<|$*PERL>X<|$*PID>X<|$*PROGRAM-NAME>
X<|$*PROGRAM>X<|$*EXECUTABLE>X<|$*EXECUTABLE-NAME>X<|$*USER>X<|$*GROUP>X<|$*HOME>
X<|$*SPEC>X<|$*TMPDIR>X<|$*THREAD>X<|$*SCHEDULER>
=begin table
    $*ARGFILES        | Magic command-line input handle.
    ------------------+--------------------------------------------
    @*ARGS            | Arguments from the command line.
    ------------------+--------------------------------------------
    $*IN              | Standard input filehandle, AKA stdin
    ------------------+--------------------------------------------
    $*OUT             | Standard output filehandle, AKA stdout
    ------------------+--------------------------------------------
    $*ERR             | Standard error filehandle, AKA stderr
    ------------------+--------------------------------------------
    %*ENV             | Environment variables
    ------------------+--------------------------------------------
    $*REPO            | A variable holding information about modules installed/loaded
    ------------------+--------------------------------------------
    $*TZ              | The system's local timezone.
    ------------------+--------------------------------------------
    $*CWD             | The Current Working Directory.
    ------------------+--------------------------------------------
    $*KERNEL          | Which kernel am I running under?
    ------------------+--------------------------------------------
    $*DISTRO          | Which OS distribution am I running under?
    ------------------+--------------------------------------------
    $*VM              | Which virtual machine am I running under?
    ------------------+--------------------------------------------
    $*PERL            | Which Perl am I running under?
    ------------------+--------------------------------------------
    $*PID             | Process ID of the current process.
    ------------------+--------------------------------------------
    $*PROGRAM-NAME    | Path to the current executable as it was entered on the
                      | command line, or C<-e> if perl was invoked with the -e flag.
    ------------------+--------------------------------------------
    $*PROGRAM         | Location (in the form of an C<IO::Path> object) of the
                      | Perl program being executed.
    ------------------+--------------------------------------------
    $*EXECUTABLE      | Absolute path of the perl executable that is currently running.
    ------------------+--------------------------------------------
    $*EXECUTABLE-NAME | The name of the perl executable that is currently running.
                      | (e.g. perl6-p, perl6-m, Niecza.exe)
                      | Favor $*EXECUTABLE because it is not guaranteed that the perl
                      | executable is in PATH.
    ------------------+--------------------------------------------
    $*USER            | The user that is running the program. It is an object
                      | that evaluates to "username (uid)".  It will evaluate
                      | to the username only if treated as a string and the
                      | numeric user id if treated as a number.
    ------------------+--------------------------------------------
    $*GROUP           | The primary group of the user who is running the program.
                      | It is an object that evaluates to "groupname (gid)".
                      | It will evaluate to the groupname only if treated as a
                      | string and the numeric group id if treated as a number.
    ------------------+--------------------------------------------
    $*HOME            | An L<IO::Path> object representing the "home directory"
                      | of the user that is running the program.  If the
                      | "home directory" cannot be determined it will be L<Nil>
    ------------------+--------------------------------------------
    $*SPEC            | The appropriate L<IO::Spec> sub-class for the platform that
                      | the program is running on. For OS-specific code, simply use smartmatch:
                      | C<say "We are on Windows!" if $*SPEC ~~ IO::Spec::Win32>
    ------------------+--------------------------------------------
    $*TMPDIR          | An L<IO::Path> object representing the "system temporary directory"
    ------------------+--------------------------------------------
    $*TOLERANCE       | Used by the C<=~=> operator, and any operations that depend on it, to
                      | decide if two values are approximately equal. Defaults to 1e-15.
    ------------------+--------------------------------------------
    $*THREAD          | A L<Thread> object representing the currently executing thread.
    ------------------+--------------------------------------------
    $*SCHEDULER       | A L<ThreadPoolScheduler> object representing the current default
                      | scheduler. (see note below)
    ------------------+--------------------------------------------
=end table

Note on usage of $*SCHEDULER:

For the current Rakudo, by default this imposes a maximum of 16 threads on the methods
C<.hyper> and C<.race>. To change the maximum number of threads, either set the
environment variable RAKUDO_MAX_THREADS before running perl6 or create a scoped copy
with the default changed before using C<.hyper> or C<.race>:

    my $*SCHEDULER = ThreadPoolScheduler.new( max_threads => 64 );

This behavior is not tested in the spec tests and is subject to change.

=end pod
