Affecting a value to a multilevel hash in one inst

Question

I am looking for a more effective way to write this affect subroutine in perl:

#!/usr/bin/perl
use 5.010;
use strict;

my @keys = qw/foo bar baz/;
my %hash = ( foo => {babel => 'fish'} );

affect (\%hash, 42);

sub affect {
   my $ref = shift;
   $ref = $ref->{$keys[$_]} //= {} for (0.. $#keys - 1);
   $ref->{$keys[$#keys]} = shift;
}

use Data::Dumper;
print Dumper \%hash;

And the expected result:

$VAR1 = {
          'foo' => {
                     'bar' => {
                                'baz' => 42
                              },
                     'babel' => 'fish'
                   }
        };

I was thinking about things like this, but obviously it can't work like this:

%hash{ @keys } = 42;

Any idea?

Answer 1

it would be more effective if you actually passed the keys to it! Let's make it an lvalue sub at the same time.

sub dive_val :lvalue {
   my $p = \shift;
   $p = \( $$p->{$_} ) for @_;
   $$p
}

my %hash;
dive_val(\%hash, qw( foo babel )) = 'fish';
dive_val(\%hash, @keys) = 42;

There are two added advantages to this implementation.

First, you can use it to peek into the data structure.

print(dive_val($hash, @keys), "\n");

Second, it will autovivify its first argument.

my $hash;
dive_val($hash, @keys) = 42;

This function already exists as Data::Diver's DiveVal.

use Dive::Val qw( DiveVal );

DiveVal(\%hash, map \$_, @keys) = 42;

---

Comparison of the flow of affect and dive_val:

• affect

  $ref is a reference to a hash.

  Pre-loop:            $ref references %hash
  After loop pass 0:   $ref references %{ $hash{$key[0]} }
  After loop pass 1:   $ref references %{ $hash{$key[0]}{$key[1]} }
  Post loop uses:      $ref->{$key[2]}
  

• dive_val

  $p is a reference to a scalar.

  Pre-loop:            $p references $hash
  After loop pass 0:   $p references $hash->{$key[0]}
  After loop pass 1:   $p references $hash->{$key[0]}{$key[1]}
  After loop pass 2:   $p references $hash->{$key[0]}{$key[1]}{$key[2]}
  Post loop uses:      $$p
  

dive_val's approach is purer.

• There's no need to create the hash before it's dereferenced (unlike affect which creates it in the previous loop pass).
• In fact, the scalar doesn't need to be in a hash at all. This means dive_val could easily be extended to support mixed array/hash structures.
• There's no need to treat the root specially (if you want to accept a potentially undefined argument).
• There's no need to treat the last key specially.