#!/usr/bin/perl -w
use strict;

my %foo = (
    camshaft   => 'lumpy',
    gearbox    => 'shifty',
    drivetrain => 'speedy',
    smokestack => 'dirty',
    lights     => 'bright eyes',
);
[download]

my %bar;
@bar{ qw/camshaft gearbox1 the_drivetrain _other/ } = '';
[download]

my %map_foo_to_bar = (
    camshaft   => 'camshaft',
    gearbox    => 'gearbox1',
    drivetrain => 'the_drivetrain',
    smokestack => 'my_smokestack',
    junkyard   => '_junkyard',
);
[download]

sub schlep($$$)
{
    my( $map_ref, $from_ref, $to_ref ) = ( shift, shift, shift );
    for( keys %{ $from_ref } )
    {
        $to_ref->{ $map_ref->{$_} } = $from_ref->{$_}
            if( exists $map_ref->{$_} && exists $to_ref->{ $map_ref->{
+$_} } )
    }
}

schlep(\%map_foo_to_bar, \%foo, \%bar);

use Data::Dumper;
print Dumper \%bar;
[download]

~Particle ;Þ

That's surprisingly complicated for what I thought was a simple task:

sub schlep
{
        my ($p,$q,%p2q) = @_;

        @{$q}{values %p2q} = @{$p}{keys %p2q};
}
[download]

Of course, this does assume that values and keys will always output in precisely the same order. Not that I have been given any reason to believe that they would do something to the contrary.

well, this looks simple. i haven't run it, but it looks like it will work if %$p and %$q implement exactly the same keys. my example works on the intersection of keys between %foo and %bar (only the keys both hashes share.) perhaps i solved a more general problem than the original poster requested.

question: what happens to your code if a key exists in %p2q, but not in %$p? my code will not auto-vivify a key in %$q. will yours?

by the way, values and keys are guaranteed to output in the same order (in the same hash.) this is by no means guaranteed in different hashes. see each for a little detail.

~Particle ;Þ

That's guaranteed. In the very docs you point to.

I'm not snide, I'm just bitter that you posted the answer before I did.

schlep(\%other_foo_bucket => $big_foo_bucket,
            qw[
                camshaft        camshaft
                gearbox1        gearbox
                the_drivetrain  drivetrain
                my_smokestack   smokestack
                _junkyard       junkyard
            ]);
[download]

Rather than qw[] you could use a heredoc and have your routine do the splitting. Then you could have:

schlep(\%other_foo_bucket => $big_foo_bucket, <<EOT );
                camshaft        camshaft
                gearbox1        gearbox
                the_drivetrain  drivetrain
                my_smokestack   smokestack
                _junkyard       junkyard
EOT
[download]

I want to say this is mentioned somewhere in the camel, maybe not for this exact problem but for something similar.

Certainly, that is easy from an input perspective, but if one were to have a mapping already prepared, you'd have to convert it into a string before using it. Yuck. qw, despite how ugly it can look, sure works well.

Still, using here-doc style declarations for function params is a very interesting idea.

schlep(\%other_foo_bucket => $big_foo_bucket,

*kvetch = *Carp::carp;
*oyvey  = sub { warn @_ };

sub Shlemiel  { &Shlemazel }
sub Shlemazel { &Shlemiel }

# and of course ...

use Bone::Easy;
pickup $shiksah;
[download]

pickup @shiksahs;
[download]

   MeowChow                                   
               s aamecha.s a..a\u$&owag.print

Would the following be a vague step in the right direction?

my @assignList = qw(camshaft gearbox drivetrain smokestack junkyard);
@{$big_foo_bucket}[@assignList]=@other_foo_bucket[@assignList];
[download]

Still not ideal, but the assignment of the list at least removes the problem of keeping the two in order. I suppose where you want to copy all of the elements of %other_foo_bucket you could have simply assigned @assignList=keys %other_foo_bucket; and it'd happily leave any items in %big_foo_bucket which aren't in %other_foo_bucket alone.

Well, map does come to mind... ;-)

use strict;

# define hash keys that need conversion
# (others will be unchanged)
my %map_foo_to_bar = (
    gearbox    => 'gearbox1',
    drivetrain => 'the_drivetrain',
    smokestack => 'my_smokestack',
    junkyard   => '_junkyard',
);

# our hash data
my %foo = (gearbox        => 'five-speed', 
           drivetrain     => 'automatic', 
           something_else => 'entirely');

# perform the mapping (wrapped in an anonymous hashref)
my $new_name;
my $bar = { 
  map 
    { defined ($new_name = $map_foo_to_bar{$_}) ? 
      ($new_name => $foo{$_}) : 
      ($_        => $foo{$_})
    } 
    (keys %foo) 
  };
[download]

Then from Data::Dumper:

$VAR1 = {
          'the_drivetrain' => 'automatic',
          'something_else' => 'entirely',
          'gearbox1' => 'five-speed'
        };
[download]

I've come to think of map a potential solution whenever I want to apply the same operation to every element of an array or hash. In this case the "same operation" just happens to be a conditional -- if we have a new name defined for a given hash key, then use it, otherwise just keep the original hash key.

YAWTDI -- you could use an anonymous function...

sub { for(map{$_*2} 0..$#_/2) { $bfb->{$_[$_+1]} = $ofb{$_[$_]} }}->(q
+w[camshaft camshaft ...]);
[download]

Or, alternatively:

sub { my%g=@_; for(keys%g) { $bfb->{$g{$_}} = $ofb{$_} }}->(qw[camshaf
+t camshaft ...]);
[download]