Perl Weekly Challenge 108: Memory Layout and Bell Numbers

One way to let me improve my knowledge about Raku (aka Perl 6) is to implement programs in it. Unluckily, I don’t have any production code to implement in Raku yet (sob!). So, why not try solving the Perl Weekly Challenge tasks?

In the following, the assigned tasks for Challenge 108.

• Task 1
• Task 2

PWC 108 - Task 1

The first task required to print out the memory location of a defined variable. This is quite simple in both Raku and Perl, at least as the virtual machine provides information about the memory address.
In Raku there is the WHERE method that can be invoked on every object to get the memory address value, even if this is know to be unstable: the memory location could change depending on the garbage collection.
In any case, the resulting program is something like:

sub MAIN() {
    my Int $my-variable = 10;
    "%s @ %0xs (%d)".sprintf( $my-variable.^name, 
                              $my-variable.WHERE, 
                              $my-variable.WHERE )
                   .say;
}

That produces an output like the following:

% raku ch-1.p6  
Int @ 7f1b988ed2c8s (139756500341448)

There is much more boilerplate code to print out the values than computing them!

PWC 108 - Task 2

This task was about computing Bell Numbers. I decided to go straight to the implementation by means of triangles. The idea is to build up a triangle where each row is computed on values depending on the previous row. At the end, leftmost values of each row represent Bell Numbers.
The program results in something like the following:

sub MAIN( Int :$base = 15 ) {

    # initialize the array used to compute Bell Numbers
    my @triangle = triangles( 1 );

    # compute all the triangle rows up to the base
    @triangle.push: triangles( $_, @triangle ) for 2 .. $base;

    # extract all the leftmost numbers of every row
    my @bell-numbers.push:  @triangle[ $_ ].head for 0 ..^ @triangle.elems;

    # all done, print out
    say "$base first Bell Numbers:";
    @bell-numbers.join( "\n" ).say;
}

The idea is to recursively compute every row of the @triangle by means of invoking the triangles function. Then I iterate on every row and extract the .head of the array stored on each row, that means getting the leftmost value, putting each of them in @bell-numbers. And last, I do print every number.
I defined the triangles function as a multi sub, because there are two particular cases: 0 and 1 always return a single value. Therefore:

multi sub triangles( 0 ) { return 1; }
multi sub triangles( 1 ) { return 1; }
multi sub triangles( Int $base where { $base > 1 }, @triangle ) {
    # since $base starts from 2, the previous row is
    # 0, so $base - 2
    my @previous-row = | @triangle[ $base - 2 ];

    # add the leftmost element of this row
    my @current-row.push: @previous-row.tail;

    # iterate and compute the diagonal sum
    for 1 ..^ $base {
        @current-row.push: ( @previous-row[ $_ - 1 ] + @current-row[ $_ - 1 ] );
    }

    return @current-row;
}

As you can see, to compute a non-trivial row I extract the @previous-row from the @triangle (assuming every row is an array), and the leftmost value is the last (i.e., rightmost) value of the previous row. Then I compute right values of the @current-row by summing values in diagonal with respect to the previous and current row. This is a simple straightforward implementation of the triangle.