> On Jul 19, 2020, at 3:02 PM, Joseph Brenner <doom...@gmail.com> wrote:
>
> I was thinking about the cross-product operator the other day,
> and I was wondering if there might be a convenient way of
> filtering the resulting cartesian product to do something like a
> database inner join:
>
> my @level = ( godzilla => 9 , gremlin => 3, hanuman => 5 );
> my @origin = ( godzilla => 'jp', tingler => 'us', hanuman => 'il' );
>
> my @results = ( @level X @origin ).grep({ $_[0].keys eq $_[1].keys });
> say @results; # ((godzilla => 6 godzilla => jp) (hanuman => 5
> hanuman => il))
—snip--
This is a neat idea, but it will scale very poorly.
If you had 3 arrays instead of 2, and just 20 pairs in each array instead of 3,
Raku would generate 8000 pairs, which would then be filtered down to 20 at most.
This should behave better, and be almost as concise:
my %monster = (|@level, |@origin)
.classify( {.key}, :as{.value} )
.grep({ .value.elems == 2 }); # The `grep` filters to become like an inner
join.
say .key.fmt('%7s => '), .value.raku for %monster.sort;
printf "%12s: level: %-2d origin: %3s\n", .key, |.value for %monster.sort;
> Is there some neater way of doing this that I'm missing?
Your line:
my %joined2 =| @results.map({ $_[0].keys => .map({ .values }).flat });
can be re-written as:
my %joined2 = @results.map: { .[0].key => .list».value };
BTW, I initially missed that “inner join” was an important factor, and locked
in on the use of "parallel arrays" (which I spoke of as a Code Smell at TPC
this year)
So, I wrote this:
sub parallel_arrays_to_HoH ( *@pairs ) {
my %r;
for @pairs -> ( :key($attribute_name), :value(@main_key_attr_value_pairs) )
{
%r{.key}{$attribute_name} = .value for @main_key_attr_value_pairs;
}
for %r.values <-> %subhash {
%subhash{$_} //= Any for @pairs».key;
}
return %r;
}
, which produces outer-joined HashOfHashes. It is not as succinct, but is
encapsulated and reusable.
The HoH is easily filtered to produce a inner join.
Usage example:
my @level = godzilla => 9 , gremlin => 3, hanuman => 5;
my @origin = godzilla => 'jp', tingler => 'us', hanuman => 'il';
my %outer_joined_monster = parallel_arrays_to_HoH( (:@level), (:@origin) ); #
Those parens are required.
say .key.fmt('%7s => '), .value.raku for %outer_joined_monster.sort;
my %inner_joined_monsters = %outer_joined_monster.grep:
*.value.values».defined.all.so;
printf "%12s: level: %-2d origin: %3s\n", .key, .value<level origin> for
%inner_joined_monsters.sort;
Produces:
godzilla => ${:level(9), :origin("jp")}
gremlin => ${:level(3), :origin(Any)}
hanuman => ${:level(5), :origin("il")}
tingler => ${:level(Any), :origin("us")}
godzilla: level: 9 origin: jp
hanuman: level: 5 origin: il
—
Hope this helps,
Bruce Gray (Util of PerlMonks)
