To convert a hashref to a hash you can dereference it. e.g.:

my %hash1 = %{$href};
my %hash2 = %$href;

my %subhash = %{$href->{subhash}};
[download]

If you are using a recent perl then you might also consider postfix dereferencing. No examples as I have not tried it yet (not for any particular reason).

And if you want an alias then use the refaliasing feature. This avoids making a copy of the hash (albeit a shallow one since perl copies the top level and keeps the inner references as-is).

use experimental qw /refaliasing/;
\my %hash = $href;
[download]

No examples as I have not tried it yet (not for any particular reason).

It's pretty simple:

# Old-style dereferencing:

my %hash  =  %$ref;
my %hash  =  %{ $ref };

# New-style dereferencing:

my %hash  =  $ref->%*;
[download]

In most projects I use the old style because I'm familiar with it, and I often need compatibility with older Perls. I do agree that the new style is usually more readable (despite having more punctuation characters).

Hire me at Toby Ink Ltd or Join my OnlyFans

I do agree that the new style is usually more readable

For me, old style dereferencing makes a bit more sense in my head when reading the code. Mostly, because for me dereferencing reads more like a type conversion/math operation:

# "The integer of $x"
my $foo = int($x);

# "The square root of $x"
my $foo = sqrt($x);

# "The reference of %x"
my $foo = \%x;

# "The dereferenced hash of $x"
my %foo = %{$x};
[download]

It also feels more in line with how variable types (scalar, hash, array) are typical denoted in perl, with the "classic" dereferenced hash starting with a correct %, whereas the new style feels more akin of "a scalar changing into a hash in the middle of the variable name".

But that's just my personal preferences.

PerlMonks XP is useless? Not anymore: XPD - Do more with your PerlMonks XP

maybe too early in the morning and low coffeine level still, but.. what's wrong with Storable#EXAMPLES?

use Storable qw(store retrieve freeze thaw dclone);
 
%color = ('Blue' => 0.1, 'Red' => 0.8, 'Black' => 0, 'White' => 1);
 
store(\%color, 'mycolors') or die "Can't store %a in mycolors!\n";
 
$colref = retrieve('mycolors');
die "Unable to retrieve from mycolors!\n" unless defined $colref;
printf "Blue is still %lf\n", $colref->{'Blue'};
[download]

L*

Note the following from Storable documentation:

Note that freezing an object structure and immediately thawing it actu
+ally achieves a deep cloning of that structure:
[download]

You are in for big surprises and bugs because you try to avoid the "blasted -> operators".

bw, bliako

You did get a reference (not a hash), but you did pass a reference (not a hash).

Anyway, you can use

use experimental qw( refaliasing declared_refs );

my \%foo = retrieve( ... );
[download]

my \%foo = retrieve( ... );
[download]

This gives you the returned hash itself, instead of copying the returned hash into a new hash. It's faster, and it maintains reference cycles.

Oops, I missed that someone had mentioned this.

How about

my %hash = %{ retrieve( 'whatever' ) };