Raku Solutions Weekly Review
Task #1: Intersection of Two Straight Lines
This is derived in part from my blog post made in answer to the Week 27 of the Perl Weekly Challenge organized by Mohammad S. Anwar as well as answers made by others to the same challenge.
The challenge reads as follows:
Write a script to find the intersection of two straight lines. The coordinates of the two lines should be provided as command line parameter. For example:
The two ends of Line 1 are represented as coordinates (a,b) and (c,d).
The two ends of Line 2 are represented as coordinates (p,q) and (r,s).
The script should print the coordinates of point of intersection of the above two lines.
Some Background Knowledge on the Subject
This is really elementary math, but, as I haven’t used any linear algebra for decades, I needed about 10 to 15 minutes with a pencil and a piece of paper to work out how to find the equation of a straight line going through two points and how to compute the intersection of two lines. For the benefits of those of you in the same situation, let me briefly summarize how this works. You may jump to the next section if you don’t need any refresher on these subjects.
The equation of a straight line is usually written as y = ax + b
(or, in some countries, y = mx + b
or y = mx + c
, but it’s just the name of the coefficients changing), where x
and y
are the coordinates of any point belonging to the line, a
is the slope (or gradient, i.e. how steep the line is) of the line, and b
the yintercept (the value of y
when x
is zero, or the place where the line crosses the Y
axis). The slope is the change in y
divided by the change in x
. For finding the slope of a line going through two points with coordinates x1, y1
and x2, y2
, the slope a
is the ordinate (y
) difference of the points divided by their abscissa (x
) difference:
a = (y2  y1) / (x2  x1)
Of course, we have a division by zero problem if x2
equals x1
(i.e. the line is vertical, at least in an orthonormal base or Cartesian plane), but we’ll come back to that special edge case later, as this does not necessarily preclude us from finding an interception point.
For finding the yintercept (b
), you just need to reformulate y = ax + b
as b = y  ax
, and to replace a
by the slope found with the above formula, and y
and x
by the coordinates of any of the two points.
For finding the intersection point of two lines y = a1 * x + b1
and y = a2 * x + b2
, you need to figure out that it is the point of the lines for which the ordinate (y
) is the same for an equal value of the abscissa (x
), i.e. write the following equations:
a1 * x + b1 = a2 * x + b2
<=>
(a1  a2) *x = b2  b1
<=>
x = (b2  b1) / (a1  a2)
Once the abscissa x
of the intersection has been found, it is easy to find its ordinate y
using the equation of any of the two lines.
If the lines’ slopes are equal, then the equation above has a division by zero problem, which reflects the fact that the line segments defined by the point pairs are parallel or colinear, meaning that the problem has no solution (there is no intersection point).
My solution
With the above knowledge secured, it is fairly easy to write a Perl 6 program computing the intersection point of two lines defined by two point pairs. The basic algorithm is fairly simple, but it becomes a little bit complicated when we want to tackle all the edge cases (two points which are the same, vertical line, parallel lines, etc.).
There is one slight complication, though: if one (and only one) of the point pairs have points with the same abscissa, we cannot write a linear equation for that pair of points, but the straight line is nonetheless well defined (provided the ordinates are different): it is a vertical line where all point have the same abscissa (x
value). We cannot write an equation for such a line, but may still find the intersection point with the other line: it is the point of that other line having this abscissa. This special case will account for quite a lot of code lines in our solution.
Another observation is that this type of problem calls for objectoriented programming (even though I’m generally not a great OO fan). So, we will define a Point
type and a Segment
class (with two Point
attributes) providing the slope
and yintercept
methods to compute the equation of a line passing through the two points. The Point
role also provides a gist
method enabling pretty printing of the point coordinates when using the say
builtin function on a Point
instance.
use v6;
role Point {
has $.x;
has $.y;
method gist {
return "\n Abscissa: $.x\n Ordinate: $.y.";
}
}
class Segment {
has Point $.start;
has Point $.end;
method slope {
return ($.end.y  $.start.y) / ($.end.x  $.start.x);
}
method yintercept {
my $slope = self.slope;
return $.start.y  $slope * $.start.x;
}
method linecoordinates { # used only for debugging purpose
return self.slope, self.yintercept;
}
}
sub computeintersection (Segment $s1, Segment $s2) {
my $abscissa = ($s2.yintercept  $s1.yintercept) /
($s1.slope  $s2.slope);
my $ordinate = $s1.slope * $abscissa + $s1.yintercept;
my $intersection = Point.new( x => $abscissa, y => $ordinate);
}
multi MAIN ( $a1, $b1, # start of line segment 1
$a2, $b2, # end of line segment 1
$a3, $b3, # start of line segment 2
$a4, $b4 # end of line segment 2
) {
my $segment1 = Segment.new(
start => Point.new(x => $a1, y => $b1),
end => Point.new(x => $a2, y => $b2)
);
my $segment2 = Segment.new(
start => Point.new(x => $a3, y => $b3),
end => Point.new(x => $a4, y => $b4)
);
say "Coordinates of intersection point: ", computeintersection $segment1, $segment2;
}
multi MAIN () {
say "Using default input values for testing. Should display poinr (2, 4).";
my $segment1 = Segment.new(
start => Point.new(x => 3, y => 1),
end => Point.new(x => 5, y => 3)
);
my $segment2 = Segment.new(
start => Point.new(x => 3, y => 3),
end => Point.new(x => 6, y => 0)
);
say "Coordinates of intersection point: ", computeintersection $segment1, $segment2;
}
This is a sample run of the program:
$ perl6 intersection.p6 3 1 5 3 3 3 6 0
Coordinates of intersection point:
 Abscissa: 4
 Ordinate: 2.
