Perl hash referencing itself at declaration - perl

Question

When declaring a Perl hash, I'm wondering if it's possible to use a value that was assigned earlier in the declaration.
I'd like to do the equivalent of this, all in one shot:
my %H = (something => generateString());
$H{foo} = $H{something} . "/FOO",
$H{bar} = $H{something} . "/BAR",
I can imagine something like this:
my %H = (
something => generateString(),
foo => $_{something} . "/FOO",
bar => $_{something} . "/BAR",
);
EDIT: To be clear, I don't care about an actual reference to $H{something} (i.e. changing $H{something} later shouldn't affect $H{foo}). I'd just like to get its value into the string concatenations.

Answer 1

You seem to think there are two assignment operators in
%H = ( a=>1, b=>$H{a} );
There isn't. Keep in mind the above is identical to
%H = ( 'a', 1, 'b', $H{a} );
There's one assignment operator, and before you can perform the assignment, you need to know what is going to be assignment.
What I'm saying is that the real problem with %H = ( a=>1, b=>$H{a} ); isn't one of scope; the real problem is that nothing been assigned to %H when you do $H{a}[1]. As such, $_{a} makes more sense than $H{a}.
The solution is simple:
my $something = generateString();
my %H = (
something => $something,
foo => "$something/FOO",
bar => "$something/BAR",
);
%H hasn't even been created yet!

Answer 2

my %H = (something => generateString());
%H = (%H,
foo => $H{something} ."/FOO",
bar => $H{something} ."/BAR",
);
seems reasonable, but if you want it in one shot at ANY cost,
use strict;
use warnings;
%{ $_->{hash} } = (
something => $_->{thing},
foo => "$_->{thing}/FOO",
bar => "$_->{thing}/BAR",
)
for {hash => \my %H, thing => generateString()};
which can be translated to more verbose version,
my %H;
local $_ = {hash => \%H, thing => generateString()};
%{ $_->{hash} } = (
something => $_->{thing},
foo => "$_->{thing}/FOO",
bar => "$_->{thing}/BAR",
);

Answer 3

As ikegami says, there is only one assignment operation; it is executed after the entire right hand side is evaluated.
A couple alternatives:
my %H = map {;
'something' => $_,
'foo' => "$_/FOO",
'bar' => "$_/BAR",
} generateString();
and
use Memoize;
memoize('generateString');
my %H = (
'something' => scalar(generateString()),
'foo' => generateString() . '/FOO',
'bar' => generateString() . '/BAR',
);
(scalar needed because otherwise, memoize will make separate calls for list and scalar context.)

Answer 4

An alternative is to do the definition as part of the assignments:
my %H = (
something => ( local our $str=generateString() ),
foo => qq{$str/FOO},
bar => qq{$str/BAR}
);
There are two things to consider:
Notice the use of local our instead of my
I advise against this. For many reasons; if not for best coding practices, but for bugs that may be introduced.
I feel that defining a variable outside the hash definition (as shown in Ikegami's answer) is the best way to go for many reasons, but I realize that's also not the question being asked. The answer to the question is that a hash cannot be referenced before it is created and during creation it is not exposed within the constructor.