By default, you pass the arguments by their values. Despite that, it is not possible to modify them inside the sub. To pass a variable by reference, add the is rw trait. (Note that formally this is not a reference but a mutable argument.) sub inc($x is rw) { $x++; } my $value = … Continue reading “📘 Non-value argument passing in Perl 6 subs”
Category: Programming languages
📘 Anonymous subs in Perl 6
Let’s look at the creation of anonymous subs. One of the options (there are more than one) is to use syntax similar to what you often see in JavaScript. say sub ($x, $y) {$x ~ ‘ ‘ ~ $y}(“Perl”, 6); The first pair of parentheses contains the list of formal arguments of the anonymous sub; … Continue reading “📘 Anonymous subs in Perl 6”
📘 Modules in Perl 6
Basically, the Perl 6 modules are the files on disk containing the Perl 6 code. Modules are kept in files with the .pm extension. The disk hierarchy reflects the namespace enclosure, which means that a module named X::Y corresponds to the file X/Y.pm, which will be searched for in one of the predefined catalogues or … Continue reading “📘 Modules in Perl 6”
📘 Class attributes in Perl 6
Class data variables are called attributes. They are declared with the has keyword. An attribute’s scope is defined via its twigil. As usual, the first character of the twigil indicates the type of the container (thus, a scalar, an array, or a hash). The second character is either . if a variable is public or … Continue reading “📘 Class attributes in Perl 6”
📘 Reverse meta-operator R in Perl 6
The prefix R forms the reverse operator for the infix operators, such as / or cmp. The reverse operator does the same as the original but changes the order of the operands. If necessary, it also changes the operator’s associativity. This matters when you have more than two operands in a row. For example, in … Continue reading “📘 Reverse meta-operator R in Perl 6”
📘 Cross meta-operator X in Perl 6
The cross meta-operator prefix, X, applies an operation to all the possible combinations of the elements of the operands that are treated in list context. The result of the cross-operation is also a list. Here is an example that prints the coordinates for all the cells of a chess board: say ‘a’..’h’ X~ 1..8;
📘 Hyper-operators in Perl 6
Hyper-operators modify regular operators in such a way that the operation is applied to all the element of a list operand. Both unary and binary operators may be written in the hyper-operator form. To create a hyper-operator, add a pair of >> and/or << to the operation sign. Let’s start with a simple unary operator … Continue reading “📘 Hyper-operators in Perl 6”
📘 Chapter 1. Perl 6 Essentials
📘 Typed arguments in Perl 6 subs
Similarly to the above-described typed variables, it is possible to indicate that the sub’s parameters are typed. To do so, add a type name before the name of the parameter. sub say-hi(Str $name) { say “Hi, $name!”; } If the types of the expected and the actual parameters do not match, a compile-time error … Continue reading “📘 Typed arguments in Perl 6 subs”
📘 Optional parameters in Perl 6 subs
Optional parameters are marked with a question mark after their names. The defined built-in function helps to tell if the parameter was really passed: sub send-mail(Str $to, Str $bcc?) { if defined $bcc { # . . . say “Sent to $to with a bcc to $bcc.”; } else { … Continue reading “📘 Optional parameters in Perl 6 subs”
📘 Slurpy parameters and flattening in Perl 6
Perl 6 allows passing scalars, arrays, hashes, or objects of any other type as the arguments to a sub. There are no restrictions regarding the combination and its order in a sub declaration. For example, the first argument may be an array, and the second one may be a scalar. Perl 6 will pass the … Continue reading “📘 Slurpy parameters and flattening in Perl 6”
📘 state variables in Perl 6
State variables (declared with the keyword state) appeared in Perl 5.10 and work in Perl 6. Such variables are initialized during the first call and keep their values in subsequent sub calls. It is important to keep in mind that a single instance of the variable is created. Let us return to the example with … Continue reading “📘 state variables in Perl 6”
📘 Function overloading in Perl 6
The multi keyword allows defining more than one function (or subroutine, or simply sub) with the same name. The only restriction is that those functions should have different signatures. In Perl 6, the signature of the sub is defined together with its name, and the arguments may be typed. In the case of multi subs, … Continue reading “📘 Function overloading in Perl 6”
📘 The need keyword to use a module in Perl 6
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”
📘 Submethods in Perl 6 classes
Perl 6 defines the so-called submethods for classes. These are the methods which are not propagating to the subclass’s definition. The submethods may be either private or public, but they will not be inherited by the children. class A { submethod submeth { say “A.submeth” } } class B is A { … Continue reading “📘 Submethods in Perl 6 classes”
📘 The closed method in Perl 6 channels
The Channel class also defines a method that checks on whether the channel is closed. This method is called closed. my $c = Channel.new; say “open” if !$c.closed; # is open $c.close; say “closed” if $c.closed; # closed Despite the simplicity of using the method, it in fact returns not a simple Boolean value but … Continue reading “📘 The closed method in Perl 6 channels”
📘 Named arguments in Perl 6 subs
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 in Perl 6
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
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”
📘 Dynamic 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”