Localizing hash keys in an AoH, continued

[kennethk]

This is a follow up to Localizing hash keys in an AoH. tobyink's suggestion of guards has worked well, until I discovered I'd naively used the code in a case where I actually needed to delete the hash key/value pair when scope exited, instead of just restoring a value. I cobbled together the code

sub localised_hashvalue {
    package localised::hashvalue;
    my ($ref, $key, $value) = @_;
    my $exist = exists $ref->{$key};
    my $old   = $ref->{$key};
    $ref->{$key} = $value;
    return bless [$ref, $key, $exist, $old];
    sub DESTROY {
        my ($ref, $key, $exist, $old) = @{+shift};
        $ref->{$key} = $old;
        delete $ref->{$key} if !$exist;
    }
}

which performs the necessary function, albeit in a clunkier-feeling way. The target hashrefs in the array are cross-referenced in a couple ways, so I really do need to localize the value in the hashref (as opposed to localizing an array slice and inserting duplicate hashrefs). Any ideas? Obviously this is more academic, since I have functioning code.

[rjt]

I suppose it depends what you mean by "clunkier way". Your sub is reasonably compact, although the usage becomes somewhat cumbersome. Here's an alternative that creates a tie'd hash allowing arbitrary localized manipulation (without the need for actual scope, though you still can, of course). The original hash is not affected by changes to the tied hash, but the tied hash will be affected by changes made to the original one, in case you need to affect some data globally. The semantics of all of this can be changed pretty easily.

#!/usr/bin/env perl

use 5.012;
use warnings;

use Data::Dump qw/dump/;

my %hash = (
    some    => 'original',
    keys    => 'for reference',
);

tie my %local, 'RJT::LocalHash', \%hash;

$local{foo} = 'bar';
delete $local{some};
$local{keys} =~ y/e/E/; # Still uses FETCH
$hash{both} = 'Operations on original hash affect both';

dump \%local;
dump \%hash;

Output:

{
  # tied RJT::LocalHash
  both => "Operations on original hash affect both",
  foo  => "bar",
  keys => "for rEfErEncE",
}
{
  both => "Operations on original hash affect both",
  keys => "for reference",
  some => "original",
}

RJT::LocalHash source

Read more... (2 kB)

[kennethk]

Thanks for the response. The information flow seems off from my needs based upon how I'm looking at your code, but somehow it shook loose the idea of performing the localization on the full hash, and not trying to compound it with setting keys. That gave me this:

sub localised {
    package localised;
    use Scalar::Util 'reftype';

    my $ref = shift;
    my $reftype = reftype $ref or die "$ref is not a reference";
    my @old = $reftype eq 'SCALAR' ? $$ref
            : $reftype eq 'ARRAY'  ? @$ref
            : $reftype eq 'HASH'   ? %$ref
            : die sprintf "Unsupported reftype %s", reftype $ref;
    return bless [$ref, @old];
    
    sub DESTROY {
        my ($ref, @old) = @{+shift};
        my $reftype = reftype $ref;
        $reftype eq 'SCALAR' ? ($$ref)
      : $reftype eq 'ARRAY'  ?  @$ref
      :                         %$ref  = @old;
    }
}

I feel like there may be a reasonable way to roll optional assignment in there simultaneously, but cleanly and across data types is escaping me.

I've never been a big user of tie, so thank you for giving something to chew on. I can vaguely see how a full understanding of how to implement this in tie combined with guards would result in a really swanky solution, but my brain is too stupid today to implement that one.