#non shared hash version
my %abc;

my @parents = qw( a b c );
my @children = qw( 1 2 3 4 );

for my $parent ( @parents )
{
  for my $child ( @children )
  {
      $abc{ $parent }{ $child } = 1;
  }
}
[download]

# shared hash version.
my %abc : shared ;

my @parents = qw( a b c );
my @children = qw( 1 2 3 4 );

for my $parent ( @parents )
{
  unless (exists $abc{$parent})
  {
    my %p : shared;
    $abc{ $parent } = \%p;
  }
  
  for my $child ( @children )
  {
      unless ( exists $abc{$parent}{$child} )
      {
        my %c : shared;
        $abc{$parent}{$child}=\%c;
      }
      $abc{ $parent }{ $child } = 1;
  }
}
[download]

Very good explanation, thanks!

But in the second example this

...
      unless ( exists $abc{$parent}{$child} )
      {
        my %c : shared;
        $abc{$parent}{$child}=\%c;
      }
...
[download]

looks like an superficial assignment of $abc{ $parent }{ $child } since immediately thereafter the reference \%c is overwritten by a scalar. For two levels of hashing two shared hashes should be enough (%abc and %p).

So for this example the following minimal version should work as well:

# shared hash version.
my %abc : shared ;

my @parents = qw( a b c );
my @children = qw( 1 2 3 4 );

for my $parent ( @parents )
{
  unless (exists $abc{$parent})
  {
    my %p : shared;
    $abc{ $parent } = \%p;
  }
  
  for my $child ( @children )
  {
      $abc{ $parent }{ $child } = 1;
  }
}
[download]

For all Perl people who got a bit confused by the example code like I was...

Or just:

my @parents = qw( a b c );
my @children = qw( 1 2 3 4 );
my %abc :shared;

%{ $abc{ $_ } //= &share({}) } = map{ $_ => 1 } @children for @parents
+;

pp \%abc;
[download]

Which prints:

do {
  my $a = {
    # tied threads::shared::tie
    a => {
           # tied threads::shared::tie
           1 => 1,
           2 => 1,
           3 => 'fix',
           4 => 'fix',
         },
    b => {
           # tied threads::shared::tie
           1 => 1,
           2 => 1,
           3 => 'fix',
           4 => 'fix',
         },
    c => {
           # tied threads::shared::tie
           1 => 1,
           2 => 1,
           3 => 'fix',
           4 => 'fix',
         },
  };
  $a->{a}{3} = $a->{a}{1};
  $a->{a}{4} = $a->{a}{2};
  $a->{b}{3} = $a->{b}{1};
  $a->{b}{4} = $a->{b}{2};
  $a->{c}{3} = $a->{c}{1};
  $a->{c}{4} = $a->{c}{2};
  $a;
}
[download]

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

I'm with torvalds on this Agile (and TDD) debunked I told'em LLVM was the way to go. But did they listen!

This method tested work, thanks a lot.