TITLE

The extensions recommended for files with Raku content.


SUBTITLE

table_head

========================================================


table_row

table

Note that in most cases, the historic extensions will still work.


head

An extension is the part of the filename after the final '.'; if no '.'
is present, there is no extension.


Filename extensions can be used to associate behavior with the file content, such as opening
a specialized reader or editor, running a program with the file content as input, etc.
Even when it is not required by the operating system, filename extensions can provide a useful
reminder about the contents of the file.


The Raku language was originally known as Perl 6, and this is reflected in the historic column
above. Please use the current extensions whenever possible when generating new code.


root

A basic introductory example of a Raku program


Raku by example 101


How to contribute to Raku and to the documents, how to generate the docs locally


About the docs


Using Raku official documentation


Brief introduction


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

Filename extensions


Functions and functional programming in Raku


Routines are one of the means Raku has to reuse code. They come in
several forms, most notably L<C<Method>|/type/Method>s, which belong in
classes and roles and are associated with an object; and functions (also
called I<subroutines> or L<C|/type/Sub>s, for short), which can be
called independently of objects.

Subroutines default to lexical (C<my>) scoping, and calls to them are
generally resolved at compile time.

Subroutines can have a L<C<Signature>|/type/Signature>, also called
I<parameter list>, which specifies which, if any, arguments the
signature expects. It can specify (or leave open) both the number and
types of arguments, and the return value.

Introspection on subroutines is provided via L<C<Routine>|/type/Routine>.

The basic way to create a subroutine is to use the C declarator followed by
an optional L<identifier|/language/syntax#Identifiers>:

sub my-func { say "Look ma, no args!" }
my-func;


The sub declarator returns a value of type L<C|/type/Sub> that can be stored
in any container:

my &c = sub { say "Look ma, no name!" }
c;     # OUTPUT: «Look ma, no name!␤»


my Any:D $f = sub { say 'Still nameless...' }
$f();  # OUTPUT: «Still nameless...␤»


