This is part 5 of the "Don't fear the grepper!" series.
The next confession
Yes, another one. In the previous blog post I said that you can decide to not accept some values in a .map
, by returning the Empty
value from the block.
say (1..12).map({
if $_ %% 2 { # is it divisible by 2?
$_ # yes, accept
}
else { # not divisible by 2
Empty # don't accept
}
}); # (2 4 6 8 10 12)
There's actually another way to decide to not accept a value, and that is by using the next
control flow statement. With next
, you're actually telling .map
to stop executing any code inside the block immediately, and start the next iteration.
So how would that look in the above case?
say (1..12).map({
next unless $_ %% 2; # not divisible by 2, next!
$_ # accept
}); # (2 4 6 8 10 12)
Note that using next
will interrupt the normal flow of the program. When it executes, it will look up the call stack and instruct the first handler capable of handling next
to immediately continue with the next iteration. In this case, the .map
method has installed such a handler.
And you see I used unless
, instead of if
not
there. I generally use unless
only as a statement modifier, because using it with blocks generally doesn't improve readability, and therefor maintainability of any codebase. But of course, I could also have written next if not $_ %% 2
!
Other than the program flow interruption feature of next
, next
is just a subroutine that is provided by the Raku core. So you can have multiple references to next
in the same block.
say (1..12).map({
next unless $_ %% 2; # not divisible by 2, next!
next unless $_ %% 3; # not divisible by 3, next!
$_ # accept
}); # (6 12)
By using next
you can create quite complicated logic when doing any mapping using .map
.
For the last time
Sometimes you want to not accept any more values in a .map
when a certain condition fires, for instance when a certain value is seen. Let's take one of the above examples, and make it stop when the value 7 has been encountered:
my $done = False; # create flag
say (1..12).map({
$done = True if $_ == 7; # switch flag if appropriate
next if $done; # we're done, next!
next unless $_ %% 2; # not divisible by 2, next!
$_ # accept
}); # (2 4 6)
As you can see, this is a bit of a hassle. Fortunately, the Raku Programming Language has a solution for that in the form of the last
control flow statement. So let's rewrite this example using last
:
say (1..12).map({
last if $_ == 7; # we're done
next unless $_ %% 2; # not divisible by 2, next!
$_ # accept
}); # (2 4 6)
Like next
, last
will interrupt the normal flow of the program. When it executes, it will look up the call stack and instruct the first handler capable of handling last
to stop iterating. In this case, the .map
method has installed such a handler.
Wow, that is so much easier!
Side effects
The previous example had one interesting side-effect: setting a flag outside of the block inside the .map
. Yes, in the Raku Programming Language you can refer to variables outside of its lexical scope, as long as they are lexically "visible". You can use this feature for instance, to keep a count of even numbers you've seen:
my $seen = 0; # initialize counter
say (1..12).map({
next unless $_ %% 2; # not divisible by 2, next!
$seen++; # increment counter
$_ # accept
}); # (2 4 6 8 10 12)
say "$seen even numbers"; # 6 even numbers
As you can see, the Raku Programming Language also has a ++
postfix operator for incrementing integer values!
But what if you're only interested in how many even numbers were seen, and not interested in the actual numbers themselves? Well, that should be easy: remove the say
, and the final $_
in the block (as we're not interested in the actual value when returning from the block anyway).
my $seen = 0; # initialize counter
(1..12).map({
next unless $_ %% 2; # not divisible by 2, next!
$seen++; # increment counter
});
say "$seen even numbers"; # 6 even numbers
And in that case, we might as well make the increment conditional, and lose the next
!
my $seen = 0; # initialize counter
(1..12).map({
$seen++ if $_ %% 2; # divisible by 2, increment!
});
say "$seen even numbers"; # 6 even numbers
This has now become a case in which the .map
method only executes the given block for its side-effects.
For all we know
Actually, the Raku Programming Language has a better syntax for that: the for
control statement:
my $seen = 0; # initialize counter
for 1..12 {
$seen++ if $_ %% 2; # divisible by 2, increment!
}
say "$seen even numbers"; # 6 even numbers
Yes. The for
loop in Raku, is basically a .map
of which the body is only executed for its side-effects. They both use the same underlying iterator mechanism. Which means that you can use next
and last
also in for
loops, because it is basically a .map
(or vice-versa, depending on how you look at it).
The underlying iterator mechanism is material for a whole separate set of blog posts, so I won't go further into that here and now. Suffice to say that Raku attempts to unify many different concepts that appear to be different on the surface, to deeper unifying logic and syntax.
Signature features
Remember that in the first post of this series, we saw that you could create a block taking a value and put it into a specific variable:
-> $number { $number %% 2 }
Would you be able to use that same syntax with for
? Yes, you can:
my $seen = 0; # initialize counter
for 1..12 -> $number {
$seen++ if $number %% 2; # divisible by 2, increment!
}
say "$seen even numbers"; # 6 even numbers
In fact, the -> $number
syntax is a property of the block, not of the .map
or the for
loop! In fact, that feature is called the signature property of the block. Does this also imply that you can use that syntax in for instance an if
statement? Yes, you can:
if complicated-calcution($input) -> $result {
say "Result of calculation: $result";
}
Because the if
statement also just accepts a block, just as .map
or for
expect a block!
But what about grep?
This series of blog posts has "grep" in its title. So how does this apply to .grep
? Could you use .grep
for its side-effects? Yes, you could:
my $seen = 0; # initialize counter
(1..12).grep({
$seen++ if $_ %% 2; # divisible by 2, increment!
});
say "$seen even numbers"; # 6 even numbers
But you probably shouldn't. Because .grep
is intended to filter out values from a list, and you're not using it for that in this example. And using .grep
for its side-effects only will confuse whoever will be maintaining your code in the future! And that could be you!
Conclusion
This concludes the fifth part of the series, this time introducing the next
and last
loop control flow statements. And hopefully instilled the notion that a for
loop is nothing but a .map
that is only executed for its side-effects. Also that blocks have signatures, that can be specified in many other situations in Raku code, such as with an if
.
Questions and comments are always welcome. You can also drop into the #raku-beginner channel on Libera.chat, or on Discord if you'd like to have more immediate feedback.
I hope you liked it! Thanks again for reading all the way to the end.
Top comments (0)