Re: stashing an array in a hash and yanking it back out

[Joseph Brenner]

Yes you're right: I could've sworn I tried that in the repl a minute
ago and it worked, but actually it's a no-op and appends nothing to
the hash.

This is okay, doing it the other way (without the inner parens around
the colonpair) is not:

ny %stash;
my @monsters = << godzilla grendel wormface blob >>;
my @rabbits = << bugs peter easter >>;

%stash.append( (:@monsters) );
%stash.append( (:@rabbits) );

say %stash;


On 3/17/20, Vadim Belman  wrote:
>
> Joseph, you've got yourself into a trap I fell into yesterday.
> %stash.append( :@stuff ) syntax is about calling append method with a named
> parameter stuff whereas append works with positionals only. So, your case
> should be written:
>
> %stash.append( (:@stuff) );
>
> Which is apparently more cumbersome. In either case, use of colons is not
> always about saving a character or two. Sometimes it's about readability,
> sometimes about elegance. Overuse is surely bad, but overuse of anything is
> bad, for that matter. :)
>
> Best regards,
> Vadim Belman
>
>> On Mar 17, 2020, at 1:09 PM, Joseph Brenner  wrote:
>>
>>> Though I've no idea what those colons are/are not doing.
>>
>> Those are "colon pairs" (which I've relearned around three times now...):
>>
>>   https://docs.raku.org/language/glossary#index-entry-Colon_Pair
>> 
>>
>> Except for this colon:
>>
>>  %stash.append: (rocks => @rocks);
>>
>> Which is a short hand for this:
>>
>>  %stash.append( (rocks => @rocks) );
>>
>> As an aside: it's a minor style point, but I think a lot of
>> us overuse that trick-- it saves a character, but the explicit
>> parens are more flexible.
>>
>> Notably this works fine, so here it doesn't even save any
>> characters:
>>
>>  %stash.append( :@stuff );
>>
>>
>
>

Re: stashing an array in a hash and yanking it back out

[Vadim Belman]

Joseph, you've got yourself into a trap I fell into yesterday. %stash.append( 
:@stuff ) syntax is about calling append method with a named parameter stuff 
whereas append works with positionals only. So, your case should be written:

%stash.append( (:@stuff) );

Which is apparently more cumbersome. In either case, use of colons is not 
always about saving a character or two. Sometimes it's about readability, 
sometimes about elegance. Overuse is surely bad, but overuse of anything is 
bad, for that matter. :)

Best regards,
Vadim Belman

