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]

DEV Community: Andrew Shitov