As it is, this program isn’t doing any validation on its arguments. So we will add a validargs
subroutine for that purpose and also check that the computed segments are not parallel.
use v6;
role Point {
has $.x;
has $.y;
method gist {
return "\n Abscissa: $.x\n Ordinate: $.y.";
}
}
class Segment {
has Point $.start;
has Point $.end;
method slope {
return ($.end.y  $.start.y) / ($.end.x  $.start.x);
}
method yintercept {
my $slope = self.slope;
return $.start.y  $slope * $.start.x;
}
method linecoordinates {
return self.slope, self.yintercept;
}
}
sub computeintersection (Segment $s1, Segment $s2) {
my $abscissa = ($s2.yintercept  $s1.yintercept) /
($s1.slope  $s2.slope);
my $ordinate = $s1.slope * $abscissa + $s1.yintercept;
my $intersection = Point.new( x => $abscissa, y => $ordinate);
}
multi MAIN ( $a1, $b1, # start of line segment 1
$a2, $b2, # end of line segment 1
$a3, $b3, # start of line segment 2
$a4, $b4 # end of line segment 2
) {
exit unless validargs @*ARGS;
my $segment1 = Segment.new(
start => Point.new(x => $a1, y => $b1),
end => Point.new(x => $a2, y => $b2)
);
my $segment2 = Segment.new(
start => Point.new(x => $a3, y => $b3),
end => Point.new(x => $a4, y => $b4)
);
say "Segments are parallel or colinear." and exit
if $segment1.slope == $segment2.slope;
say "Coordinates of intersection point: ",
computeintersection $segment1, $segment2;
}
multi MAIN () {
say "Using default input values for testing. Should display poinr (2, 4).";
my $segment1 = Segment.new(
start => Point.new(x => 3, y => 1),
end => Point.new(x => 5, y => 3)
);
my $segment2 = Segment.new(
start => Point.new(x => 3, y => 3),
end => Point.new(x => 6, y => 0)
);
say "Coordinates of intersection point: ",
computeintersection $segment1, $segment2;
}
sub validargs ( $a1, $b1, # start of line segment 1
$a2, $b2, # end of line segment 1
$a3, $b3, # start of line segment 2
$a4, $b4 # end of line segment 2
) {
unless @*ARGS.all ~~ /<[\d]>+/ {
say "Non numeric argument. Can't continue.";
return False;
}
if $a1 == $a2 and $b1 == $b2 {
say "The first two points are the same. Cannot draw a line.";
return False;
}
if $a3 == $a4 and $b3 == $b4 {
say "The last two points are the same. Cannot draw a line.";
return False;
}
if $a1 == $a2 and $a3 == $a4 {
say "The two segments are vertical. No intersection.";
return False;
}
if $a1 == $a2 {
# First segment is vertical but not the second one
my $segment2 = Segment.new(
start => Point.new(x => $a3, y => $b3),
end => Point.new(x => $a4, y => $b4)
);
my $ordinate = $segment2.slope * $a1 + $segment2.yintercept;
my $interception = Point.new(x => $a1, y => $ordinate);
say "Coordinates of intersection point: ", $interception;
return False;
}
if $a3 == $a4 {
# Second segment is vertical but not the first one
my $segment1 = Segment.new(
start => Point.new(x => $a1, y => $b1),
end => Point.new(x => $a2, y => $b2)
);
my $ordinate = $segment1.slope * $a3 + $segment1.yintercept;
my $interception = Point.new(x => $a3, y => $ordinate);
say "Coordinates of intersection point: ", $interception;
return False;
}
return True;
}
Running the program with some examples of valid or invalid arguments displays the following:
$ perl6 intersection.p6 3 1 5 3 3 3 n 0
Non numeric argument. Can't continue.
$ perl6 intersection.p6 3 1 5 3 3 3 5.4 0
Coordinates of intersection point:
 Abscissa: 3.888889
 Ordinate: 1.888889.
