

"The most basic building blocks of a programming language are it's nouns, the chunks of data that get sucked in, pushed around, altered in various ways, and spat out to some new location." -- Allison Randal

Variable Types


%hash{'ba'} ######### $hash{'ba'} in Perl 5
%hash{'ba','da','bim'} ### @hash{'ba','da','bim'} in Perl 5


The fourth namespace is for subroutines and similar, even if you don't usually think of them as variables. It's sigil & is used to refer to subroutines without calling them.

All special namespaces from Perl 5 (often marked with special syntax), like tokens (__PACKAGE__), formats, file or dir handles, or builtins are now regular variables or routines.

Because all variables contain objects, they have methods. In fact, all operators, including square or curly bracket subscripts, are just methods of an object with a fancy name.

The primary sigil can be followed by a secondary sigil, called a twigil, which indicates a special scope for that variable.


This type stores one value, usually a reference to something: a value of a data type, a code object, an object or a compound of values like a pair, junction, array, hash or capture. The scalar context is now called item context, hence the scalar instruction from Perl 5 was renamed to item.

$CHAPTER = 3; # first comment!
$bin = 0b11; # same value in binary format
$pi = 3.14159_26535_89793; # the underscores just ease reading
# double quoted string, does eval $pi to it's content
$text = " What is $pi?";
$text = q:to'EOT'; # heredoc string

    handy for multiline text
    like HTML templates or email

$handle = open $file_name; # file handle
# an object from a class with a nested namespace
$object =;
$arrayref = [0,1,1,2,3,5,8,13,21]; # an array stored as a single item
# a hash stored as a single item
            'damian'=>'larrys evil henchman'};
# pointing to a callable
$coderef = sub { do_something_completely_diffenent(@_) };

(For info on some of those terms: comment, binary format, the underscores ease reading, scientific notation, single-quoted string, double-quoted string, heredoc string, file handle, class, junction, list of values, hash, callable.)

Unlike Perl 5, references are automatically dereferenced to a fitting context. So you could use these $arrayrefs and $hashrefs similarly to an array or hash, making $ the universal variable prefix, pretty much like in PHP. The primary difference is that $ prefixed lists are not flattened in lists.

my $a = (1, 2, 3);
my @a = 1, 2, 3;
for $a { }          # just one iteration
for @a { }          # three iterations

Scalar Methods

my $chapter = 3;
undefine $chapter;
defined $a; # false, returns 0


An array is an ordered and indexed list of scalars. If not specified otherwise, they can be changed, expanded and shortened anytime and used as a list, stack, queue and much more. As in Haskell, lists are processed lazily, which means: the compiler looks only at the part it currently needs. This way Perl 6 can handle infinite lists or do computation on lists that have not been computed yet. The lazy command enforces this and the eager command forces all values to be computed.

The list context is forced with a @() operator or list() command. That's not autoflattening like in Perl 5 (automatically convert a List of Lists into one List). If you still want that, say flat(). Or say lol() to explicitly prevent autoflattening.

@primes = <2 3 5 7 11 13 17 19 23>; # ditto, <> is the new qw()
$primes = (2,3,5,7,11,13,17,19,23); # same array object just sits in $primes, $primes[0] is 2
$primes = item @primes;             # same thing, more explicit
$primes = 2,;                       # just 2, first element of the Parcel
@primes = 2;                        # array with one element
@primes = [2,3,5,7,11,13,17,19,23]; # array with one element (List of Lists - LoL)
@dev    = {'dan' => 'parrot'};      # array with one element (a Hash)
@list   = lol @data;                # no change

Array Slices

@primes                       # all values as list
@primes.values                # same thing
@primes.keys                  # list of all indices
"@primes[]"                   # insert all values in a string, uses [] to distinguish from mail adresses
@copy = @data;                # shallow copy of the array

Array Methods


? @rray;              # boolean context, Bool::True if array has any value in it, even if it's a 0

@rray.elems;          # same as + @rray
@rray.end;            # number of the last element, equal to @rray.elems-1;            # same ~ @rray
@rray.unshift;        # prepend one value to the array
@rray.shift;          # remove the first value and return it
@rray.push;           # add one value on the end
@rray.splice($pos,$n);# starting at $pos remove $n values and replace them with values that follow those two parameters
@rray.delete(@ind); # delete all cells with indices in @ind
@rray.exists(@ind); # Bool::True if all indices of @ind have a value (can be 0 or '')
@rray.reverse;        # all elements in reversed order
# position if $n is positive, if negative the other way around

@rray.sort($coderef); # returns a list sorted by a user-defined criteria, default is alphanumerical sorting
@rray.min;            # numerical smallest value of that array
@rray.max;            # numerical largest value of that array
$a,$b= @rray.minmax;  # both at once, like in .sort,  .min, or .max, a sorting algorithm can be provided$coderef);  # high oder map function, runs $coderef with every value as $_ and returns the list or results
@rray.categorize($cr);# kind of classify, but closure can have no (Nil) or several results, so a key can have a list of values



In Perl 6 a Hash is an unordered list of Pairs. A Pair is a single key => value association and appears in many places of the language syntax. A hash allows lookup of values by key using {} or <> syntax.


Hash Slices

@values = %dev<key1 key2>;

%dev   .<dukeleto>;        # error
%dev\ .{'patrick'};        # works too, "long dot style", because it's an object in truth

Hash Methods


$table = %dev;             # same as ~ %dev
@pairs = %dev;             # list of all containing pairs
%dev.pairs                 # same thing in all context
%dev.elems                 # same as + %dev or + %dev.pairs
%dev.keys                  # returns a list of all keys
%dev.values                # list of all values
%dev.invert                # reverse all key => value relations


Internally subroutines, methods and alike are variables with the sigil & and stored in a fourth namespace. Unlike Perl 5, all subroutines can be overwritten or augmented with user defined routines. Of course scalars can also contain routines.

function();                      # call/run it


Data Types

In contrast to variable types (container types) every value has a type too. These are organized internally as classes or roles and can be categorized into 3 piles: the undefined, immutable, and the mutable types.

You can assign one of these types to scalar, array, or hash variables, which enforces the contents to be that type.

my Int $a;
my Int @a;  # array of Int


Pairs are new and their syntax is used nearly everywhere in the language where there is an association between a name and a value.

$pair.key                     # returns 'jakub'
$pair.value                   # returns 'helena'
$pair.isa(Pair)               # Bool::True




Captures are also a new type, which holds the parameters a routine gets. Because Perl now knows both positional and named parameters, it is a mixture of a list and array.

$cap = \(@a,$s,%h,'a'=>3);    # creating a capture, "\" was free since there are no references anymore
|$cap                         # flatten into argument list (without |, it will pass it as a single value)
||$cap                        # flatten into semicolon list (meant for variadic functions that take list of lists)

One important difference between a capture and a compound structure of lists and hashes: While assignments with = will copy the complete content of the named variables, this is not so in the case of a capture. When I change sinthelastexample, thecontentofcap changes too, because when parameters to a routine are variables, they are also interpolated in the moment the routine is called, not when it's defined.

Properties and Traits






scope declarator, scopes

my $var;
our $var;



Assignment and Binding



my @original = [1,2],[3,4];


Since every variable in Perl 6 is a reference, programmers can use binding to get 2 variables that point to the same memory location.

$original = 5;
$original = 3;
say $mirror;                # prints 3
$original =:= $mirror       # true, because they're bound together
$original === $mirror       # also true, because content and type are equal

Special Variables

are listed in Index B. To understand their secondary sigil click here.