> On Mar 17, 2020, at 1:09 PM, Joseph Brenner  wrote:
> 
>> Though I've no idea what those colons are/are not doing.
> 
> Those are "colon pairs" (which I've relearned around three times now...):
> 
>   https://docs.raku.org/language/glossary#index-entry-Colon_Pair 
> 
> 
> Except for this colon:
> 
>  %stash.append: (rocks => @rocks);
> 
> Which is a short hand for this:
> 
>  %stash.append( (rocks => @rocks) );
> 
> As an aside: it's a minor style point, but I think a lot of
> us overuse that trick-- it saves a character, but the explicit
> parens are more flexible.
> 
> Notably this works fine, so here it doesn't even save any
> characters:
> 
>  %stash.append( :@stuff );
> 
> 

Re: stashing an array in a hash and yanking it back out

[Joseph Brenner]

> Though I've no idea what those colons are/are not doing.

Those are "colon pairs" (which I've relearned around three times now...):

   https://docs.raku.org/language/glossary#index-entry-Colon_Pair

Except for this colon:

  %stash.append: (rocks => @rocks);

Which is a short hand for this:

  %stash.append( (rocks => @rocks) );

As an aside: it's a minor style point, but I think a lot of
us overuse that trick-- it saves a character, but the explicit
parens are more flexible.

Notably this works fine, so here it doesn't even save any
characters:

  %stash.append( :@stuff );


On 3/16/20, Andy Bach  wrote:
> Vadim clarified for us, off-list:
>> So, you basically needed:
> my %h = :a(1); %h.append: (:b(2));
>
>> Am I correct?
> I think so, I mean, I believe the append method(?) for hashes would solve
> the problem the "whatever star" was attempted to be used for - so:
>> my @monsters = << godzilla grendel wormface blob fingfangfoom tingler >>;
> [godzilla grendel wormface blob fingfangfoom tingler]
>> my @rocks = << marble sandstone granite chert pumice limestone >>
> [marble sandstone granite chert pumice limestone]
>> my  %stash = monsters => @monsters
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
>>  %stash.append: (:rocks(@rocks));
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks =>
> [marble sandstone granite chert pumice limestone]}
> Or:
>> my  %stash = monsters => @monsters
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
>> %stash.append: (:rocks => @rocks);
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks
> True => [marble sandstone granite chert pumice limestone]}
> Or:
>> my  %stash = monsters => @monsters
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
>> %stash.append: (rocks => @rocks);
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks =>
> [marble sandstone granite chert pumice limestone]}
>
> Though I've no idea what those colons are/are not doing.  And we can get to
> those "inner" array elements via
>> say %stash[1]
> sandstone
>
>
>
> 
> From: Vadim Belman 
> Sent: Friday, March 13, 2020 12:50 PM
> To: Andy Bach 
> Cc: William Michels via perl6-users ; Joseph Brenner
> ; Timo Paulssen ; yary
> 
> Subject: Re: stashing an array in a hash and yanking it back out
>
>
> There is no mystery whatsoever.
>
> Consider the following:
>
> my %h = "a", 1; # {a => 1}
>
> Then consider this:
>
> say *, *; # **
>
>
> and also:
>
> say *.VAR.WHAT; # (Whatever)
>
> Taking into account that => has tighter precedence than , what you get in:
>
> my %h = *, a => [1,2,3];
>
> is actually the following data structure:
>
> %( Whatever => Pair )
>
> Regarding your use of postcircumfix [ ] on the data, you use it on Pair.
>
> Best regards,
> Vadim Belman
>
> On Mar 13, 2020, at 11:52 AM, Andy Bach
> mailto:andy_b...@wiwb.uscourts.gov>> wrote:
>
>> my  %stash = monsters => @monsters, rocks => @rocks
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks =>
> [marble sandstone granite chert pumice limestone]}
>> my @more_rocks = << marble sandstone granite chert pumice limestone >>
> [marble sandstone granite chert pumice limestone]
>> my  %stash = *, morerocks => @rocks
> {* => morerocks => [marble sandstone granite chert pumice limestone]}
>> say %stash{*}
> (morerocks => [marble sandstone granite chert pumice limestone])
>
> So, I'm guessing the display
> {* => morerocks => [marble sandstone granite chert pumice limestone]}
>
> really means something like
> {* => (morerocks => [marble sandstone granite chert pumice limestone])}
>
> maybe?
>> say @(%stash{*})
> (morerocks => [marble sandstone granite chert pumice limestone])
>> say @(%stash{*}).[0]
> morerocks => [marble sandstone granite chert pumice limestone]
>> say @(%stash{*}).[1]
> Nil
>> say @(%stash{*}).[0].{morerocks}
> ===SORRY!=== Error while compiling:
> Undeclared routine:
> morerocks used at line 1
>
>> say @(%stash{*}).[0].[0]
> morerocks => [marble sandstone granite chert pumice limestone]
>> say @(%stash{*}).[0].[1]
> Index out of range. Is: 1, should be in 0..0
>   in block  at  line 1
>
>> say @(%stash{*}).[0].[0].perl
> :morerocks(["marble", "sandstone", "granite", "chert", "pumice",
> "limestone"])
>> say @(%stash{*}).[0].perl
> :morerocks(["marble", "sandstone", "granite", "chert", "pumice",
> "limestone"])
>
>
> I dunno.
>
> 
> From: William Michels via perl6-users
> mailto:perl6-users@perl.org>>
> Sent: Thursday, March 12, 2020 5:44 PM
> To: perl6-users mailto:perl6-users@perl.org>>
> Cc: Joseph Brenner mailto:doom...@gmail.com>>; Timo
> Paulssen mailto:t...@wakelift.de>>; yary
> mailto:not@gmail.com>>
> Subject: Re: stashing an array in a hash and yanking it back out
>
> Thanks yary! The code you posted works perfectly.
>
> Okay, one last question. I tried to use the 'DRY' principle to add
> things 

