each() is vulnerable. Like it or not, your re-written version is the standard idiom for looping through a hash's key-value pairs when *anything* outside your control could interfere with an each() call.

foreach my $key ( keys %hash ) {
  my $val = $hash{$key};
  ...
}
[download]

To improve readability with your long package names, you might do some combination of these refactorings:

• Move the scope of $val back inside the loop.
• Align the long parts of the first two lines:

  foreach my $key ( keys %some::very::long::named::module::foo ) {
    my $val =            $some::very::long::named::module::foo{$key};
  [download]

• Change the if block to next, or pre-filter the keys through grep().
• Use scoped aliases via globs:

  {
    local *foo  = *some::very::long::named::module::foo;
    local *draw = *some::very::long::named::module::drawSomethingPretty;
    foreach my $key ( grep { testconditions($_) } keys %foo ) {
      drawSomethingPretty( $foo{$key} );
    }
  }
  [download]

• Import the identifiers. If such importing is not supported by the module, then submit a request or a patch to the module author.

  use some::very::long::named::module qw( foo drawSomethingPretty );
  foreach my $key ( keys %foo ) {
    next if not testconditions($key);
    drawSomethingPretty( $foo{$key} );
  }
  [download]

  This is the most "correct" way to handle the issue; it is exactly this issue that Exporter is designed to resolve. Work with the author to nail down this part of the module's API. If direct access to %foo is truely part of the API, then it should definitely be available for import. Otherwise, some accessor method should be provided, or the module docs should make clear a proper path to meet the same needs.

use Data::Dumper;

my %hash1 = ( key1 => 'hello', key2 => 'world' );
my %hash2 = %hash1;

print Dumper \%hash1;
print Dumper \%hash2;
[download]

You could avoid copying the large hash by using a reference:

my $thingy_ref = \%Foo::Bar::Baz::thingy;

foreach my $key ( keys %$thingy_ref ){
    print "$key => $thingy_ref->{ $key }\n";
}
[download]

Erm, then you'd have a reference to the same hash you're trying to avoid resetting the each iterator and the OP would be back to square one. The iterator is a property of the underlying hash, not how it's accessed.

You could make your own iterator.

sub gen_each_iter(\%) {
   my ($hash) = @_;
   my @keys = keys(%$hash);
   return sub {
      return if not @keys;
      my $key = shift(@keys);
      return wantarray ? ($key, $hash->{$key}) : $key;
   };
};

my $each = gen_each_iter(%foo);

while (my ($key, $val) = $each->()) {
   ...
}
[download]

If you don't want a general case solution, the above simplifies to

my @keys = keys(%foo);

my $each = sub {
   return if not @keys;
   my $key = shift(@keys);
   return ($key, $foo{$key});
};

while (my ($key, $val) = $each->()) {
   ...
}
[download]

I would try to copy or alias the ugly names, if export wasn't an option.

# Cruel module author doesn't allow exporting these!
my $foo = 
    \%some::very::long::named::module::foo;
my $drawSomethingPretty =
    \&some::very::long::named::module::drawSomethingPretty;

foreach my $key ( keys %{ $foo } ) {
    # It doesn't look like you need $val out here, so why not
    # just stick in the inner block?
    if ( testconditions($key) ) {
        my $val = $foo->{$key};
        $drawSomethingPretty->($val);
    }
}
[download]

But if these names can't be exported, there are a couple of equally possible likelihoods:

• The module author needs a gentle nudge to allow export of %foo and &drawSomethingPretty;
• The module author had no intention of letting people get at %foo or &drawSomethingPretty and you are poking into the guts of the module rather than the defined interface. Nothing wrong with poking at guts occasionally, but it could be an explanation of why things aren't working right.