$ perl6 intersection.p6 3 1 5 3 3 3 6.0 0
Coordinates of intersection point:
 Abscissa: 4
 Ordinate: 2.
$ perl6 intersection.p6 3 1 5 3 6 2 10 6
Segments are parallel or colinear.
$ perl6 intersection.p6 3 1 3 1 3 3 6 0
The first two points are the same. Cannot draw a line.
$ perl6 intersection.p6 3 1 3 2 3 5 3 0
The two segments are vertical. Cannot find an intersection.
Alternate Solutions
My program just above is much longer than most other solutions presented below. The only other quite long program is Joelle Maslak’s, which also happens to be the only other objectoriented solution. This may be a coincidence, but I have the feeling that OO programming often leads to rather verbose solutions. And this is, by the way, one of the reasons why I’m not a great fan of OO programming: it feels a bit like writing Java in Perl 6. Having said that, I should add that most more concise solutions contain long mathematical formulas that are a bit difficult to read and hardly selfdocumenting.
Arne Sommer‘s solution is much shorter than mine, but I’m afraid Arne looked only at some of the edge cases:
my \ta1 = (y3−y4) * (x1−x3) + (x4−x3) * (y1−y3);
my \ta2 = (x4−x3) * (y1−y2) − (x1−x2) * (y4−y3);
my \tb1 = (y1−y2) * (x1−x3) + (x2−x1) * (y1−y3);
my \tb2 = (x4−x3) * (y1−y2) − (x1−x2) * (y4−y3);
my \ta = ta1 / ta2;
my \tb = tb1 / tb2;
if ta2 == 0  tb2 == 0
{
say "Colinear lines";
}
elsif 0 <= ta <= 1 && 0 <= tb <= 1
{
say "Segment intersection at x: { x1 + ta * (x2  x1) } y: { y1 + ta * (y2 − y1) }";
}
else
{
say "General Intersection (outside the box)";
}
Kevin Colyer‘s solution is also shorter than mine but also appears to skip some of the validation. This is the code of Kevin’s subroutine making the real work:
sub intersection($a,$b,$c,$d,$e,$f,$g,$h) {
my $m1=($b$d)/($a$c);
my $m2=($f$h)/($e$g);
return (False,Nil,Nil,"Do not intersect: lines are parallel") if $m1==$m2;
my $x=($f$b+$m1*$a$m2*$e)/($m1$m2);
my $y=$m2*$x$m2*$e+$f;
return (False,Nil,Nil,"Do not intersect: x is not on line 1") if $x < $a < $c or $x > $c > $a;
return (False,Nil,Nil,"Do not intersect: y is not on line 1") if $y < $b < $d or $y > $d > $b;
return (False,Nil,Nil,"Do not intersect: x is not on line 2") if $x < $e < $g or $x > $g > $e;
return (False,Nil,Nil,"Do not intersect: y is not on line 2") if $y < $f < $h or $y > $h > $f;
return (True,$x,$y,"Lines intersect at $x,$y");
}
Markus Holzer also made a very short solution. This is Markus’s main subroutine:
sub intersection( Int \x1, Int \y1, Int \x2, Int \y2, Int \x3, Int \y3, Int \x4, Int \y4 )
{
CATCH { default { fail "Lines are parallel or identical" } }
return (
eager # potential for division by zero,
( (x1 * y2  y1 * x2 ) * (x3  x4)  (x1  x2) * (x3 * y4  y3*x4) ) div
( (x1  x2) * (y3  y4)  (y1  y2) * (x3  x4) ),
eager # without eager, laziness will bite us later
( (x1 * y2  y1 * x2) * (y3  y4)  (y1 y2) * (x3*y4  y3 * x4) ) div
( (x1  x2) * (y3  y4)  (y1  y2) * (x2  x4) )
);
}
Noud has the following very relevant comment:
# Computational geometry is always difficult, because there are so many border
# cases you have to take into account. I hope I covered all of them.
Noud’s main subroutine is as follows:
sub line_intersection(($x1, $y1), ($x2, $y2), ($x3, $y3), ($x4, $y4)) {
if (($x1 == $x2 and $y1 == $y2) or ($x3 == $x4 and $y3 == $y4)) {
die "Input doesn't represent two lines.";
}
my $disc = ($x1  $x2) * ($y3  $y4)  ($y1  $y2) * ($x3  $x4);
if ($disc == 0) {
if ($x1 == $x2 and $x2 == $x3 and $x3 == $x4) {
# Lines coincide vertically. Return one coinciding point.
return ($x1, $y1);
}
if ($y1 == $y2 and $y2 == $y3 and $y3 == $y4) {
# Lines coincide horizontally. Return one coinciding point.
return ($x1, $y1);
}
if (($y1  $x1) * ($x4  $x2) == ($y2  $x2) * ($x3  $x1)) {
# Lines coincide diagonally. Return one coinciding point.
return ($x1, $y1);
}
# If the discriminant is zero, the two lines are parallel to each
# other. Therefore, depending on your definitions the lines don't
# intersect, or they intersect at infinity, introducing a
# nonEuclidian geometry. I choose the latter.
return Inf;
}
# Discriminant is nonzero, hence there is one intersecting point.
return ((($x1 * $y2  $y1 * $x2) * ($x3  $x4)
 ($x3 * $y4  $y3 * $x4) * ($x1  $x2)) / $disc,
(($x1 * $y2  $y1 * $x2) * ($y3  $y4)
 ($x3 * $y4  $y3 * $x4) * ($y1  $y2)) / $disc);
}
Simon Proctor‘s program is also fairly short:
sub MAIN( Rat() \a, Rat() \b, Rat() \c, Rat() \d,
Rat() \p, Rat() \q, Rat() \r, Rat() \s ) {
my \a1 = d  b;
my \b1 = a  c;
my \c1 = a1*(a) + b1*(b);
my \a2 = s  q;
my \b2 = p  r;
my \c2 = a2*(p)+ b2*(q);
my \determinant = a1*b2  a2*b1;
say "Lines ({a},{b}) > ({c},{d}) and ({p},{q}) > ({r},{s})";
if ( determinant == 0 ) {
say "Lines are parallel. No intersection";
} else {
my \x = (b2*c1  b1*c2)/determinant;
my \y = (a1*c2  a2*c1)/determinant;
say "Intersection at ({x},{y})";
}
}
Joelle Maslak‘s code starts with a very interesting and detailed comment about all the edge cases. Well worth reading. Her program is objectoriented and defines a Point
and a Line
classes (both use the CPAN StrictClass
role, which I did not know before and which makes the program choke on unknown attributes). Her Line
class defines five methods and also redefines the eqv
infix operator for Line
objects:
# We need an eqv that works
CORE::<&infix:<eqv>>.add_dispatchee(
multi sub infix:<eqv> (Line:D $line1, Line:D $line2 >Bool) {
return False if $line1.slope ≠ $line2.slope;
# Are both vertical?
if $line1.slope == ∞ and $line2.slope == ∞ {
return $line1.point.x == $line2.point.x;
}
# All other lines
return $line1.point.y == $line2.solvefory($line1.point.x);
}
);
Roger Bell West contributed a fairly concise program (except for his rather verbose way of retrieving the argupments passed to the program):
my @x;
my @y;
@x[1]=shift @*ARGS;
@y[1]=shift @*ARGS;
@x[2]=shift @*ARGS;
@y[2]=shift @*ARGS;
@x[3]=shift @*ARGS;
@y[3]=shift @*ARGS;
@x[4]=shift @*ARGS;
@y[4]=shift @*ARGS;
my $d=(@x[1]@x[2])*(@y[3]@y[4])  (@y[1]@y[2])*(@x[3]@x[4]);
if ($d==0) {
die "Lines are parallel or coincident.\n";
}
my $t=( (@x[1]@x[3])*(@y[3]@y[4])  (@y[1]@y[3])*(@x[3]@x[4]) )/$d;
if $t < 0 or $t > 1 {
die "No intersection.\n";
}
my $u=( (@y[1]@y[2])*(@x[1]@x[3])  (@x[1]@x[2])*(@y[1]@y[3]))/$d;
if $u < 0 or $u > 1 {
die "No intersection.\n";
}
@x[0]=@x[1]+$t*(@x[2]@x[1]);
@y[0]=@y[1]+$t*(@y[2]@y[1]);
say "@x[0] @y[0]";
Ruben Westerberg also suggested a very concise program:
my @l;
while @l < 2 {
my @p=split " ", prompt("Enter line"~(@l+1)~": x1 y1 x2 y2\n"), :skipempty;
if (@p==4) {
push @l, {px=>[@p[0,2]],py=>[@p[1,3]],m=>Any,c=>Any};
}
else {
print "not a valid line! \n";
}
}
for @l {
$_<m>=($_<py>[1]$_<py>[0])/($_<px>[1]$_<px>[0]);
$_<c>=$_<py>[0] ($_<m>*$_<px>[0]);
}
my $x=(@l[0]<c>@l[1]<c>)/( @l[1]<m>@l[0]<m>);
my $y=@l[0]<m>*$x+@l[0]<c>;
put "Intercept point: $x, $y";
Task #2: Displaying Historical Values
This is derived in part from my blog post made in answer to the Week 27 of the Perl Weekly Challenge organized by Mohammad S. Anwar as well as answers made by others to the same challenge.
The challenge reads as follows:
Write a script that allows you to capture/display historical data. It could be an object or a scalar. For example:
my $x = 10; $x = 20; $x = 5;
After the above operations, it should list $x historical value in order.
My Solution
I was very busy during the week of that challenge and was running out of time. Therefore my answers were somewhat minimalist.
I initially tried to redefine the =
assignment operator but that appears to be impossible:
Cannot override infix operator '=', as it is a special form handled directly by the compiler
So, I decided to create my own =:=
assignment operator for watched variables. Besides that, the program uses the WatchedValue
class to enable the storing of current and past values.
use v6;
class WatchedValue {
has Int $.currentvalue is rw;
has @.pastvalues = ();
method getpastvalues {
return @.pastvalues;
}
}
multi sub infix:<=:=> (WatchedValue $y, Int $z) {
push $y.pastvalues, $y.currentvalue;
$y.currentvalue = $z;
}
my $x = WatchedValue.new(currentvalue => 10);
say "Current: ", $x.currentvalue;
$x =:= 15;
say "Current: ", $x.currentvalue;
$x =:= 5;
say "Current: ", $x.currentvalue;
$x =:= 20;
say "Current: ", $x.currentvalue;
say "Past values: ", $x.getpastvalues;
When running the program; I get warnings for each assignment:
Useless use of "=:=" in expression "$x =:= 15" in sink context (line 18)
I do not know how to avoid or suppress these warnings (it seems that the no warnings ...
pragma isn’t implemented yet), but the program otherwise runs correctly and displays the successive values:
Current: 10
Current: 15
Current: 5
Current: 20
Past values: [10 15 5]
Alternate solutions
All challengers except Noud and Yet Ebreo used objects of the builtin Proxy class, which I did not know about before. According to the Perl 6 documentation, a proxy is an object that allows you to set a hook that executes whenever a value is retrieved from a container (FETCH
) or when it is set (STORE
). This is quite obviously the right tool for solving the task at hand. This is the example provided in the official Perl 6 documentation to create a container that returns twice what was stored in it:
sub double() is rw {
my $storage = 0;
Proxy.new(
FETCH => method () { $storage * 2 },
STORE => method ($new) { $storage = $new },
)
}
my $doubled := double();
$doubled = 4;
say $doubled; # OUTPUT: «8
»
Arne Sommer‘s program defines a%hist
hash to store values according to their time stamp, and then defines the memoryvariable
subroutine creating and returning Proxy
object:
sub memoryvariable($label) is rw
{
my $val;
Proxy.new(
FETCH => method ()
{
$val
},
STORE => method ($new)
{
$val = $new;
%hist{$label}.push( Pair(now.Int => $new) );
},
);
}
Arne also defines two additional subroutines, one for displaying the stored historical values and another to output historical values along with the associated time stamp. For example, the second subroutine might display the following:
20191006T17:35:10+02:00: 10
20191006T17:35:10+02:00: 20
20191006T17:35:10+02:00: 15
Kevin Colyer created a HistoryInt
class also using a Proxy
object, storing the historical values in an array attribute (@.history
) of the HistoryInt
class:
class HistoryInt {
has Int $.x =0 ;
has @.history;
method x () is rw {
Proxy.new(
FETCH => > $ { $!x },
STORE => > $, Int $new {
$!x = $new;
@!history.push: $new;
}
)
}
method History () {
@!history;
}
}
Markus Holzer‘s program is extremely concise:
use Scalar::History;
my Int $x := Scalar::History.create(10, Int);
$x = 20;
$x = 5;
thanks to the fact that it uses the Scalar::History module, which he wrote and is still in development stage (it should presumably go to CPAN some time in the future when completed). This module also uses Proxy
objects.
Simon Proctor implemented a Historic
class with a @!values
attribute, implementing various setters and getters and using Proxy
objects. One very interesting point is that he also implemented a Δ=
operator to handle Historic
objects:
multi sub infix:<Δ=> ( Any:U $h is rw, Any $v ) is equiv(&infix:<=>) {
$h = Historic.new();
$h.set( $v );
$h;
}
multi sub infix:<Δ=> (Historic:D $h, Any $a) is equiv(&infix:<=>) {
$h.set($a);
return $h;
}
Joelle Maslak implemented a History
class with the @!hist
and $!data
attributes, also using Proxy
objects:
class History {
has @!hist;
has $!data;
method getproxy() is rw {
my $data := $!data;
my $history := @!hist;
Proxy.new(
FETCH => method () { $data },
STORE => method ($val) { $data = $val; $history.push( $data.clone ) },
);
}
method history() {
my @h = @!hist;
return @h;
}
}
Ruben Westerberg used a @history
array to store the successive values of a Proxy
object:
sub remembering (@history) {
returnrw Proxy.new(
FETCH => method () {@history[*1]},
STORE => method ($new) {;@history.push($new)}
);
}
Noud wrote a program that reads another program and writes a third one. His program takes another program as an argument and parses it to collect information about the variables used in this other script. After that, it creates a %var_hash_
that updates the current values of each of the defined variables after each semicolon. The new script is then executed using the EVAL method. Noud humourously comments that he hopes he doesn’t get banned from the Perl Weekly Challenge club for using the dangerous EVAL
statement in this problem. He certainly shouldn’t be banned, especially not for writing such an innovative solution! It is worth quoting the whole program:
use MONKEYSEENOEVAL;
sub MAIN(Str $filename) {
# Collect all variables in program.
my @variables = ();
for $filename.IO.slurp.split(";") > $line {
my @line_var = ($line ~~ /my\s*\$(\w+)/).values;
if (@line_var.elems > 0) {
@variables = ((@line_var), (@variables));
}
}
my $exec_prog = "";
for $filename.IO.slurp.split(";") > $line {
$exec_prog = "$exec_prog $line\;";
# After every line update %var_hash_ with the current variable values.
for @variables > $x {
$exec_prog = "$exec_prog
if (not DYNAMIC::<\$$x> === Nil) \{
\%var_hash_\.push: ($x => DYNAMIC::<\$$x>)\; \}\;";
}
}
my %var_hash_;
EVAL $exec_prog; # https://xkcd.com/292/
say "Variables history:";
for %var_hash_.kv > $var, @hist {
my @hist_ = @hist.grep({ not $_.^name === "Any" });
if (@hist_.elems > 0) {
print("$var = (");
my $last = @hist_[0];
print("$last");
for @hist_[1..*] > $next {
if ($last != $next) {
print(", $next");
$last = $next;
}
}
print(")\n");
}
}
}
Yet Ebreo created an apparently very simple hist
class with a STORE
method:
class hist {
has @.history;
has $!var handles <Str gist FETCH Numeric>;
method STORE($val) {
push @.history, $val;
$!var = $val;
}
}
my \x = hist.new(history => []);
x = 10;
x = 20;
x = 5;
x = 3.1416;
x = Q[a quick brown fox jumps over the lazy dog];
x = 1e3;
x*= sqrt 3;
.say for x.history;
The code of the hist
class seems very simple, but is in fact pretty clever. I must admit that I don’t fully grasp it: I don’t really understand what the handles
trait does in such context, and I am also not quite sure how this (re)definition of the STORE
subroutine is supposed to work. If any reader wants to explain this, I would be very happy to update this blog post accordingly.
SEE ALSO
Only two blog posts this time (in addition to mine):

Arne Sommer: https://perl6.eu/historicalintersection.html;

Roger Bell West: https://blog.firedrake.org/archive/2019/09/Perl_Weekly_Challenge_27.html.
Wrapping up
Please let me know if I forgot any of the challengers or if you think my explanation of your code misses something important (you can just file an issue against this GitHub page).
If you want to participate to the Perl Weekly Challenge, please connect to this site.