TITLE

SUBTITLE

These documents should not be mistaken for a beginner tutorial or a
promotional overview of Raku (née Perl 6); it is intended as a technical
reference for Raku learners with a strong Perl background and for anyone
porting Perl code to Raku.


head

L<Raku in a Nutshell|/language/5to6-nutshell> provides a quick overview of
things changed in syntax, operators, compound statements, regular expressions,
command-line flags, and various other bits and pieces.


The L<Syntax section|/language/5to6-perlsyn> provides an overview of the
syntactic differences between Perl and Raku: how it is still mostly
free form, additional ways to write comments, and how C<switch> is very
much a Raku thing.


The L<Operators section|/language/5to6-perlop> guides you from the operators
in L<Perl's perlop|https://metacpan.org/pod/distribution/perl/pod/perlop.pod>
to the equivalent in Raku.


The L<Functions section|/language/5to6-perlfunc> describes all of the Perl
functions and their Raku equivalent and any differences in behavior.  It
also provides references to ecosystem modules that provide the Perl behavior
of functions, either existing in Raku with slightly different semantics
(such as C<shift>), or non-existing in Raku (such as C<tie>).


The L<Special Variables section|/language/5to6-perlvar> describes if and how
a lot of Perl's special (punctuation) variables are supported in Raku.


comment

=begin comment

### Guidelines for contributions:

Headers should contain the text that a Perl user might search for, since
those headings will be in the Table of Contents generated for the top of
the document.

We use POD =item instead of =head3 or =head4 for unchanged bits that need
not appear in the table of contents.

This article does not describe the additions to syntax, nor details of
possible improvements. For example, C<0 + $string> still works, even though
we would write it as C<+$string> now. (Blue Tiger will offer a Perl
Modernization guide, with step-by-step procedures for translation, along
with details of new idioms and "better ways to do it")

Example code and links to other documents should be favored over long
explanations of details better found elsewhere.

Finally, if a real user asks a P5->P6 question not answered here, please
add it to the document, even if we don't have a good answer yet. That will
be better than losing the information about a real need.

=end comment


root

How do I do what I used to do? (Raku in a nutshell)


Perl to Raku guide - in a nutshell


Builtin functions in Perl to Raku


Perl to Raku guide - functions


Operators in Perl to Raku: equivalencies and variations


Perl to Raku guide - operators


Syntactic differences between Perl and Raku


Perl to Raku guide - syntax


A comparison of special variables in Perl and Raku


Perl to Raku guide - special variables


Learning Raku from Haskell, in a nutshell


Haskell to Raku - nutshell


Learning Raku from Node.js, in a nutshell


JavaScript (Node.js) to Raku - nutshell


Learning Raku from Python, in a nutshell


Python to Raku - nutshell


Learning Raku from Ruby, in a nutshell: what do I already know?


Ruby to Raku - nutshell


How do I do what I used to do?


para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

Perl to Raku guide - overview


A (hopefully) comprehensive list of Perl builtin functions with their Raku
equivalents with notes on variations between them where necessary.


This document is an
attempt to guide you from the functions in Perl's C<perlfunc> document to
their equivalents in Raku. For full documentation on the Raku
functions, follow the links in this document to their respective documentation.


One general comment: Raku takes its objects a lot more seriously than
Perl. In Raku, everything is an object, although the language is
flexible enough to not force you to work in an object oriented manner if
you do not wish to do so. What this does mean, however, is that a lot of
things that are function calls of the form C<function(@args)> are now
also method calls of the form C<@args.function> (In rare cases, there is
I<only> a method call). This should be obvious in the following text,
but it probably behooves you to get into that frame of mind now.


Also, unless otherwise stated, the use of the term "function" here will mean a
function in the style of C<func(@args)>, while "method" will refer to a
function in the style of C<@args.func>.


X<Filetests|Other languages,filetests - perlfunc>


item

Raku gives you a couple of options when it comes to file tests. You can do a
smartmatch (C<~~>) or you can call a method.


In Raku, you don't need to actually open a filehandle in the
traditional way (although you can) to do a filetest. You can simply append
C<.IO> to the filename. For instance, here is how to check if a file is
readable using smartmatch:


You can use an already opened filehandle. Here, using the filehandle
C<$fh>, is an example, using the method syntax for the file test:


code

Most of the former filetests have colon equivalents for use with smartmatch:


table_row

