DEV Community: Andrew Shitov

Raku: la lingua dove posso parlare italiano

Andrew Shitov — Tue, 15 Sep 2026 18:08:18 +0000

(Raku: the language where I can speak Italian)

There are a few interesting modules in the L10N namespace in the Raku ecosystem: L10N itself and the family of L10N::... modules written by different authors (I added three just yesterday).

What these modules allow you to do is switch the built-in keyword dictionary of the language itself and thus write code in a language other than English.

Of course, you could always use identifiers (such as variable and routine names) in any language, including those with non-Latin alphabets.

my $saluto = 'Buongiorno';
my $nome = 'Isabella';
say "$saluto, $nome!";

But these modules allow you to extend the idea to elements of Raku itself. Consider the following program:

il-mio $saluto = 'Buongiorno';
il-mio $nome = 'Isabella';
dillo "$saluto, $nome!";

This program does not compile unless you add L10N::IT:

use L10N::IT;

il-mio $saluto = 'Buongiorno';
il-mio $nome = 'Isabella';
dillo "$saluto, $nome!";

And voilà (ok, that's for L10N::FR), you get the result:

% raku test.raku
Buongiorno, Isabella!

As of today, there are a bit over a dozen different localisation modules in the Raku ecosystem.

(To run the program with Rakudo prior to its version 2026.09, set RAKUDO_RAKUAST=1.)

Mechanics

If you'd like to contribute a missing language, consult the L10N documentation first to get an idea of how to generate the module template so that it fits the rest of the family.

A concrete module is generated from a simple text file containing a list of pairs: a regular Raku keyword, e.g., my, and its translation: il-mio or mijn. By the way, that my can be translated into more than one word depending on the gender, as, for example, in Latvian: mans, mana, as well as plural mani or manas, but such support of synonyms is not yet fully used, as I can tell.

Using a module attaches a role to the Raku grammar, which lists the keyword tokens in their translated forms. For example, here is a small extract from the Latvian grammar for the two keywords: my and our:

role L10N::LV {
    . . .
    token scope-my { mans }
    token scope-our { mūsu }
    . . .
}

In the other direction

All these modules share the same design pattern, so you may expect that you can translate the source code back to English. The localisation generator creates yet another role, e.g. RakuAST::Deparse::L10N::LV.

It contains a long list of keywords for reverse translation:

my constant %xlation = . . . 
    "scope-my", "mans", "scope-our", "mūsu", . . .

Call the .DEPARSE method on the .AST (so at this point you indirectly touched on two features of Raku: slangs and RakuAST) and get back to English:

% raku -ML10N::IT
Raku++ 3.28.0 — \h for help, ^D to exit

> 'test.raku'.IO.slurp.AST('IT').DEPARSE

my $saluto = "Buongiorno";
my $nome = "Isabella";
say "{$saluto}, {$nome}!"

And that's all for now: short text, but what's described in this blog post opens up the whole internal Universe of Raku.

Raku: a language where a value can have several values at once (Part 1)

Andrew Shitov — Sun, 13 Sep 2026 12:50:43 +0000

If you did not get the idea from the title, here's an example straight away:

my $x = 5;
say "OK" if $x == 3 | 5 | 7;

This program prints OK, as $x holds 5, which is one of the options listed in 3 | 5 | 7.

The construct 3 | 5 | 7 is called a junction — many values in a single value. And the result of a comparison with it is also a junction:

my $x = 5;
say (3 | 5 | 7).WHAT; # (Junction)
say ($x == 3 | 5 | 7).WHAT; # (Junction)

So, when we compare 5 in $x with 3 | 5 | 7, the result is any(False, True, False). It is enough for one of the three values to be true, so the whole comparison is also true. It's that simple. You don't have to worry about how Raku computes it: sequentially, in parallel using a multi-core processor or simultaneously in parallel universes; you just get the result.

To see the result in a simple Boolean form, convert a junction to a Boolean with so:

say so 5 == 3 | 5 | 7;
say so 4 == 3 | 5 | 7;

All four

It is now logically to extend the above idea. Indeed, in Raku, you have more options to refer to several values with a single word:

say so any(3, 5, 7) == 5;
say so all(2, 4, 6) %% 2;
say so one(1, 2, 3) > 2;
say so none(1, 2, 3) < 0;

All of the numbers 2, 4, 6 are divisible by 2. One of 1, 2, 3 is greater than 2, and none of 1, 2, 3 is negative.

Change the conditions and/or the numbers to confirm that Raku gets it right.

Beyond constants

Naturally, junctions work not only with integer constants. What a programmer may be more interested in is applying them to data structures.

my @ages = 19, 34, 27;

say so all(@ages) ≥ 18; 
say so any(@ages) > 30; 
say so none(@ages) < 0;

Here, the junctions run checks such as age limits for entering the club: all(@ages) ≥ 18 or sanity-checking the age values: none(@ages) < 0.

Such constructs are a natural choice for interval comparisons:

my @v = 3, 7, 5;

say so 0 ≤ all(@v) ≤ 10; # True
say so 0 ≤ all(@v) ≤ 6;  # False

Leaving aside the Unicode characters like ≤ vs. their ASCII equivalents <= etc., spelling out the rules to compare all the numbers in @v would require far more code than testing them with a junction function like all.

What is maybe even more appealing is that you can call a method right on all of the junction-containing values at once:

say (3 | 4 | 5).is-prime;

No need to loop over the items. A junction does the job. The above line of code prints any(True, False, True), which gives the three answers in one.

Similarly, it's possible to pass a junction to a function that—as you might think—accepts a single scalar argument:

sub double($x) { $x × 2 }
say double(1 | 2 | 3);

All of the numbers will be multiplied by two: any(2, 4, 6).

And now let's use junctions as restrictions in function signatures:

multi roll-die(Int $n where 1 | 3 | 5) {
    "odd $n"
}

multi roll-die(Int $n where 2 | 4 | 6) {
    "even $n"
}

say roll-die(6.rand.Int + 1) for ^10;

Here, we have two versions of the same function roll-die, each accepting only odd or even numbers. There is more than one way to test the numbers for that separation, one of them is to use junctions.

The loop runs 10 times and calls roll-die with random integer numbers between 1 and 6.

Raku: a language that counts to infinity (Part 2)

Andrew Shitov — Sun, 30 Aug 2026 18:14:28 +0000

In this part, let's look at infinite sequences from another angle: let's start collecting the values.

First of all, Raku has a pair of built-in routines gather and take. They are useful when you need to collect data that's computed along the way. For example:

my @data = gather {
    for ^50 {
        my $value = 100.rand.Int;
        take $value if 45 < $value < 55;
    }
}

say @data;

The program prints a few random numbers between 45 and 55 (or none when unlucky). You don't know upfront how many numbers it will pick, but at least there's some limit: the loop body runs only 50 times, and the random numbers are less than 100.

So, it's time to introduce some infinity into the code. The next program scans the number, but does not explicitly say how many of them the user will use later. The second line, for example, demands the first five items, and that's when the real computation happens:

my $data = gather for 1 .. ∞ { take $_ if 45 < $_ < 55 }
say $data[^5]; # (46 47 48 49 50)

Surprisingly, working with infinities makes the code clearer for the reader. You just describe what to do with data, but omit the length. The next snippet literally says “Convert the numbers to their squares”. You apply this rule to the infinite (but lazy) range 1 .. ∞, and only then you take the first five elements.

say (gather for 1 .. ∞ { take $_ × $_ }).head(5);

Once again, note that you first apply the action to an infinite sequence, and only then cut it to the size you need. Not vice versa (of course you can if you know when to stop; but sometimes you need the condition on the results rather than on the source). The program prints:

(1 4 9 16 25)

A similar approach is demonstrated in the next two lines:

say ([\+] 1 .. ∞)[^10];
say ([\*] 1 .. ∞)[^7];

Wait, how? Add up or multiply all the integer numbers, and then take the first few elements of one of the triangle metaoperator's results?!

Yes, no problem. A couple of triangle metaoperators are only used to compute the values for the first few items, not for the whole infinity:

(1 3 6 10 15 21 28 36 45 55)
(1 2 6 24 120 720 5040)

Here is a slightly more complex program, but the principle is the same, you define a rule and allow it work for any number of items:

my @pascal = [1], -> @p { [0, |@p Z+ |@p, 0] } ... ∞;
.say for @pascal[^5];

The function in this case is an anonymous pointy block -> @p { [0, |@p Z+ |@p, 0] }. The program prints five rows of Pascal's triangle:

[1]
[1 1]
[1 2 1]
[1 3 3 1]
[1 4 6 4 1]

By the way, you can also ask Raku to add up everything in 1 .. ∞ and you'll get the correct answer: Inf.

say [+] 1 .. ∞;

Again and again we can see that things like Inf and ∞ are not black holes in Raku. They behave according to the task you are working on.

say <a b c> Z (1 .. ∞);

Even though one of the operands of Z is an infinite range, the result is limited to the first three items, as the left operand is quite measurable:

((a 1) (b 2) (c 3))

But nobody can stop us from having infinite ranges on both sides of Z and even making some computations on those as we did earlier. Just make sure you do not take too many:

say ((1 .. ∞) Z (1 .. ∞).map(* ** 2)).head(4);

This program prints the numbers with their squares:

((1 1) (2 4) (3 9) (4 16))

If you are curious why, remove the map and confirm that this weird construct just gives you the same number twice:

((1 1) (2 2) (3 3) (4 4))

As homework, rewrite the last example without using the Z metaoperator.

Raku: a language that counts to infinity (Part 1)

Andrew Shitov — Sun, 16 Aug 2026 19:21:49 +0000

We've already seen that Raku understands characters like ∞, and it would be logically that you can use them with ease, similar to any other constructs of the language.

Take, for example, a sequence with no definite end. You define a pattern and take as many items as you need.

say (1, 1, * + * ... ∞)[^10];

Here, the pattern defines a Fibonacci sequence and we only take the first 10 elements of it:

(1 1 2 3 5 8 13 21 34 55)

You don't know upfront what the 10^th element will be, so just say that the sequence is defined by the rule * + * and goes towards ∞.

Need a stop at a given point? You can make the stop rule explicit:

say 1, 1, * + * ...^ * > 100;

Here we see the same sequence, but it stops as soon as the next number overcomes 100:

(1 1 2 3 5 8 13 21 34 55 89)

If you want to manipulate data a bit more elaborate than just taking the first few items, save the whole infinite list in a variable, why not? Use it as any other array in a Raku program:

my @fib = 1, 1, * + * ... ∞;
say @fib[5];
say @fib[55];

The program prints the requested 5^th and 55^th items of the sequence:

8
225851433717

The main difference with other elements is that the sequence that @fib hosts is lazy. It only computes the values when you demand it. Raku offers an easy way to check if it's lazy indeed:

my @fib = 1, 1, * + * ... ∞;
say @fib.is-lazy; # True

Working with lazy computations is very similar to any other "non-infinite" data. It's possible to map the values of an infinite sequence, say, square the numbers:

my @squares = (1 .. ∞).map(* ** 2);
say @squares[^5];
say @squares[999];

The program first prints the first five squares and then the item number 999, which is 1000²:

(1 4 9 16 25)
1000000

Let's try filtering a lazy sequence:

say (1 .. ∞).grep(*.is-prime)[^10];
say (1 .. ∞).grep(*.is-prime).first(* > 1000);

In this case, not only the original sequence 1 .. ∞ is lazy, but also it's filtered version (1 .. ∞).grep(*.is-prime). Use it in a similar manner as before:

(2 3 5 7 11 13 17 19 23 29)
1009

That's all for now. In Part 2, we'll see some more interesting things that you can do with lazy sequences.

Raku: a language that speaks Unicode

Andrew Shitov — Sun, 09 Aug 2026 17:58:02 +0000

Raku is by design a language that supports Unicode.

So, yes, Unicode is special for both Raku and Raku++. This all starts from the visible surface, like when you can type Greek letters and use math symbols — even easier than you do it in LaTeX (in case you know how to type in non-ASCII characters).

say τ;                       
say ∞ > 10⁹⁹;

my \φ = (1 + sqrt 5) ÷ 2;
say φ;

say 2⁵;
say 5 ∈ (2, 3, 5, 7);

sub prefix:<∑>(@a) { [+] @a }
say ∑(1, 2, 3);

You can run this program in your browser to see how it works using the Raku.js playground. You can also change it a bit to try other things.

The above program was mostly about the characters that are available in the source code. But behind it, Raku knows the internal rules of the Unicode datasets, and the current Raku++ version comes with the embedded UCD 17 tables (Unicode Character Database). They are simply built in the source code, so all happens naturally.

my $family = "👨‍👩‍👧‍👦";
say $family.chars;    # 1   — one grapheme
say $family.codes;    # 7   — seven code points
say "noël".flip;      # lëon — the ë survives reversal
say "🇺🇦🇵🇱".chars;    # 2   — flags don't split

The distinction between the number of codes and characters is mostly visible as soon as you leave the ASCII space. What's beyond it, it's the whole Universe of different rules, collations, normalisations, names, properties, etc.

The good thing is that you do not need to think about all those Unicode internals when just using Raku and when just working with text. For example, converting to upper case has no difference in the code for "street" and "straße".

say "straße".uc;  # STRASSE — one char becomes two
say "ﬃ".uc;      # FFI     — ligature expands
say "🐋".uniname; # WHALE

Diacritics are difficult because a single character (glyph) can be represented differently: say, as two distinct items for the letter and the accent, as well as as a single Unicode entry point. For Raku, it's not difficult at all.

say "e\x[0301]" eq "é"; # True — NFG normalizes on creation
say "é".NFD.list;       # (101 769)
say "é".NFC.list;       # (233)

If you know that Unicode has literally hundreds of characters marked as digits, you may also want to use similar nice characters in the programs. Unicode fractions, Roman numbers, all that has it's meaning and can even be used in place of Arabic digits.

say "½".unival + "⅓".unival;  # 0.833333
say "Ⅻ".unival;              # 12
say "五".unival;              # 5

If you ever learned Greek, you may remember that letter S looks differently depending on the position of the word. Raku knows it out of the box; the final lowercased sigma looks differently indeed:

"ΣΊΣΥΦΟΣ".lc.say # prints σίσυφος

Characters names and properties, even weird, are reachable with ease.

say "\c[ORCA]".uniprop("Age"); # 17.0

Regexes (and thus grammars) are no exception.

say "abc🐋def" ~~ /<:Emoji>/; # ｢🐋｣

A couple of words about Raku++. The first phase of its development was to target the compiler against Roast, which is a huge official test suite of the Raku programming language. In total, Roast includes about 90k tests in the Unicode sections. All of them pass under Raku++. Actually, having proper support of UCD 17 helped to jump from 57% to 82% of Raku coverage, just so huge it is.

And before wrapping up, some homework for you. Below are two variants of the program that solves quadratic equations and — what is important for us today — uses a lot of non-ASCII characters. Well, and some other useful Raku features such as custom operators and junctions.

Variant 1:

sub prefix:<√>($x) {
    $x.sqrt
}
sub infix:<±>($p, $q) is equiv(&infix:<+>) {
    ($p + $q), ($p - $q)
}

my (\a, \b, \c) = 1, -4, 3;
if (my $D = b² − 4 × a × c) ≥ 0 {
    my @roots = (−b ± √$D) »÷» (2 × a);
    say @roots;
}
else {
    say "There are no real solutions";
}

Variant 2:

sub prefix:<√>($x) {
    $x.sqrt
}
sub infix:<±>($p, $q) is equiv(&infix:<+>) {
    ($p + $q) | ($p - $q)
}

my (\a, \b, \c) = 1, -4, 3;
if (my $D = b² − 4 × a × c) ≥ 0 {
    my $roots = (−b ± √$D) ÷ (2 × a);
    say $roots;
}
else {
    say "There are no real solutions";
}

First try to understand what the programs will print, and then run them in the playground. The first variant uses regular arrays to save results, but the in the second program $root is a scalar and it's a junction that keep both roots at the same time.

Raku: a language where 0.1 + 0.2 is 0.3

Andrew Shitov — Sat, 18 Jul 2026 11:48:53 +0000

Programming languages are fascinating. Even if you think that these are the last days when you need to write code yourself, that only gives you more time to enjoy the beauty.

In this article I would like to showcase some of the small but astonishing features of Raku. Even if you never had a chance to install a compiler on your machine, you can run all the examples below in the online Raku playground straight away.

0.1 + 0.2 == 0.3

It is an obvious equation when written on paper, but when you employ floating-point arithmetic, you get a collection of various answers – the price of the trade-off between speed, compactness, and exactness.

In Raku, 0.1 + 0.2 equals 0.3 exactly:

say 0.1 + 0.2 == 0.3;   # True

Run it in the online playground to confirm. In the rest of the article, I will use links like this: 🦋▶ to point you to the playground with the code filled in. All you need is to press the Run button and see the magic.

Similarly, 0.1 + 0.2 - 0.3 is an exact zero. 🦋▶

All this is possible as Raku treats these numbers as belonging to the Rat (rational) type of numbers. 0.1 is a fraction 1/10. 0.2 is the same as 1/5. And while say 1/3 does print a rounded 0.333333, that is only the display: underneath lives the exact ⅓, with the numerator and the denominator in easy reach 🦋▶:

say ⅓.numerator;    # 1
say ⅓.denominator;  # 3

And yes, Unicode fractions are understood, together with any kind of digits 🦋▶:

say ⅷ + ٣;   # 11

The ⅷ here is a single Unicode character – the small Roman numeral eight – and ٣ is the Arabic-Indic digit three, the everyday three for hundreds of millions of people. Raku reads both as the numbers they are.

Superscripts are powers

Raise a number to a power the way your maths teacher wrote it 🦋▶:

say 2⁵;               # 32
say 5² + 12² == 13²;  # True

The second line is the 5–12–13 Pythagorean triple, checked in one readable line.

Integers have no ceiling

An integer in Raku is as long as it needs to be. There is no 64-bit cliff to fall off, no special "big integer" import – the numbers simply grow 🦋▶:

say 2¹⁰⁰;         # 1267650600228229401496703205376
say 10¹⁸ × 10¹⁸;  # 1 followed by 36 zeroes
say [*] 1 .. 100;

The square brackets in the last line are the reduction meta-operator: [*] places * between all the numbers of the range, so you get the factorial of 100 – all 158 digits of it:

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Primality included

Number theory is on board too 🦋▶:

say 97.is-prime;          # True
say (2¹²⁷ − 1).is-prime;  # True

The second number is a Mersenne prime of 39 digits, tested as casually as the small one. Notice the minus sign in 2¹²⁷ − 1: it is not the ASCII hyphen but the true Unicode minus, and Raku is perfectly happy with either.

Operators from the maths textbook

Superscripts are not the only notation rescued from the maths textbook. The multiplication and division signs, and the comparison signs with the slash already crossed through, are all ordinary Raku operators 🦋▶:

say 7 × 6;      # 42
say 10 ÷ 4;     # 2.5
say 1 ≤ 2 ≤ 3;  # True
say 2 ≠ 3;      # True

× and ÷ are the real multiplication and division operators (the ASCII * and / work too, of course). Comparisons chain the way they do in mathematics: 1 ≤ 2 ≤ 3 is a single condition, not a syntax error. And 10 ÷ 4 is the familiar Rat story again – the exact fraction 5/2, whose decimal display 2.5 this time needs no rounding at all.

Chaining also combines with the reduction meta-operator you met at the factorial: put ≤ between the square brackets, and [≤] chains it across every neighbouring pair of a list – a ready-made test that the list is sorted 🦋▶:

say [≤] 1, 2, 5, 9;  # True
say [≤] 3, 1, 2;     # False

π, τ, and ∞

The constants you know from school are predefined 🦋▶:

say π;           # 3.141592653589793
say τ == 2 × π;  # True

(Type pi and tau if the Greek letters are far from your keyboard.) Infinity is a value in its own right: you can compare things with it, and you can build a range of all positive integers and politely take the first five 🦋▶:

say ∞ > 10¹⁰⁰;     # True
say (1 .. ∞)[^5];  # (1 2 3 4 5)

The range is lazy, so nobody attempts to materialise the rest of it.

And when you do want floating point

Floats did not go anywhere – you ask for them with scientific notation 🦋▶:

say 0.1e0 + 0.2e0;  # 0.30000000000000004

0.1e0 is a Num, an honest IEEE double, and with it comes the famous constant from the beginning of this article. Floats remain the right tool for physics and simulations; Raku simply refuses to make them the default meaning of a decimal literal.

Where this runs

Every example above runs in the raku.online playground, which is powered by Raku++, an independent implementation of Raku compiled to WebAssembly – the interpreter works entirely in your browser page. The reference implementation of the language is Rakudo, and everything shown here prints exactly the same on both.

The next article in this series opens the second cabinet of curiosities: Unicode – strings that count a seven-codepoint emoji as one character, a variable named $Δ, and a file called café-☕.txt.

Sorting numbers in Raku with the help of ChatGPT

Andrew Shitov — Fri, 08 Sep 2023 07:57:21 +0000

In this post I will show you the solution to the Task 2 of this week’s Weekly Challenge 233. This time I was using the help of ChatGPT, which offered a very nice solution.

You are given an array of integers.
Write a script to sort the given array in increasing order based on the frequency of the values. If multiple values have the same frequency then sort them in decreasing order.

I asked ChatGPT the following: ‘Create a program. Here is the description of the task.’ To make sure the result is in the Raku programming language, I also added the following instruction in my local settings so that it knows which programming language I prefer by default.

The solution generated by ChatGPT was quite good with a small mistake.

ChatGPT: Sure, here’s a Raku program that implements the described sorting algorithm for the given task:

sub frequency-sort(@arr) {
    my %freq;

    %freq{$_}++ for @arr;
    my @sorted = @arr.sort: {
        %freq{$^b} <=> %freq{$^a} ||
        $^b <=> $^a
    };

    return @sorted;
}

my @ints = (1, 1, 2, 2, 2, 3);
my @sorted = frequency-sort(@ints);

say "Input:  @ints";
say "Output: @sorted";

First, Raku would not interpolate arrays, so say "Input: @ints" prints the string literary: Input: @ints. Second, in the sorting rule, sorting by frequency must be ascending rather than descending, so we need to switch the placeholder variables $^b and $^a.

In the rest, ChatGPT did a good work. It computed the frequency using a loop, and I especially liked how it addressed the requirement to sort by two dimensions.

Here is the full program with the above-mentioned corrections:

sub frequency-sort(@arr) {
    my %freq;
    %freq{$_}++ for @arr;

    my @sorted = @arr.sort: {
        %freq{$^a} <=> %freq{$^b} ||
        $^b <=> $^a
    };

    return @sorted;
}

my @tests =
    (1, 1, 2, 2, 2, 3),
    (2, 3, 1, 3, 2),
    (-1, 1, -6, 4, 5, -6, 1, 4, 1);

say frequency-sort($_) for @tests;

This program prints the following output for the given test cases:

$ raku ch-2.raku
[3 1 1 2 2 2]
[1 3 3 2 2]
[5 -1 4 4 -6 -6 1 1 1]