Category: Raku

To just load a module and do no exports, use the need keyword. Let us create a module named N, which contains the sub n(). This time, the sub is declared as our but with no is export. unit module N;  our sub n() {     say “N::n()”; } Then you need a module and … Continue reading “📘 The need keyword to use a module in Perl 6”

Apart from the positional parameters (those that have to go in the same order both in the sub definition and in the sub call), Perl 6 allows named variables, somewhat similar to how you pass a hash to a Perl 5 subroutine. To declare a named parameter, a colon is used: sub power(:$base, :$exponent) { … Continue reading “📘 Named arguments in Perl 6 subs”

Nested subs are allowed in Perl 6. sub cube($x) {     sub square($x) {         return $x * $x;     }     return $x * square($x); } say cube(3); # 27 The name of the inner sub square is only visible within the body of the outer sub cube.

Lexical variables in Perl 6 are those declared with the my keyword. These variables are only visible within the block where they were declared. If you tried accessing them outside the scope, you’d get the error: Variable ‘$x’ is not declared. {      my $x = 42;      say $x; # This is fine } … Continue reading “📘 Lexical variables in Perl 6”

The scope of dynamic variables is calculated at the moment when a variable is accessed. Thus, two or more calls of the same code may produce different results. Dynamic variables are marked with the * twigil (a character clearly referencing a wildcard). In the following example, the echo() function prints a dynamic variable $*var, which … Continue reading “📘 Dynamic variables in Perl 6”

When an anonymous code block is created, declaring a list of arguments is not mandatory even when a block takes an argument. To let this happen, Perl 6 uses special variable containers, which come with the ^ twigil. This is similar to the predefined variables $a and $b in Perl 5. In the case of … Continue reading “📘 Placeholders in Perl 6”

Multi subs can be made even more specific by using subtypes. In Perl 6, subtypes are created with the subset keyword. A subtype definition takes one of the existing types and adds a restriction to select the values to be included in the subtype range. The following lines give a clear view of how subtypes … Continue reading “📘 Sub overloading with subtypes in Perl 6”

The my and our variables, as well as subs, which are defined in the module, are not visible outside of its scope by default. To export a name, the is export trait is required. unit module X;  sub x() is export {     say “X::x()”; } This is all you need to do to be … Continue reading “📘 Exporting a sub from a module in Perl 6”

Here is a concise list of the keywords for working with modules. use loads and imports a module at compile time need loads a module at compile time but does not import anything from it import imports the names from the loaded module at compile time require loads a module at runtime without importing the … Continue reading “📘 Modules import summary in Perl 6”

The keyword module declares a module. The name of the module is given after the keyword. There are two methods of scoping the module. Either it can be a bare directive in the beginning of a file, or the whole module can be scoped in the code block within the pair of braces. In the … Continue reading “📘 Creating a module in Perl 6”

To use a module in your code, use the keyword use. An example. Let us first create the module Greet and save it in the file named Greet.pm. unit module Greet;  sub hey($name) is export {     say “Hey, $name!”; } Then, let us use this module in our programme by saying use Greet. use … Continue reading “📘 Using a module in Perl 6”

The use keyword automatically imports the names from modules. When a module is defined in the current file in the lexical scope (please note that the module can be declared as local with my module), no import will be done by default. In this case, importing the names should be done explicitly with the import … Continue reading “📘 Importing a module in Perl 6”

The require keyword loads a module at a runtime unlike the use, which loads it at the compile-time. For example, here is a module with a single sub, which returns the sum of its arguments. unit module Math;  our sub sum(*@a) {     return [+] @a; } (The star in *@a is required to tell … Continue reading “📘 The require keyword to use a module in Perl 6”