Re: stashing an array in a hash and yanking it back out

[Joseph Brenner]

Thanks, this is indeed the trick:

> Ok, clear enough. This is as simple as:

> %stash.append: (:@greek);



On 3/17/20, Vadim Belman  wrote:
> My reply to Joseph went off the list too. I copy it over here. Here is the
> key quote from Joseph's email I was answering to:
>
> So doing that with append would be like this:
>
>  %stash.append: (:greek(@greek));
>
> William Michels was wondering if there was a way to avoid
> repeating the name twice, speculating that there might be
> some way to do that with a 'whateva' *.
>
> My answer follows:
>
> Ok, clear enough. This is as simple as:
>
> %stash.append: (:@greek);
>
> Roughly, colon op doesn't care about sigils and twigils. It takes a symbol
> and creates a pair with the key of the symbol. A good example with a bit of
> Raku charm:
>
> class Foo {
> has @.attr = ;
> method foo { %(:@.attr) }
> }
> say Foo.new.foo; # {attr => [a b c]}
>
> Best regards,
> Vadim Belman
>
>> On Mar 16, 2020, at 6:44 PM, Andy Bach 
>> wrote:
>>
>> Vadim clarified for us, off-list:
>> > So, you basically needed:
>> my %h = :a(1); %h.append: (:b(2));
>>
>> > Am I correct?
>> I think so, I mean, I believe the append method(?) for hashes would solve
>> the problem the "whatever star" was attempted to be used for - so:
> > my @monsters = << godzilla grendel wormface blob fingfangfoom tingler
> > >>;
> [godzilla grendel wormface blob fingfangfoom tingler]
> > my @rocks = << marble sandstone granite chert pumice limestone >>
> [marble sandstone granite chert pumice limestone]
> > my  %stash = monsters => @monsters
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
> >  %stash.append: (:rocks(@rocks));
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler],
> rocks => [marble sandstone granite chert pumice limestone]}
> Or:
> > my  %stash = monsters => @monsters
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
> > %stash.append: (:rocks => @rocks);
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler],
> rocks True => [marble sandstone granite chert pumice limestone]}
> Or:
> > my  %stash = monsters => @monsters
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
> > %stash.append: (rocks => @rocks);
> {monsters => [godzilla grendel wormface blob fingfangfoom tingler],
> rocks => [marble sandstone granite chert pumice limestone]}
>
>> Though I've no idea what those colons are/are not doing.  And we can get
>> to those "inner" array elements via
>> > say %stash[1]
>> sandstone
>>
>>
>>
>> From: Vadim Belman 
>> Sent: Friday, March 13, 2020 12:50 PM
>> To: Andy Bach 
>> Cc: William Michels via perl6-users ; Joseph Brenner
>> ; Timo Paulssen ; yary
>> 
>> Subject: Re: stashing an array in a hash and yanking it back out
>>
>>
>> There is no mystery whatsoever.
>>
>> Consider the following:
>>
>> my %h = "a", 1; # {a => 1}
>>
>> Then consider this:
>>
>> say *, *; # **
>>
>>
>> and also:
>>
>> say *.VAR.WHAT; # (Whatever)
>>
>> Taking into account that => has tighter precedence than , what you get
>> in:
>>
>> my %h = *, a => [1,2,3];
>>
>> is actually the following data structure:
>>
>> %( Whatever => Pair )
>>
>> Regarding your use of postcircumfix [ ] on the data, you use it on Pair.
>>
>> Best regards,
>> Vadim Belman
>>
>>> On Mar 13, 2020, at 11:52 AM, Andy Bach >> > wrote:
>>>
>>> > my  %stash = monsters => @monsters, rocks => @rocks
>>> {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks
>>> => [marble sandstone granite chert pumice limestone]}
>>> > my @more_rocks = << marble sandstone granite chert pumice limestone >>
>>> [marble sandstone granite chert pumice limestone]
>>> > my  %stash = *, morerocks => @rocks
>>> {* => morerocks => [marble sandstone granite chert pumice limestone]}
>>> > say %stash{*}
>>> (morerocks => [marble sandstone granite chert pumice limestone])
>>>
>>> So, I'm guessing the display
>>> {* => morerocks => [marble sandstone granite chert pumice limestone]}
>>>
>>> really means something like
>>> {* => (morerocks => [marble sandstone granite chert pumice limestone])}
>>>
>>> maybe?
>>> > say @(%stash{*})
>>> (morerocks => [marble sandstone granite chert pumice limestone])
>>> > say @(%stash{*}).[0]
>>> morerocks => [marble sandstone granite chert pumice limestone]
>>> > say @(%stash{*}).[1]
>>> Nil
>>> > say @(%stash{*}).[0].{morerocks}
>>> ===SORRY!=== Error while compiling:
>>> Undeclared routine:
>>> morerocks used at line 1
>>>
>>> > say @(%stash{*}).[0].[0]
>>> morerocks => [marble sandstone granite chert pumice limestone]
>>> > say @(%stash{*}).[0].[1]
>>> Index out of range. Is: 1, should be in 0..0
>>>   in block  at  line 1
>>>
>>> > say @(%stash{*}).[0].[0].perl
>>> :morerocks(["marble", "sandstone", "granite", "chert", "pumice",
>>> "limestone"])
>>> > say @(%stash{*}).[0].perl
>>> :morerocks(["marble", 

Re: stashing an array in a hash and yanking it back out

[yary]

Vadim seems to have provided the definitive answer:

Ok, clear enough. This is as simple as:
> %stash.append: (:@greek);

Fwd: stashing an array in a hash and yanking it back out

[Joseph Brenner]

Sorry, I thought I was replying on list...

I was trying to remind that what William Michels was asking about was
a way to assign an array to a hash field named after the array, but
without manually typing the name twice.

These both work, but aren't what he was asking about:

  %stash{'greek'}= @greek;

   %stash.append: (:greek(@greek));


-- Forwarded message --
From: Joseph Brenner 
Date: Mon, 16 Mar 2020 14:10:01 -0700
Subject: Re: stashing an array in a hash and yanking it back out
To: Vadim Belman 

Vadim Belman wrote:

> So, you basically needed:
>
> my %h = :a(1); %h.append: (:b(2));
>
> Am I correct?
Well, not exactly.

The kind of thing I was doing is stashing the contents of an
array in a hash field with the same name:

  my @greek = << alpha beta gamma >>;
  %stash{'greek'}= @greek;

So doing that with append would be like this:

  %stash.append: (:greek(@greek));

William Michels was wondering if there was a way to avoid
repeating the name twice, speculating that there might be
some way to do that with a 'whateva' *.

My personal take would be that even if there's a way to do that
that I'm missing, it's probably a little too clever.  You can
over do things like "DRY"...  It's pretty clear at a glance what
a line like this is trying to do:

  %stash{'greek'} = @greek;



On 3/16/20, Vadim Belman  wrote:
> So, you basically needed:
>
> my %h = :a(1); %h.append: (:b(2));
>
> Am I correct?
>
> Best regards,
> Vadim Belman
>
>> On Mar 16, 2020, at 11:13 AM, Andy Bach 
>> wrote:
>>
>> > Due to rather weird formatting in your message I hardly can understand
>> > what is it all about.
>> No worries,  I'm often quite befuddling, esp. when I think I'm being
>> extra-clear about things.  I was trying to include enough of the previous
>> thread, in context, to make any replies more coherent.  Then again, I'm
>> using Outlook and I never really know what it's going to do to my outgoing
>> msgs.
>>
>> It wasn't my idea to use the "*", Joseph, the original poster was thinking
>> they could save rekeying (or something) the current contents of the hash
>> by using the "*" in the assignment list, when adding a new pair without
>> specifying the key on the LHS. Whoops, it was William who tried the
>> "whatever star" problem.
>>
  However, (thinking that a 'whatever star' might
 reduce typing), I came up with an odd "ternary" structure. Can anyone
 explain the last line of code, below?

 mbook:~ homedir$ perl6
 To exit type 'exit' or '^D'
 > my @monsters = << godzilla grendel wormface blob fingfangfoom tingler
 > >>;
 [godzilla grendel wormface blob fingfangfoom tingler]
 > my @rocks = << marble sandstone granite chert pumice limestone >>
 [marble sandstone granite chert pumice limestone]
 > my  %stash = monsters => @monsters
 {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
 > my %stash = *, rocks => @rocks;
 {* => rocks => [marble sandstone granite chert pumice limestone]}
>>
>> From: Vadim Belman 
>> Sent: Sunday, March 15, 2020 5:18 PM
>> To: Andy Bach 
>> Cc: William Michels via perl6-users ; Joseph Brenner
>> ; Timo Paulssen ; yary
>> 
>> Subject: Re: stashing an array in a hash and yanking it back out
>>
>> Due to rather weird formatting in your message I hardly can understand
>> what is it all about. But before you can find an answer on how to get the
>> array out of the hash, try answering the following question: why do you
>> use bare asterisk in the hash initialization? What is its purpose over
>> there? To me this looks like the key to all your issues.
>>
>> With regard to Pair type object, there is a little magic about it:
>>
>> my $p = a => [1,2]; say $p;
>>
>> Or, in your case that'd be something like:
>>
>> my %h = *, a => ; say %h<*>;
>>
>> Though I'd still insist on reconsidering how you do things.
>>
>> Best regards,
>> Vadim Belman
>>
>>> On Mar 15, 2020, at 5:41 PM, Andy Bach >> > wrote:
>>>
>>> >> really means something like
>>> {* => (morerocks => [marble sandstone granite chert pumice limestone])}
>>>
>>> > Taking into account that => has tighter precedence than , what you get
>>> > in:
>>> my %h = *, a => [1,2,3];
>>>
>>> > is actually the following data structure:
>>> %( Whatever => Pair )
>>>
>>> That's sort of what I said, or, at least, saw.
>>> > Regarding your use of postcircumfix [ ] on the data, you use it on
>>> > Pair.
>>>
>>> Not quite sure what this means, but is that how you'd get the [>> rocks>] array from %stash? I could get the pair back, but not the "inner"
>>> array of the pair's 2nd partner, so to speak:
>>> >> say @(%stash{*})
>>> (morerocks => [marble sandstone granite chert pumice limestone])
>>> >> say @(%stash{*}).[0]
>>> morerocks => [marble sandstone granite chert pumice limestone]
>>> >> say @(%stash{*}).[1]
>>> Nil
>>> >> say @(%stash{*}).[0].{morerocks}
>>> ===SORRY!=== Error while compiling:
>>> Undeclared routine:
>>>

Re: stashing an array in a hash and yanking it back out

[Vadim Belman]

My reply to Joseph went off the list too. I copy it over here. Here is the key 
quote from Joseph's email I was answering to:

So doing that with append would be like this:

 %stash.append: (:greek(@greek));

William Michels was wondering if there was a way to avoid
repeating the name twice, speculating that there might be
some way to do that with a 'whateva' *.

My answer follows:

Ok, clear enough. This is as simple as:

%stash.append: (:@greek);

Roughly, colon op doesn't care about sigils and twigils. It takes a symbol and 
creates a pair with the key of the symbol. A good example with a bit of Raku 
charm:

class Foo { 
has @.attr = ; 
method foo { %(:@.attr) } 
}
say Foo.new.foo; # {attr => [a b c]}

Best regards,
Vadim Belman

> On Mar 16, 2020, at 6:44 PM, Andy Bach  wrote:
> 
> Vadim clarified for us, off-list:
> > So, you basically needed:
> my %h = :a(1); %h.append: (:b(2));
> 
> > Am I correct?
> I think so, I mean, I believe the append method(?) for hashes would solve the 
> problem the "whatever star" was attempted to be used for - so:
 > my @monsters = << godzilla grendel wormface blob fingfangfoom tingler >>;
 [godzilla grendel wormface blob fingfangfoom tingler]
 > my @rocks = << marble sandstone granite chert pumice limestone >>
 [marble sandstone granite chert pumice limestone]
 > my  %stash = monsters => @monsters
 {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
 >  %stash.append: (:rocks(@rocks));
 {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks 
 => [marble sandstone granite chert pumice limestone]}
 Or:
 > my  %stash = monsters => @monsters
 {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
 > %stash.append: (:rocks => @rocks);
 {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks 
 True => [marble sandstone granite chert pumice limestone]}
 Or:
 > my  %stash = monsters => @monsters
 {monsters => [godzilla grendel wormface blob fingfangfoom tingler]}
 > %stash.append: (rocks => @rocks);
 {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks 
 => [marble sandstone granite chert pumice limestone]}
 
> Though I've no idea what those colons are/are not doing.  And we can get to 
> those "inner" array elements via
> > say %stash[1]
> sandstone
> 
> 
> 
> From: Vadim Belman 
> Sent: Friday, March 13, 2020 12:50 PM
> To: Andy Bach 
> Cc: William Michels via perl6-users ; Joseph Brenner 
> ; Timo Paulssen ; yary 
> 
> Subject: Re: stashing an array in a hash and yanking it back out
>  
> 
> There is no mystery whatsoever.
> 
> Consider the following:
> 
> my %h = "a", 1; # {a => 1}
> 
> Then consider this:
> 
> say *, *; # **
> 
> 
> and also:
> 
> say *.VAR.WHAT; # (Whatever)
> 
> Taking into account that => has tighter precedence than , what you get in:
> 
> my %h = *, a => [1,2,3];
> 
> is actually the following data structure:
> 
> %( Whatever => Pair )
> 
> Regarding your use of postcircumfix [ ] on the data, you use it on Pair.
> 
> Best regards,
> Vadim Belman 
> 
>> On Mar 13, 2020, at 11:52 AM, Andy Bach > > wrote:
>> 
>> > my  %stash = monsters => @monsters, rocks => @rocks
>> {monsters => [godzilla grendel wormface blob fingfangfoom tingler], rocks => 
>> [marble sandstone granite chert pumice limestone]}
>> > my @more_rocks = << marble sandstone granite chert pumice limestone >>
>> [marble sandstone granite chert pumice limestone]
>> > my  %stash = *, morerocks => @rocks
>> {* => morerocks => [marble sandstone granite chert pumice limestone]}
>> > say %stash{*}
>> (morerocks => [marble sandstone granite chert pumice limestone])
>> 
>> So, I'm guessing the display
>> {* => morerocks => [marble sandstone granite chert pumice limestone]}
>> 
>> really means something like
>> {* => (morerocks => [marble sandstone granite chert pumice limestone])}
>> 
>> maybe?
>> > say @(%stash{*})
>> (morerocks => [marble sandstone granite chert pumice limestone])
>> > say @(%stash{*}).[0]
>> morerocks => [marble sandstone granite chert pumice limestone]
>> > say @(%stash{*}).[1]
>> Nil
>> > say @(%stash{*}).[0].{morerocks}
>> ===SORRY!=== Error while compiling:
>> Undeclared routine:
>> morerocks used at line 1
>> 
>> > say @(%stash{*}).[0].[0]
>> morerocks => [marble sandstone granite chert pumice limestone]
>> > say @(%stash{*}).[0].[1]
>> Index out of range. Is: 1, should be in 0..0
>>   in block  at  line 1
>> 
>> > say @(%stash{*}).[0].[0].perl
>> :morerocks(["marble", "sandstone", "granite", "chert", "pumice", 
>> "limestone"])
>> > say @(%stash{*}).[0].perl
>> :morerocks(["marble", "sandstone", "granite", "chert", "pumice", 
>> "limestone"])
>> 
>> 
>> I dunno.
>> 
>> From: William Michels via perl6-users > >
>> Sent: Thursday, March 12, 2020 5:44 PM
>> To: perl6-users mailto:perl6-users@perl.org>>
>> Cc: Joseph Brenner