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 10th 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 5th and 55th 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.
Top comments (0)