in reply to Localizing hash keys in an AoH, continued

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;

[download]

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",
}

[download]

RJT::LocalHash source

package RJT::LocalHash {
    use parent 'Tie::Hash';
    use List::MoreUtils qw/uniq/;
    use Carp;

    sub TIEHASH {
        my ($class, $orig) = @_;
        croak 'Expected HASH ref, not `'.ref($orig)."'"
            unless 'HASH' eq ref $orig;
        bless { orig => $orig, del => { }, new => { } }, $class;
    }
    sub STORE  { delete $_[0]{del}{$_[1]};  $_[0]{new}{$_[1]} = $_[2] 
+ }
    sub EXISTS { not exists $_[0]{del}{$_[1]} and
                 (exists $_[0]{new}{$_[1]} or exists $_[0]{orig}{$_[1]
+}) }
    sub FETCH  { return if exists $_[0]{del}{$_[1]};
                 exists $_[0]{new}{$_[1]} ? $_[0]{new}{$_[1]}
                                          : $_[0]{orig}{$_[1]} }
    sub FIRSTKEY {
        # Initialize the iterator as union of both hash key sets
        # minus anything that's been locally deleted
        my @each = grep { not exists $_[0]{del}{$_} } 
                   uniq keys $_[0]{orig}, keys $_[0]{new};
        $_[0]{each} = \@each;
        shift @each;
    }
    sub NEXTKEY { shift $_[0]{each} }

    sub DELETE {
        $_[0]{del}{$_[1]} = 1;
        $_[0]{new}{$_[1]} // $_[0]{orig}{$_[1]};
    }
}

[download]

Edit: Minor fix to EXISTS.

Replies are listed 'Best First'.
Re^2: Localizing hash keys in an AoH, continued
by kennethk (Abbot) on Jul 22, 2013 at 21:04 UTC
    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;
    }
}

    [download]

    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.

    #11929 First ask yourself `How would I do this without a computer?' Then have the computer do it the same way.

[reply]
[d/l]

In Section Seekers of Perl Wisdom