Variables

Perl 6 Variables

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

Sigils

The sigil serves both as rough type constraint, and as an indicator as to whether the contents of the variable flatten in list context. See also the documentation in List.

Sigil Type constraint Default type Flattens Assignment
$ Mu (no type constraint) Any No item
& Callable Callable No item
@ Positional Array Yes list
% Associative Hash Yes list

Examples:

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

Item and List Assignment

There are two types of assignment, item assignment and list assignment. Both use the equal sign = as operator. The distinction whether an = means item or list assignment is based on the syntax of the left-hand side. (TODO: explain in detail, or do that in operators).

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 Array variables (@ sigil) empty themselves on list assignment, and then put all the values from the right-hand side into themselves. Contrary to item assignment, it means that the type of the variable on the left always stays Array, regardless of the type of the right-hand side.

Note that the item assignment has tighter precedence than list assignment, and also tighter than the comma. This means that:

my @array = my $num = 42, "str";

Assigns 42 to $num, and both 42 and "str" to @array. See operators for more details.

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 containers. That means that degrees and θ above actually directly represent Ints. To illustrate, just try assigning to one after you've defined it:

θ = 3; # Dies with the error "Cannot modify an immutable Int"

Twigils

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

Twigil Scope
* dynamic
! attribute (class member)
? compile-time "constant"
. 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

The * Sigil

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

    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();

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

The ! Sigil

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

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

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

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

The ? Sigil

Compile-time "constants" may be addressed via the ? 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".

Although they may not be changed at runtime, the user is allowed to (re)define such constants.

constant $?TABSTOP = 4; # this causes leading tabs in a heredoc or in a POD
                        # block's virtual margin to be counted as 4 spaces.

For a list of those special variables see Compile-time "constants".

The . Sigil

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

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

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

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

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

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

    SaySomething.a; # prints "a"

For more details on objects, classes and their attributes and methods see objects.

The < Sigil

The < twigil is just an alias for $/<...> where $/ is the match variable. For more information on the match variable see $/.

The ^ Sigil

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

for ^4 {
    say "$^seconds follows $^first";
}

which prints

1 follows 0
3 follows 2

has two formal parameters, namely $first and $second. Note that even though $^second appears before $^first in the code, $^first 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 $^a once you may refer to it using only $a thereafter.

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.

sub say-it    { say $^a; } # valid
sub say-it()  { say $^a; } # invalid
              { say $^a; } # valid
-> $x, $y, $x { say $^a; } # invalid

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

The : Sigil

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

See ^ for more details about placeholder variables.

The = Sigil

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

=begin Foo
...
=end Foo

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

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

Note that all those $=someBlockName support the Positional and the Associative role.

The ~ Sigil

The ~ twigil is for referring to sublanguages (called slangs). The following are useful:

$~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

You may supersede or augment those languages in your current lexical scope by doing

augment slang Regex {  # derive from $~Regex and then modify $~Regex
    token backslash:std<\Y> { YY };
}

or

supersede slang Regex { # completely substitute $~Regex
    ...
}

Special Variables

Often-Used Variables

# TODO: find a better heading

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

Variable Meaning
$_ topic variable
$/ regex match
$! exceptions

$_

$_ is the topic variable. It is the default parameter for blocks that do not have an explicit signature, so constructs like for @array { ... } and given $var { ... } binds to $_ 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

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

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

.say;                   # same as $_.say

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

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

This outputs:

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

$/

$/ is the match variable. It stores the result of each regex match, and usually contains objects of type Match.

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

The Grammar.parse method also sets the caller's $/ to the resulting Match object.

Other match variables are aliases to elements of $/:

$0          # same as $/[0]
$1          # same as $/[1]
$<named>    # same as $/<named>

$!

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

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

Compile-time "constants"

$?FILE Which file am I in?
$?LINE Which line am I at?
&?ROUTINE Which routine am I in?
&?BLOCK Which block am I in?
%?LANG What is the current set of interwoven languages?

Other compile-time constants:

$?SCOPE Which lexical scope am I in?
$?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.

Dynamic variables

$*ARGFILES Magic command-line input handle.
@*ARGS Arguments from the command line.
$*IN Standard input filehandle.
$*OUT Standard output filehandle.
$*ERR Standard error filehandle.
$*TZ The system's local timezone.
$*CWD The Current Working Directory.
$*KERNEL Which kernel am I compiled for?
$*DISTRO Which OS distribution am I compiling under
$*VM Which virtual machine am I compiling under
$*PERL Which Perl am I compiled for?
$*PID Process ID of the current process.
$*PROGRAM_NAME Path to the current executable as it was typed in on the command line, or C<-e> if perl was invoked with the -e flag.
$*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.