Note: Some references to Perl 6 still apply in the Raku infrastructure, but the changeover from the name Perl 6 to Raku is ongoing and the references will be changed as soon as they become operative in the latest release of Raku (and some volunteer changes them!).

This page attempts to provide a fast-path to the changes in syntax and semantics from Perl to Raku. Whatever worked in Perl and must be written differently in Raku, should be listed here (whereas many new Raku features and idioms need not).

Hence this should not be mistaken for a beginner tutorial or a promotional overview of Raku; it is intended as a technical reference for Raku learners with a strong Perl background and for anyone porting Perl code to Raku (though note that #Automated translation might be more convenient).

A note on semantics; when we say "now" in this document, we mostly just mean "now that you are trying out Raku." We don't mean to imply that Perl is now suddenly obsolete. Quite the contrary, most of us love Perl, and we expect Perl to continue in use for a good many years. Indeed, one of our more important goals has been to make interaction between Perl and Raku run smoothly. However, we do also like the design decisions in Raku, which are certainly newer and arguably better integrated than many of the historical design decisions in Perl. So many of us do hope that over the next decade or two, Raku will become the more dominant language. If you want to take "now" in that future sense, that's okay too. But we're not at all interested in the either/or thinking that leads to fights.

CPAN

See https://modules.raku.org/.

If the module that you were using has not been converted to Raku, and no alternative is listed in this document, then its use under Raku may not have been addressed yet.

The Inline::Perl5 project makes it possible to use Perl modules directly from Raku code by using an embedded instance of the perl interpreter to run Perl code.

This is as simple as:

# the :from<Perl5> makes Raku load Inline::Perl5 first (if installed) 
# and then load the Scalar::Util module from Perl 
use Scalar::Util:from<Perl5> <looks_like_number>;
say looks_like_number "foo";   # 0 
say looks_like_number "42";    # 1 

A number of Perl modules have been ported to Raku, trying to maintain the API of these modules as much as possible, as part of the CPAN Butterfly Plan. These can be found at https://modules.raku.org/t/CPAN5.

Many Perl built-in functions (about a 100 so far) have been ported to Raku with the same semantics. Think about the shift function in Perl having magic shifting from @_ or @ARGV by default, depending on context. These can be found at https://modules.raku.org/t/Perl5 as separately loadable modules, and in the P5built-ins bundle to get them all at once.

Syntax

There are a few differences in syntax between the two languages, starting with how identifiers are defined.

Identifiers

Raku allows the use of dashes (-), underscores (_), apostrophes ('), and alphanumerics in identifiers:

sub test-doesn't-hang { ... }
my $ความสงบ = 42;
my \Δ = 72; say 72 - Δ;

-> Method calls

If you've read any Raku code at all, it's immediately obvious that method call syntax now uses a dot instead of an arrow:

$person->name  # Perl 

$person.name   # Raku 

The dot notation is both easier to type and more of an industry standard. But we also wanted to steal the arrow for something else. (Concatenation is now done with the ~ operator, if you were wondering.)

To call a method whose name is not known until runtime:

$object->$methodname(@args);  # Perl 

$object."$methodname"(@args); # Raku 

If you leave out the quotes, then Raku expects $methodname to contain a Method object rather than the simple string name of the method. Yes, everything in Raku can be considered an object.

Whitespace

Perl allows a surprising amount of flexibility in the use of whitespace, even with strict mode and warnings turned on:

# unidiomatic but valid Perl 
say"Hello ".ucfirst  ($people
    [$ i]
    ->
    name)."!"if$greeted[$i]<1;

Raku also endorses programmer freedom and creativity, but balanced syntactic flexibility against its design goal of having a consistent, deterministic, extensible grammar that supports single-pass parsing and helpful error messages, integrates features like custom operators cleanly, and doesn't lead programmers to accidentally misstate their intent. Also, the practice of "code golf" is slightly de-emphasized; Raku is designed to be more concise in concepts than in keystrokes.

As a result, there are various places in the syntax where whitespace is optional in Perl, but is either mandatory or forbidden in Raku. Many of those restrictions are unlikely to concern much real-life Perl code (e.g., whitespace being disallowed between the sigil and name of a variable), but there are a few that will unfortunately conflict with some Perl hackers' habitual coding styles:

• No space allowed before the opening parenthesis of an argument list.

  substr ($s, 4, 1); # Perl (in Raku this would try to pass a single 
                         #         argument of type List to substr) 

  substr($s, 4, 1);  # Raku 
  substr $s, 4, 1;   # Raku - alternative parentheses-less style 

  Should this really be a problem for you, then you might want to have a look at the Slang::Tuxic module in the Raku ecosystem: it changes the grammar of Raku in such a way that you can have a space before the opening parenthesis of an argument list.

• Space is required immediately after keywords

  my($alpha, $beta);          # Perl, tries to call my() sub in Raku 

  my ($alpha, $beta);         # Raku 

  if($a < 0) { ... }          # Perl, dies in Raku 

  if ($a < 0) { ... }         # Raku 
  if $a < 0 { ... }           # Raku, more idiomatic 

  while($x-- > 5) { ... }     # Perl, dies in Raku 

  while ($x-- > 5) { ... }    # Raku 
  while $x-- > 5 { ... }      # Raku, more idiomatic 

• No space allowed after a prefix operator, or before a postfix/postcircumfix operator (including array/hash subscripts).

  $seen {$_} ++; # Perl 

  %seen{$_}++;   # Raku 

• Space required before an infix operator if it would conflict with an existing postfix/postcircumfix operator.

  $n<1;   # Perl (in Raku this would conflict with postcircumfix < >) 

  $n < 1; # Raku 

• However, whitespace is allowed before the period of a method call!

  # Perl 
  my @books = $xml
    ->parse_file($file)          # some comment 
    ->findnodes("/library/book");

  # Raku 
  my @books = $xml
    .parse-file($file)           # some comment 
    .findnodes("/library/book");

However, note that you can use unspace to add whitespace in Raku code in places where it is otherwise not allowed.

See also other lexical conventions in the syntax page.

Sigils

In Perl, arrays and hashes use changing sigils depending on how they are being accessed. In Raku the sigils are invariant, no matter how the variable is being used - you can think of them as part of the variable's name.

$ Scalar

The $ sigil is now always used with "scalar" variables (e.g. $name), and no longer for array indexing and Hash indexing. That is, you can still use $x[1] and $x{"foo"}, but it will act on $x, with no effect on a similarly named @x or %x. Those would now be accessed with @x[1] and %x{"foo"}.

@ Array

The @ sigil is now always used with "array" variables (e.g. @months, @months[2], @months[2, 4]), and no longer for Hash indexing.

% Hash

The % sigil is now always used with "hash" variables (e.g. %calories, %calories<apple>, %calories<pear plum>), and no longer for array indexing.

& Sub

The & sigil is now used consistently (and without the help of a backslash) to refer to the function object of a named subroutine/operator without invoking it, i.e. to use the name as a "noun" instead of a "verb":

my $sub = \&foo; # Perl 

my $sub = &foo;  # Raku 

callback => sub { say @_ }  # Perl - can't pass built-in sub directly 

callback => &say            # Raku - & gives "noun" form of any sub 

Since Raku does not allow adding/removing symbols in a lexical scope once it has finished compiling, there is no equivalent to Perl's undef &foo;, and the closest equivalent to Perl's defined &foo would be defined ::('&foo') (which uses the "dynamic symbol lookup" syntax). However, you can declare a mutable named subroutine with my &foo; and then change its meaning at runtime by assigning to &foo.

In Perl, the ampersand sigil can additionally be used to call subroutines in special ways with subtly different behavior compared to normal sub calls. In Raku those special forms are no longer available:

• &foo(...) for circumventing a function prototype

  In Raku there are no prototypes, and it no longer makes a difference whether you, say, pass a literal code block or a variable holding a code object as an argument:

  # Perl: 
  first_index { $_ > 5 } @values;
  &first_index($coderef, @values); # (disabling the prototype that parses a 
                                       # literal block as the first argument) 

  # Raku: 
  first { $_ > 5 }, @values, :k;   # the :k makes first return an index 
  first $coderef, @values, :k;

• &foo; and goto &foo; for re-using the caller's argument list / replacing the caller in the call stack. Raku can use either callsame for re-dispatching or nextsame and nextwith, which have no exact equivalent in Perl.

  sub foo { say "before"; &bar;     say "after" } # Perl 

  sub foo { say "before"; bar(|@_); say "after" } # Raku - have to be explicit 

  sub foo { say "before"; goto &bar } # Perl 

  proto foo (|) {*};
  multi foo ( Any $n ) {
      say "Any"; say $n;
  };
  multi foo ( Int $n ) {
      say "Int"; callsame;
  };
  foo(3); # /language/functions#index-entry-dispatch_callsame 

* Glob

In Perl, the * sigil referred to the GLOB structure that Perl uses to store non-lexical variables, filehandles, subs, and formats.

^[1]

You are most likely to encounter a GLOB in code written on an early Perl version that does not support lexical filehandles, when a filehandle needed to be passed into a sub.

# Perl - ancient method 
sub read_2 {
    local (*H) = @_;
    return scalar(<H>), scalar(<H>);
}
open FILE, '<', $path or die;
my ($line1, $line2) = read_2(*FILE);

You should refactor your Perl code to remove the need for the GLOB, before translating into Raku.

# Perl - modern use of lexical filehandles 
sub read_2 {
    my ($fh) = @_;
    return scalar(<$fh>), scalar(<$fh>);
}
open my $in_file, '<', $path or die;
my ($line1, $line2) = read_2($in_file);

And here's just one possible Raku translation:

# Raku 
sub read-n($fh, $n) {
    return $fh.get xx $n;
}
my $in-file = open $path or die;
my ($line1, $line2) = read-n($in-file, 2);

[] Array indexing/slicing

Index and slice operations on arrays no longer inflect the variable's sigil, and adverbs can be used to control the type of slice:

• Indexing

  say $months[2]; # Perl 

  say @months[2]; # Raku - @ instead of $ 

• Value-slicing

  say join ',', @months[6, 8..11]; # Perl and Raku 

• Key/value-slicing

  say join ',', %months[6, 8..11];    # Perl 

  say join ',', @months[6, 8..11]:kv; # Raku - @ instead of %; use :kv adverb 

Also note that the subscripting square brackets are now a normal postcircumfix operator rather than a special syntactic form, and thus checking for existence of elements and unsetting elements is done with adverbs.

An array's biggest index is now available with the .end method:

say $#item;    # Perl 

say @item.end; # Raku 

{} Hash indexing/slicing

Index and slice operations on hashes no longer inflect the variable's sigil, and adverbs can be used to control the type of slice. Also, single-word subscripts are no longer magically autoquoted inside the curly braces; instead, the new angle brackets version is available which always autoquotes its contents (using the same rules as the qw// quoting construct):

• Indexing

  say $calories{"apple"}; # Perl 

  say %calories{"apple"}; # Raku - % instead of $ 

  say $calories{apple};   # Perl 

  say %calories<apple>;   # Raku - angle brackets; % instead of $ 
  say %calories«"$key"»;  # Raku - double angles interpolate as a list of Str 

• Value-slicing

  say join ',', @calories{'pear', 'plum'}; # Perl 

  say join ',', %calories{'pear', 'plum'}; # Raku - % instead of @ 
  say join ',', %calories<pear plum>;      # Raku (prettier version) 
  my $keys = 'pear plum';
  say join ',', %calories«$keys»;          # Raku the split is done after interpolation 

• Key/value-slicing

  say join ',', %calories{'pear', 'plum'};    # Perl 

  say join ',', %calories{'pear', 'plum'}:kv; # Raku - use :kv adverb 
  say join ',', %calories<pear plum>:kv;      # Raku (prettier version) 

Also note that the subscripting curly braces are now a normal postcircumfix operator rather than a special syntactic form, and thus checking for existence of elements and unsetting elements is done with adverbs.

Creating references and using them

In Perl, references to anonymous arrays and hashes and subs are returned during their creation. References to existing named variables and subs were generated with the \ operator. the "referencing/dereferencing" metaphor does not map cleanly to the actual Raku container system, so we will have to focus on the intent of the reference operators instead of the actual syntax.

my $aref = \@aaa  ; # Perl 

This might be used for passing a reference to a routine, for instance. But in Raku, the (single) underlying object is passed (which you could consider to be a sort of pass by reference).

my @array = 4,8,15;
{ $_[0] = 66 }(@array);   # run the block with @array aliased to $_ 
say @array; #  OUTPUT: «[66 8 15]␤» 

The underlying Array object of @array is passed, and its first value modified inside the declared routine.

In Perl, the syntax for dereferencing an entire reference is the type-sigil and curly braces, with the reference inside the curly braces. In Raku, this concept simply does not apply, since the reference metaphor does not really apply.

In Perl, the arrow operator, -> , is used for single access to a composite's reference or to call a sub through its reference. In Raku, the dot operator . is always used for object methods, but the rest does not really apply.

# Perl 
    say $arrayref->[7];
    say $hashref->{'fire bad'};
    say $subref->($foo, $bar);

In relatively recent versions of Perl (5.20 and later), a new feature allows the use of the arrow operator for dereferencing: see Postfix Dereferencing. This can be used to create an array from a scalar. This operation is usually called decont, as in decontainerization, and in Raku methods such as .list and .hash are used:

# Perl 5.20 
    use experimental qw< postderef >;
    my @a = $arrayref->@*;
    my %h = $hashref->%*;
    my @slice = $arrayref->@[3..7];

# Raku 
    my @a = $contains-an-array.list;        # or @($arrayref) 
    my %h = $contains-a-hash.hash;          # or %($hashref) 

The "Zen" slice does the same thing:

# Raku 
    my @a = $contains-an-array[];
    my %h = $contains-a-hash{};

See the "Containers" section of the documentation for more information.

Operators

See the documentation for operators for full details on all operators.

Unchanged:

• + Numeric Addition

• - Numeric Subtraction

• * Numeric Multiplication

• / Numeric Division

• % Numeric Modulus

• ** Numeric Exponentiation

• ++ Numeric Increment

• -- Numeric Decrement

• ! && || ^ Booleans, high-precedence

• not and or xor Booleans, low-precedence

• == != < > <= >= Numeric comparisons

• eq ne lt gt le ge String comparisons

, (Comma) List separator

Unchanged, but note that in order to flatten an array variable to a list (in order to append or prefix more items) one should use the | operator (see also Slip). For instance:

my @numbers = 100, 200, 300;
my @more_numbers = 500, 600, 700;
my @all_numbers = |@numbers, 400, |@more_numbers;

That way one can concatenate arrays.

Note that one does not need to have any parentheses on the right-hand side: the list separator takes care of creating the list, not the parentheses!

<=> cmp Three-way comparisons

In Perl, these operators returned -1, 0, or 1. In Raku, they return Order::Less, Order::Same, or Order::More.

cmp is now named leg; it forces string context for the comparison.

<=> still forces numeric context.

cmp in Raku does either <=> or leg, depending on the existing type of its arguments.

~~ Smartmatch operator

While the operator has not changed, the rules for what exactly is matched depend on the types of both arguments, and those rules are far from identical in Perl and Raku. See ~~ and the smartmatch operator

& | ^ String bitwise ops

& | ^ Numeric bitwise ops

& | ^ Boolean ops

In Perl, & | ^ were invoked according to the contents of their arguments. For example, 31 | 33 returns a different result than "31" | "33".

In Raku, those single-character ops have been removed, and replaced by two-character ops which coerce their arguments to the needed context.

# Infix ops (two arguments; one on each side of the op) 
+&  +|  +^  And Or Xor: Numeric
~&  ~|  ~^  And Or Xor: String
?&  ?|  ?^  And Or Xor: Boolean
 
# Prefix ops (one argument, after the op) 
+^  Not: Numeric
~^  Not: String
?^  Not: Boolean (same as the ! op)

<< >> Numeric shift left|right ops

Replaced by +< and +> .

say 42 << 3; # Perl 

say 42 +< 3; # Raku 

=> Fat comma

In Perl, => acted just like a comma, but also quoted its left-hand side.

In Raku, => is the Pair operator, which is quite different in principle, but works the same in many situations.

If you were using => in hash initialization, or in passing arguments to a sub that expects a hashref, then the usage is likely identical.

sub get_the_loot { ... }; # Raku stub 
# Works in Perl and Raku 
my %hash = ( AAA => 1, BBB => 2 );
get_the_loot( 'diamonds', { quiet_level => 'very', quantity => 9 }); # Note the curly braces

If you were using => as a convenient shortcut to not have to quote part of a list, or in passing arguments to a sub that expects a flat list of KEY, VALUE, KEY, VALUE, then continuing to use => may break your code. The easiest workaround is to change that fat arrow to a regular comma, and manually add quotes to its left-hand side. Or, you can change the sub's API to slurp a hash. A better long-term solution is to change the sub's API to expect Pairs; however, this requires you to change all sub calls at once.

# Perl 
sub get_the_loot {
    my $loot = shift;
    my %options = @_;
    # ... 
}
# Note: no curly braces in this sub call 
get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 );

# Raku, original API 
sub get_the_loot( $loot, *%options ) { # The * means to slurp everything 
    ...
}
get_the_loot( 'diamonds', quiet_level => 'very', quantity => 9 ); # Note: no curly braces in this API 
 
# Raku, API changed to specify valid options 
# The colon before the sigils means to expect a named variable, 
# with the key having the same name as the variable. 
sub get_the_loot( $loot, :$quiet_level?, :$quantity = 1 ) {
    # This version will check for unexpected arguments! 
    ...
}
get_the_loot( 'diamonds', quietlevel => 'very' ); # Throws error for misspelled parameter name 

? : Ternary operator

The conditional operator ? : has been replaced by ?? !!:

my $result = $score > 60 ?  'Pass' :  'Fail'; # Perl 

my $result = $score > 60 ?? 'Pass' !! 'Fail'; # Raku 

. (Dot) String concatenation

Replaced by the tilde.

Mnemonic: think of "stitching" together the two strings with needle and thread.

$food = 'grape' . 'fruit'; # Perl 

$food = 'grape' ~ 'fruit'; # Raku 

x List repetition or string repetition operator

In Perl, x is the repetition operator, which behaves differently in scalar or list contexts:

• in scalar context x repeats a string;

• in list context x repeats a list, but only if the left argument is parenthesized!

Raku uses two different repetition operators to achieve the above:

• x for string repetitions (in any context);

• xx for list repetitions (in any context).

Mnemonic: x is short and xx is long, so xx is the one used for lists.

# Perl 
    print '-' x 80;             # Print row of dashes 
    @ones = (1) x 80;           # A list of 80 1's 
    @ones = (5) x @ones;        # Set all elements to 5 

# Raku 
    print '-' x 80;             # Unchanged 
    @ones = 1 xx 80;            # Parentheses no longer needed 
    @ones = 5 xx @ones;         # Parentheses no longer needed 

.. ... Two dots or three dots, range op or flipflop op

In Perl, .. was one of two completely different operators, depending on context.

In list context, .. is the familiar range operator. Ranges from Perl code should not require translation.

In scalar context, .. and ... were the little-known Flipflop operators. They have been replaced by ff and fff.

String interpolation

In Perl, "${foo}s" deliminates a variable name from regular text next to it. In Raku, simply extend the curly braces to include the sigil too: "{$foo}s". This is in fact a very simple case of interpolating an expression.

Compound statements

These statements include conditionals and loops.

Conditionals

if elsif else unless

Mostly unchanged; parentheses around the conditions are now optional, but if used, must not immediately follow the keyword, or it will be taken as a function call instead. Binding the conditional expression to a variable is also a little different:

if (my $x = dostuff()) {...}  # Perl 

if dostuff() -> $x {...}      # Raku 

(You can still use the my form in Raku, but it will scope to the outer block, not the inner.)

The unless conditional only allows for a single block in Raku; it does not allow for an elsif or else clause.

given-when

The given-when construct is like a chain of if-elsif-else statements or like the switch-case construct C, for example. It has the general structure:

given EXPR {
    when EXPR { ... }
    when EXPR { ... }
    default { ... }
}

In its simplest form, the construct is as follows:

given $value {                   # assigns $_ 
    when "a match" {             # if $_ ~~ "a match" 
        # do-something(); 
    }
    when "another match" {       # elsif $_ ~~ "another match" 
        # do-something-else(); 
    }
    default {                    # else 
        # do-default-thing(); 
    }
}

This is simple in the sense that a scalar value is matched in the when statements against $_, which was set by the given. More generally, the matches are actually smartmatches on $_ such that lookups using more complex entities such as regexps can be used instead of scalar values.

See also the warnings on the smartmatch op above.

Loops

while until

Mostly unchanged; parentheses around the conditions are now optional, but if used, must not immediately follow the keyword, or it will be taken as a function call instead. Binding the conditional expression to a variable is also a little different:

while (my $x = dostuff()) {...}  # Perl 

while dostuff() -> $x {...}      # Raku 

(You can still use the my form in Raku, but it will scope to the outer block, not the inner.)

Note that reading line-by-line from a filehandle has changed.

In Perl, it was done in a while loop using the diamond operator. Using for instead of while was a common bug, because the for causes the whole file to be sucked in at once, swamping the program's memory usage.

In Raku, for statement is lazy, so we read line-by-line in a for loop using the .lines method.

while (<IN_FH>)  { } # Perl 

for $IN_FH.lines { } # Raku 

Also note that in Raku, lines are chomped by default.

do while/until

# Perl 
do {
    ...
} while $x < 10;
 
do {
    ...
} until $x >= 10;

The construct is still present, but do was renamed to repeat, to better represent what the construct does:

# Raku 
repeat {
    ...
} while $x < 10;
 
repeat {
    ...
} until $x >= 10;

Note that Perl's unadorned do block ('do {...}') behaves the same when used in Raku.

for foreach

Note first this common misunderstanding about the for and foreach keywords: Many programmers think that they distinguish between the C-style three-expression form and the list-iterator form; they do not! In fact, the keywords are interchangeable; the Perl compiler looks for the semicolons within the parentheses to determine which type of loop to parse.

The C-style three-factor form now uses the loop keyword, and is otherwise unchanged. The parentheses are still required.

for  ( my $i = 1; $i <= 10; $i++ ) { ... } # Perl 

loop ( my $i = 1; $i <= 10; $i++ ) { ... } # Raku 

The loop-iterator form is named for in Raku and foreach is no longer a keyword. The for loop has the following rules:

• parentheses are optional;

• the iteration variable, if any, has been moved from appearing before the list, to appearing after the list and an added arrow operator;

• the iteration variable is now always lexical: my is neither needed nor allowed;

• the iteration variable is a read-only alias to the current list element (in Perl it is a read-write alias!). If a read-write alias is required, change the -> before the iteration variable to a <->. When translating from Perl, inspect the use of the loop variable to decide if read-write is needed.

for my $car (@cars)  {...} # Perl; read-write 

for @cars  -> $car   {...} # Raku; read-only 
for @cars <-> $car   {...} # Raku; read-write 

In Raku and unlike Perl, the default topic $_ will behave in the same way, becoming read-only when used as a topic variable.

for (@cars)      {...} # Perl; $_ is read-write 

for @cars        {...} # Raku; $_ is read-only 
for @cars <-> $_ {...} # Raku; $_ is also read-write 

It is possible to consume more than one element of the list in each iteration simply specifying more than one variable after the arrow operator:

my @array = 1..10;
for @array -> $first, $second {
    say "First is $first, second is $second";
}

For cases in which the number of elements iterated over isn't a multiple of the number of variables after the arrow operator, you can provide variables with default values:

my @array = 1..9;
for @array -> $first, $second = 0 {
    say "First is $first, second is $second";
}

each

Here is the equivalent to Perl’s while…each(%hash) or while…each(@array) (i.e., iterating over both the keys/indices and values of a data structure) in Raku:

while (my ($i, $v) = each(@array)) { ... } # Perl 

for @array.kv -> $i, $v { ... } # Raku 

while (my ($k, $v) = each(%hash)) { ... } # Perl 

for %hash.kv -> $k, $v { ... } # Raku 

Flow control statements

Unchanged:

• next

• last

• redo

continue

There is no longer a continue block. Instead, use a NEXT block (phaser) within the body of the loop.

# Perl 
    my $str = '';
    for (1..5) {
        next if $_ % 2 == 1;
        $str .= $_;
    }
    continue {
        $str .= ':'
    }

# Raku 
    my $str = '';
    for 1..5 {
        next if $_ % 2 == 1;
        $str ~= $_;
        NEXT {
            $str ~= ':'
        }
    }

Please note that phasers don't really need a block. This can be very handy when you don't want another scope:

# Raku 
    my $str = '';
    for 1..5 {
        next if $_ % 2 == 1;
        $str ~= $_;
        NEXT $str ~= ':';
    }

Functions

Built-ins with bare blocks

Builtins that previously accepted a bare block followed, without a comma, by the remainder of the arguments will now require a comma between the block and the arguments e.g. map, grep, etc.

my @results = grep { $_ eq "bars" } @foo; # Perl 

my @results = grep { $_ eq "bars" }, @foo; # Raku 

delete

Turned into an adverb of the Hash indexing and array indexing operators.

my $deleted_value = delete $hash{$key};  # Perl 

my $deleted_value = %hash{$key}:delete;  # Raku - use :delete adverb 

my $deleted_value = delete $array[$i];  # Perl 

my $deleted_value = @array[$i]:delete;  # Raku - use :delete adverb 

exists

Turned into an adverb of the Hash indexing and array indexing operators.

say "element exists" if exists $hash{$key};  # Perl 

say "element exists" if %hash{$key}:exists;  # Raku - use :exists adverb 

say "element exists" if exists $array[$i];  # Perl 

say "element exists" if @array[$i]:exists;  # Raku - use :exists adverb 

Regular expressions ( regex / regexp )

Change =~ and !~ to ~~ and !~~ .

In Perl, matches and substitutions are done against a variable using the =~ regexp-binding op.

In Raku, the ~~ smartmatch op is used instead.

next if $line  =~ /static/  ; # Perl 

next if $line  ~~ /static/  ; # Raku 

next if $line  !~ /dynamic/ ; # Perl 

next if $line !~~ /dynamic/ ; # Raku 

$line =~ s/abc/123/;          # Perl 

$line ~~ s/abc/123/;          # Raku 

Alternately, the new .match and .subst methods can be used. Note that .subst is non-mutating.

Captures start with 0, not 1

/(.+)/ and print $1; # Per 

/(.+)/ and print $0; # Raku 

Move modifiers

Move any modifiers from the end of the regex to the beginning. This may require you to add the optional m on a plain match like /abc/.

next if $line =~    /static/i ; # Perl 

next if $line ~~ m:i/static/  ; # Raku 

Add :P5 or :Perl5 adverb

If the actual regex is complex, you may want to use it as-is (with some exceptions), by adding the P5 modifier.

next if $line =~    m/[aeiou]/   ; # Perl 

next if $line ~~ m:P5/[aeiou]/   ; # Raku, using P5 modifier 
next if $line ~~ m/  <[aeiou]> / ; # Raku, native new syntax 

If the Perl regex has any modifiers, move them from the end and place them after the P5 modifier. Each modifier will have to be separated from any others by a colon. For example:

my $a = "abcabc";
my $b = $a;
$a =~ s/abcaBc//gi;  # Perl 5 
$a ~~ s:P5:g:i/ab//; # Raku, using P5 modifier 
$b ~~ s:gi/ab//;     # Raku, native new syntax 
say $a;
say $b;

Another accommodation required with the P5 syntax is to replace curly braces with square brackets when specifying Unicode in the expression:

next if $line =~ m/\x{2043};
next if $line ~~ m:P5/\x[2043]/;
next if $line ~~ /\x[2043]/;

Please note that the Perl regular expression syntax dates from many years ago and may lack features that have been added since the beginning of the Raku project. Two such features not yet implemented in Raku for the P5 syntax are the Perl Unicode property matchers \p{} and \P{}.

Special matchers generally fall under the <> syntax

There are many cases of special matching syntax that Perl regexes support. They won't all be listed here but often, instead of being surrounded by (), the assertions will be surrounded by <>.

For character classes, this means that:

• [abc] becomes <[abc]>

• [^abc] becomes <-[abc]>

• [a-zA-Z] becomes <[a..zA..Z]>

• [[:upper:]] becomes <:Upper>

• [abc[:upper:]] becomes <[abc]+:Upper>

For lookaround assertions:

• (?=[abc]) becomes <?[abc]>

• (?=ar?bitrary* pattern) becomes <before ar?bitrary* pattern>

• (?!=[abc]) becomes <![abc]>

• (?!=ar?bitrary* pattern) becomes <!before ar?bitrary* pattern>

• (?<=ar?bitrary* pattern) becomes <after ar?bitrary* pattern>

• (?<!ar?bitrary* pattern) becomes <!after ar?bitrary* pattern>

For more info see lookahead assertions.

(Unrelated to <> syntax, the "lookaround" /foo\Kbar/ becomes /foo <( bar )> /

• (?(?{condition))yes-pattern|no-pattern) becomes [ <?{condition}> yes-pattern | no-pattern ]

Longest token matching (LTM) displaces alternation

In Raku regexes, | does LTM, which decides which alternation wins an ambiguous match based off of a set of rules, rather than about which was written first.

The simplest way to deal with this is just to change any | in your Perl regex to a ||.

However, if a regex written with || is inherited or composed into a grammar that uses | either by design or typo, the result may not work as expected. So when the matching process becomes complex, you finally need to have some understanding of both, especially how LTM strategy works. Besides, | may be a better choice for grammar reuse.

Named captures

These work in a slightly different way; also they only work in the latest versions of Perl.

use v5.22;
"þor is mighty" =~ /is (?<iswhat>\w+)/n;
say $+{iswhat};

The iswhat within a non-capturing group is used to actually capture what is behind, and up to the end of the group (the )). The capture goes to the %+ hash under the key with the name of the capture. In Raku named captures work this way

"þor is mighty" ~~ /is \s+ $<iswhat>=(\w+)/;
say $<iswhat>;

An actual assignment is made within the regular expression; that's the same syntax used for the variable outside it.

Comments

As with Perl, comments work as usual in regexes.

/ word #`(match lexical "word") /

BEGIN, UNITCHECK, CHECK, INIT and END

Except for UNITCHECK, all of these special blocks exist in Raku as well. In Raku, these are called Phasers. But there are some differences!

UNITCHECK becomes CHECK

There is currently no direct equivalent of CHECK blocks in Raku. The CHECK phaser in Raku has the same semantics as the UNITCHECK block in Perl: it gets run whenever the compilation unit in which it occurs has finished parsing. This is considered a much saner semantic than the current semantics of CHECK blocks in Perl. But for compatibility reasons, it was impossible to change the semantics of CHECK blocks in Perl, so a UNITCHECK block was introduced in 5.10. Consequently, it was decided that the Raku CHECK phaser would follow the saner Perl UNITCHECK semantics.

No block necessary

In Perl, these special blocks must have curly braces, which implies a separate scope. In Raku this is not necessary, allowing these special blocks to share their scope with the surrounding lexical scope.

my $foo;             # Perl 
BEGIN { $foo = 42 }

BEGIN my $foo = 42;  # Raku 

Changed semantics with regards to precompilation

If you put BEGIN and CHECK phasers in a module that is being precompiled, then these phasers will only be executed during precompilation and not when a precompiled module is being loaded. So when porting module code from Perl, you may need to change BEGIN and CHECK blocks to INIT blocks to ensure that they're run when loading that module.

Pragmas

strict

Strict mode is now on by default.

warnings

Warnings are now on by default.

no warnings is currently NYI, but putting things in a quietly {} block will silence.

autodie

The functions which were altered by autodie to throw exceptions on error, now generally return Failures by default. You can test a Failure for definedness / truthiness without any problem. If you use the Failure in any other way, then the Exception that was encapsulated by the Failure will be thrown.

# Perl 
open my $i_fh, '<', $input_path;  # Fails silently on error 
use autodie;
open my $o_fh, '>', $output_path; # Throws exception on error 

# Raku 
my $i_fh = open $input_path,  :r; # Returns Failure on error 
my $o_fh = open $output_path, :w; # Returns Failure on error 

Because you can check for truthiness without any problem, you can use the result of an open in an if statement:

# Raku 
if open($input_path,:r) -> $handle {
    .say for $handle.lines;
}
else {
    # gracefully handle the fact that the open() failed 
}

base, parent

Both use base and use parent have been replaced in Raku by the is keyword, in the class declaration.

# Perl 
package Cat;
use base qw(Animal);

# Raku 
class Cat is Animal {}

Note that the Animal class must be known at compilation time prior to be able to inherit from it.

bigint bignum bigrat

No longer relevant.

Int is now arbitrary precision, as is the numerator of Rat (the denominator is limited to 2**64, after which it will automatically upgrade to Num to preserve performance). If you want a Rat with an arbitrary-precision denominator, FatRat is available.

constant

In Raku, constant is a declarator for variables, just like my, except the variable is permanently locked to the result of its initialization expression (evaluated at compile time).

So, change the => to =.

use constant DEBUG => 0; # Perl 

constant DEBUG = 0;      # Raku 

use constant pi => 4 * atan2(1, 1); # Perl 

tau, pi, e, i; # built-in constants in Raku 
τ, π, 𝑒        # and their unicode equivalents 

encoding

Allows you to write your script in non-ascii or non-utf8. Raku uses, for the time being, only utf8 for its scripts.

integer

Perl pragma to use integer arithmetic instead of floating point. There is no such thing in Raku. If you use native integers in your calculations, then this will be the closest thing.

#Raku 
my int $foo = 42;
my int $bar = 666;
say $foo * $bar;    # uses native integer multiplication 

lib

Manipulate where modules are looked up at compile time. The underlying logic is very different from Perl, but in the case you are using an equivalent syntax, use lib in Raku works the same as in Perl.

mro

No longer relevant.

In Raku, method calls now always use the C3 method resolution order. If you need to find out parent classes of a given class, you can invoke the mro metamethod thusly:

say Animal.^mro;    # .^ indicates calling a metamethod on the object 

utf8

No longer relevant: in Raku, source code is expected to be in utf8 encoding.

vars

Discouraged in Perl. See https://perldoc.perl.org/vars.html.

You should refactor your Perl code to remove the need for use vars, before translating into Raku.

Command-line flags

See the command line flags that Rakudo uses

Unchanged:

-c -e -h -I -n -p -v -V

-a

Change your code to use .split manually.

-F

Change your code to use .split manually.

-l

This is now the default behavior.

-M -m