table

All of these tests can be used as methods (without the colon).


Three tests, however, I<only> have method equivalents:


The remaining filetests in Perl are not implemented in Raku.


The documentation for this can be found at
L<File test operators|/type/IO::Path#File_test_operators>.


There is more information on reading and writing files at
L<io|/language/io>. Also, the section on C<open()>
below may be helpful.


The Raku ecosystem has a module L<C<P5-X>|https://raku.land/zef:lizmat/P5-X>
which exports the behavior as much as possible in Raku.


Works as a function (C<abs($x)>), but also as a method. One gotcha,
however - method calls bind more tightly than C<->, so, for example,
C<-15.abs> evaluates as C<-(15.abs)> giving you C<-15>. In this example, you
would have to do something like C<(-15).abs>.


C<abs> also operates on C<$_> in the absence of a value, but not as a
function, and as a method you need to call it as C<.abs> rather than simply
C<abs>.


The Raku ecosystem has a module L<C<P5math>|https://raku.land/zef:lizmat/P5math>
which exports an C<abs> function that mimics the original Perl behavior as
much as possible.


X<accept|Other languages,accept - perlfunc>


C<accept> is a method you can call on a server, e. g.
C<$server.accept()>. Instead of returning a packed address, it returns a
socket, most likely an L<C<IO::Socket>|/type/IO::Socket> object of some sort.


X<alarm|Other languages,alarm - perlfunc>


C<alarm()> is no more.  But it is possible to have code execute after a
certain time has elapsed, or at a given time:


Promise.in(5).then: { say "five seconds have passed" }


Promise.at(now + 5).then: { say "five seconds have passed" }


In Raku, this does I<not> involve any (dummy) signals.


X<atan2|Other languages,atan2 - perlfunc>


Available as a function as well as being able to be used as a method.
For instance, these are equivalent:


[NEEDS FURTHER RESEARCH] No sign of a socket-related C<bind()> in Raku. At a
guess, whatever socket binding is needed happens when you create a new socket
object.


X<binmode|Other languages,binmode - perlfunc>


Instead of this, you would use C<:bin> as the file mode when opening the
socket. E. g. C<my $fh = open("path/to/file", :bin);>


X<bless|Other languages,bless - perlfunc>


With the changes in class creation in Raku, this may find less use
than in Perl, and is a method as well as a function. The Raku docs
say "Creates a new object of the same type as the invocant, uses the
named arguments to initialize attributes, and returns the created
object." If you're porting a module from Perl to Raku, it's quite
possible you'll want to use C<new> for creating objects rather than
C<bless>, although there may be some situations in which the latter may
still be useful.


X<break|Other languages,break - perlfunc>


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
I<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 L<automated translation|#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.


I<Please note that some historic documents may refer to Raku by its
original name, Perl 6, or to Perl as specifically Perl 5.>


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 L<C<Inline::Perl5>|https://raku.land/cpan:NINE/Inline::Perl5> project makes
it possible to C<use> Perl modules directly from Raku code by using
an embedded instance of the C<perl> interpreter to run Perl code.


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 L<https://raku.land/?q=CPAN5>.


Many Perl built-in functions (about a 100 so far) have been ported to
Raku with the same semantics.  Think about the C<shift> function in Perl
having magic shifting from C<@_> or C<@ARGV> by default, depending on context.
These can be found at L<https://raku.land/zef:lizmat/P5built-ins> and
its dependencies.


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


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


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


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:


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 C<~> operator, if you were wondering.)


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


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


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


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:


However, note that you can use L<unspace|/language/syntax#Unspace>
to add whitespace in Raku code in places where it is otherwise not
allowed.


See also
L<other lexical conventions in the syntax page|/language/syntax#Lexical_conventions>.


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.


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


The C<@> sigil is now always used with "array" variables (e.g. C<@months>,
C<@months[2]>, C<@months[2, 4]>), and no longer for L<value-slicing
hashes|#{}_Hash_indexing/slicing>.


The C<%> sigil is now always used with "hash" variables (e.g. C<%calories>,
C<%calories<apple>>, C<%calories<pear plum>>), and no longer for
L<key/value-slicing arrays|#[]_Array_indexing/slicing>.


The C<&> 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":


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


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Perl to Raku guide - overview

Raku in a nutshell

Syntactic differences

Operators in Raku

Functions in Raku

Special variables in Raku

See Also