my Code \a = sub { say ‚raw containers don't implement postcircumfix:<( )>‘ };
a.(); # OUTPUT: «raw containers don't implement postcircumfix:<( )>␤»

The declarator C will declare a new name in the current scope at compile
time. As such, any indirection has to be resolved at compile time:

constant aname = 'foo';
sub ::(aname) { say 'oi‽' };
foo;


This will become more useful once macros are added to Raku.


To have the subroutine take arguments, a L<C<Signature>|/type/Signature> goes
between the subroutine's name and its body, in parentheses:

code

By default, subroutines are L<lexically scoped|/syntax/my>. That is,
C is the same as C<my sub foo {...}> and is only
defined within the current scope.

=begin code
sub escape($str) {
 # Puts a slash before non-alphanumeric characters
 S:g[<-alpha -digit>] = "\\$/" given $str
}

say escape 'foo#bar?'; # OUTPUT: «foo\#bar\?␤»

{
 sub escape($str) {
 # Writes each non-alphanumeric character in its hexadecimal escape
 S:g[<-alpha -digit>] = "\\x[{ $/.ord.base(16) }]" given $str
 }

 say escape 'foo#bar?' # OUTPUT: «foo\x[23]bar\x[3F]␤»
}

# Back to original escape function
say escape 'foo#bar?'; # OUTPUT: «foo\#bar\?␤»
=end code

Subroutines don't have to be named. If unnamed, they're called I<anonymous>
subroutines.

say sub ($a, $b) { $a ** 2 + $b ** 2 }(3, 4) # OUTPUT: «25␤»


But in this case, it's often desirable to use the more succinct L<C<Block>|/type/Block>
syntax. Subroutines and blocks can be called in place, as in the example above.

say -> $a, $b { $a ** 2 + $b ** 2 }(3, 4)    # OUTPUT: «25␤»


say { $^a ** 2 + $^b ** 2 }(3, 4)            # OUTPUT: «25␤»


Whenever you see something like C«{ $_ + 42 }», C«-> $a, $b { $a ** $b }», or
C«{ $^text.indent($:spaces) }», that's L<C<Block>|/type/Block> syntax; the C«->» is
considered also part of the block. Statements such as C<if>, C<for>, C<while>
are followed by these kind of blocks.

for 1, 2, 3, 4 -> $a, $b {
    say $a ~ $b;
}
# OUTPUT: «12␤34␤»


They can also be used on their own as anonymous blocks of code.


say { $^a ** 2 + $^b ** 2}(3, 4) # OUTPUT: «25␤»


Please note that this implies that, despite the fact that statements such as
C<if> do not define a topic variable, they actually can:

For block syntax details, see the documentation for the L<C<Block>|/type/Block>
type.

The parameters that a function accepts are described in its I<signature>.

Details about the syntax and use of signatures can be found in the
L<documentation on the C<Signature> class|/type/Signature>.

X<Automatic signatures|Variables,@_;Variables,%_>

If no signature is provided but either of the two automatic variables C<@_> or
C<%_> are used in the function body, a signature with C<*@_> or C<*%_> will be
generated. Both automatic variables can be used at the same time.

sub s { say @_, %_ };
say &s.signature # OUTPUT: «(*@_, *%_)␤»


Arguments are supplied as a comma separated list. To disambiguate nested calls,
use parentheses:


sub f(&c){ c() * 2 }; # call the function reference c with empty parameter list
sub g($p){ $p - 2 };
say(g(42), 45);       # pass only 42 to g()


When calling a function, positional arguments should be supplied
in the same order as the function's signature. Named arguments
may be supplied in any order, but it's considered good form to
place named arguments after positional arguments. Inside the
argument list of a function call, some special syntax is supported:


sub f(|c){};
f :named(35); # A named argument (in "adverb" form)
f named => 35; # Also a named argument
f :35named; # A named argument using abbreviated adverb form
f 'named' => 35; # Not a named argument, a Pair in a positional argument
f 'hi', :1x, :2y; # Positional and named arguments
my \c = <a b c>.Capture;
f |c; # Merge the contents of Capture $c as if they were supplied

Arguments passed to a function are conceptually first collected in a
L<C<Capture>|/type/Capture> container. Details about the syntax and use of these containers
can be found in L<C<Capture>|/type/Capture>'s documentation.

When using named arguments, note that normal list "pair-chaining" allows
one to skip commas between named arguments.


A low-level explanation of Raku containers


Containers


What are contexts and how to switch into them


Contexts and contextualizers


Statements used to control the flow of execution


Control flow


An example using the enum type


Enumeration


Using exceptions in Raku


Exceptions


Parsing and interpreting text


Grammars


Working with associative arrays/dictionaries/hashes


Hashes and maps


Correctly use Raku IO


Input/Output the definitive guide


Positional data constructs


Lists, sequences, and arrays


Introspection and the Raku object system


Metaobject protocol (MOP)


Call into dynamic libraries that follow the C calling convention


Native calling interface


Using the types the compiler and hardware make available to you


Raku native types


How the different newline characters are handled, and how to change the behavior


Newline handling in Raku


Numeric types available in Raku


Numerics


Object orientation in Raku


Object orientation


Common Raku infixes, prefixes, postfixes, and more!


Operators


Organizing and referencing namespaced program elements


Packages


Measuring and improving runtime or compile-time performance


Performance


Program execution phases and corresponding phaser blocks


Phasers


Special modules that define certain aspects of the behavior of the code


Pragmas


Writing strings and word lists, in Raku


Quoting constructs


Pattern matching against strings


Regexes


Unordered collections of unique and weighted objects in Raku


Sets, bags, and mixes


A guide to signatures in Raku


Signature literals


Prefixes that alter the behavior of a statement or a set of them


Statement prefixes


How Raku deals with data structures and what we can expect from them


Data structures


Accessing data structure elements by index or key


Subscripts


General rules of Raku syntax


Syntax


Working with the underlying operating system and running applications


System interaction


Processing date and time in Raku


Date and time functions


Compile-time specification of behavior made easy


Traits


Unicode symbols and their ASCII equivalents


Unicode versus ASCII symbols


Unicode support in Raku


Unicode


Variables in Raku


Variables


Routines not defined within any class or role.


Independent routines


Functions


What's the difference between Raku, Rakudo and Perl 6?


Properly speaking, L<Rakudo|https://rakudo.org/> is an implementation of Raku.
It's currently the one that's being developed, but there have been other
implementations in the past and there will likely be others in the future.
Raku is the definition of the language. When talking about the current
interpreter, Rakudo and Raku can be used interchangeably. "Perl 6" is the
name that was used for "Raku" before October 2019.

The Rakudo 2015.12 implementation version was released on December 25th 2015,
which implemented the v6.c Raku specification, released at the same time.


No. The first stable language specification version is v6.c
("Christmas"). Future versions of the spec may have point releases (e.g.,
v6.d.2) or major releases (e.g., v6.e).


Running C<raku -v> will display the language version your compiler
implements, e.g.:

The v6.d Specification was released on
L<Diwali 2018|https://en.wikipedia.org/wiki/Diwali>,
which was November 6–7 2018, in a
convenient time zone. 6.d was enabled by default in the Rakudo compiler
release of 2018.11.

The vast majority of 6.d features were already implemented and available
in the Rakudo compiler without requiring any special pragmas, as they
did not conflict with the 6.c specification. A smaller set of features
and behaviors is available automatically if you have the C<use
v6.d> pragma at the top of the file. The rest of about 3100 new
commits to the language specification simply clarify previously
undefined behavior.

Mac users can use the latest Rakudo Star DMG binary installer at
L<https://rakudo.org/downloads/star>

Windows users can use the Rakudo Star MSI binary installer. You will
need Windows Git and Strawberry Perl to use zef to install library
modules.


Linux users probably want to download Rakudo Star and follow the
compilation instructions at L<https://www.raku.org/downloads/>.

There should be Linux and Mac binaries available from vendors and third
parties, although vendor versions may be outdated. Versions before
Rakudo release of 2015.12 should be avoided.


There's an official Rakudo Star docker image at
L<https://hub.docker.com/_/rakudo-star/>

X<|Reference,rakubrew (FAQ)>
X<|Reference,rakudobrew (FAQ)>

As an advanced user I want to track Rakudo development.


An option is to clone L<the repository|https://github.com/rakudo/rakudo> and
build it. This will install work in progress which is minimally-tested and
may contain severe bugs. If you're interested in contributing to the Rakudo
Raku compiler, you may find the
L<Z-Script helper tool|https://github.com/zoffixznet/z> useful.

To install the last official monthly release, check out the tag visible
at L<https://raw.githubusercontent.com/rakudo/rakudo/master/VERSION> or
set up L<a helper command|https://github.com/zoffixznet/r#table-of-contents>.

Some users choose to use L<rakubrew|https://rakubrew.org/>, which allows
quick installation of multiple versions of Rakudo in parallel.

In either case you will probably need to also install
L«C<zef>|https://github.com/ugexe/zef» and
L«C<rakudoc>|https://raku.land/zef:coke/rakudoc» from the
L<ecosystem|https://raku.land/>.

Where can I find good documentation on Raku?


See L<the official documentation website|/index>
(especially its L<"Introduction" section|/introduction>) as well as the
L<Resources page|https://raku.org/resources/>. You can also consult
this L<great cheatsheet|https://htmlpreview.github.io/?https://github.com/perl6/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.html>.

L<perl6book.com|https://perl6book.com/> contains a list of dead tree and
electronic books.

Be mindful of publication dates when reading third-party articles.
Anything published before December, 2015 likely describes a pre-release
version of Raku.


You can always
L<get help from a live human in our help chat|https://web.libera.chat/?channel=#raku>
or L<search the chat logs|https://irclogs.raku.org/>
to find previous conversations and discussions.

Here are some available books, in alphabetical order:


item

A list of books published or in progress is maintained in
L<C<raku.org>|https://raku.org/resources/>.

The specification refers to the official test suite for Raku. It's called
L<C<roast>|https://github.com/Raku/roast> and is hosted on github. Any
compiler that passes the tests is deemed to implement that version of the
Raku specification.

Roast's C<master> branch corresponds to the latest development that isn't
necessarily part of any specification yet. Other branches
correspond to specific versions; for example, "6.c-errata".

So C<6.c-errata> is a released language version we don't change other than to
fix errors in tests (the "errata") whereas master is the unreleased
work-in-progress that may become the next language version. Its current state
is not necessarily prescriptive of the next language version's behavior since
new additions will be reviewed for inclusion into the release.

Is there a glossary of Raku related terms?


Yes, see L<glossary|/language/glossary>.

I'm a Perl programmer. Where is a list of differences between Perl
and Raku?


There are several I<Perl to Raku> guides in the
L<Introduction section of the documentation|/introduction>, most notable of which
is the L<Overview|/language/5to6-nutshell>.

I'm a Ruby programmer looking for quickstart type docs?


See the L<rb-nutshell|/language/rb-nutshell> guide.

X<|Reference,CPAN (FAQ)>X<|Reference,ecosystem>

Is there a repository of third party library modules for Raku?


Valid opening/closing paired delimiters


Brackets


Information about the people working on and using Raku


Community


Glossary of Raku terminology


Glossary


An easy-to-use markup language for documenting Raku modules and programs


Pod6


Valid, invalid, and unexpected tables


Pod6 tables


Raku terms


Terms


Writing and running tests in Raku


Testing


Traps to avoid when getting started with Raku


Traps to avoid


Frequently asked questions about Raku


FAQ


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

Filename extensions

Introduction

History

See Also

File contents	Extension	Historic extensions
Raku script	.raku	.pl, .p6
Raku module	.rakumod	.pm, .pm6
Raku documentation	.rakudoc	.pm, pm6, pod, pod6
Test files in raku	.rakutest	.t
Not Quite Perl (NQP)	.nqp