📘 Variables in Perl 6: Introspection

Due to the mechanism of introspection, it is easily possible to tell the type of the data living in a variable (a variable in Perl 6 is often referred as a container). To do that, call the predefined WHAT method on a variable. Even if it is a bare scalar, Perl 6 treats it internally as an object; thus, you may call some methods on it.

For scalars, the result depends on the real type of data residing in a variable. Here is an example (parentheses are part of the output):

my $scalar = 42;
my $hello-world = "Hello, World";

say $scalar.WHAT;      # (Int)
say $hello-world.WHAT; # (Str)

For those variables, whose names start with the sigils @ and %, the WHAT method returns the strings (Array) and (Hash).

Try with arrays:

my @list = 10, 20, 30;
my @squares = 0, 1, 4, 9, 16, 25;

say @list.WHAT;    # (Array)
say @squares.WHAT; # (Array)

Now with hashes:

my %hash = 'Language' => 'Perl';
my %capitals = 'France' => 'Paris';

say %hash.WHAT;     # (Hash)
say %capitals.WHAT; # (Hash)

The thing, which is returned after a WHAT call, is a so-called type object. In Perl 6, you should use the === operator to compare these objects.

For instance:

my $value = 42;
say "OK" if $value.WHAT === Int;

There’s an alternative way to check the type of an object residing in a container — the isa method. Call it on an object, passing the type name as an argument, and get the answer:

my $value = 42;
say "OK" if $value.isa(Int);

📘 Int type in Perl 6

The Int type is intended to host integer variables of arbitrary size. For example, no digit is lost in the following assignment:

my Int $x =
say $x;

A special syntax exists for defining integers with an other-than-10 base:

say :16<D0CF11E0>

Also, it is allowable to use the underscore character to separate digits so that big numbers can be read more easily:

my Int $x = 735_817_503_285_431_532;

Of course, when you print the value, all the underscores are gone.

On the Int object, you may call some other handy methods, for example, to convert a number to a character or to check if the integer in hand is prime (yes, is-prime is a built-in method!).

my Int $a = 65;
say $a.chr; # A

my Int $i = 17;
say $i.is-prime; # True

say 42.is-prime; # False

📘 Prefix operators ! and not in Perl 6

Prefix operators are those that come in front of their operands. Obviously, prefix operators require only one operand. In some cases, the symbol of the operation can be used as an infix operator when it stands between two operands.

! is the Boolean negation operator.

say !True;     # False
say !(1 == 2); # True

The not operator does the same but has lower precedence.

say not False; # True

📘 Frequently used special variables in Perl 6

The $_ variable is the one similar to that in Perl 5, which is the default variable containing the current context argument in some cases. Like any other variable, the $_ is an object in Perl 6, even in the simplest use cases. For example, the recent example .say for @*ARGS implicitly contains the $_.say call. The same effect would give $_.say(), .say(), or just .say.

This variable is used as a default variable in other cases, for instance, during the match against regular expressions:

for @*ARGS {
    .say if /\d/;

This short code is equivalent to the following, which uses the smartmatch (~~) operator:

for @*ARGS {
    $_.say if $_ ~~ /\d/;

The result of matching against a regular expression is available in the $/ variable. To get the matched string, you may call the $/.Str method. So as to get the substrings, which were caught during the match, indices are used: $/[2] or, in a simpler form, $2.

"Perl’s Birthday: 18 December 1987" ~~ 
    / (\d+) \s (\D+) \s (\d+) /;
say $/.Str;
say $/[$_] for 0..2;

Here, we are looking for a date. In this case, the date is defined as a sequence of digits \d+, a space \s, the word having no digits \D+, another space \s, and some more digits \d+. If the match succeeded, the $/.Str slot contains the whole date, while the $/[0], $/[1], and $/[2] keep their parts (the small square corner brackets are part of the output to indicate the Match object, see Chapter 6):

18 December 1987

Finally, the $! variable will contain an error message, for example, the one that occurred within a try block, or the one that happened while opening a file:

try {
    say 42/0;
say $! if $!;

If you remove the last line in this programme, nothing will be printed. This is because the try block masks any error output. Remove the try, and the error message reappears (the programme, itself, is terminated).