for my $d (sort {$a cmp $b} keys %{{map {$_ => $hash{$_}{desc}} keys %
+hash}} ) {
   ...
   ...
}
[download]

my %descs = map { $_ => $hash{$_}{desc} } keys %hash;

for my $d ( sort keys %descs ) {
   ...
   ...
}
[download]

my %descs = map { $_ => $hash{$_}{desc} } keys %hash;

for my $d ( sort { $descs{$a} cmp $descs{$b} } keys %desc ) {
   ...
   ...
}
[download]

Update: On the other hand, why are you building a hash at all??

my %descs = map { $_ => $hash{$_}{desc} } keys %hash;

for my $d ( sort { $descs{$a} cmp $descs{$b} } keys %descs ) {
   my $desc = $descs{$d};
   ...
}
[download]

for my $d ( sort { $hash{$a}{desc} cmp $hash{$b}{desc} } keys %hash ) 
+{
   my $desc = $hash{desc}{$d};
   ...
}
[download]

if i wanted to use



my %descs = map { $_ => $hash{$_}{desc} } keys %hash;

for my $d ( sort keys %descs ) {
   ...
   ...
}
[download]


i had written that.
The question was about not using an explicit intermediate hash.
Thanks anyway for your contribute

Schwartzian transform

for my $d ( map { $_->[0] }
              sort { $a->[1] cmp $b->[1] }
                map { [ $_, $hash{$_}{desc} ] }
                  keys %hash )
{
   

}
[download]

Simpler and faster:

for my $d ( sort { $hash{$a}{desc} cmp $hash{$b}{desc} }
                keys %hash )
{
   

}
[download]

To expand on ikegami's response, using a Schwartzian Transform only makes sense when the item(s) by which to sort is/are obtained by some expensive transformation. That transformation gets repeated many times for each element being sorted as the sort algorith moves it into the right place by successive comparisons with other elements. There was no transformation required in your code as $hash{$_}{desc} could be accessed directly.

Consider the following two code snippets that sort files by modification time (requiring an lstat call, our expensive transformation). Note the timings; using Benchmark would be better but this was just a quick example.

knoppix@Knoppix:~$ time perl -Mstrict -wle '
-> my $d = q{/usr/bin};
-> my @fns = do { opendir my $dh, $d or die $!; readdir $dh };
-> my @sorted =
->    sort { ( lstat qq{$d/$a} )[ 9 ] <=> ( lstat qq{$d/$b} )[ 9 ] }
->    @fns;'

real    0m1.614s
user    0m0.307s
sys    0m1.273s
knoppix@Knoppix:~$ time perl -Mstrict -wle '
-> my $d = q{/usr/bin};
-> my @fns = do { opendir my $dh, $d or die $!; readdir $dh };
-> my @sorted =
->    map  { $_->[ 0 ] }                                            
->    sort { $a->[ 1 ] <=> $b->[ 1 ] }
->    map  { [ $_, lstat qq{$d/$_} ] }
->    @fns;'

real    0m0.281s
user    0m0.100s
sys    0m0.160s
knoppix@Knoppix:~$
[download]

I hope this is of interest.

Cheers,

JohnGG

It is, indeed.
ikegami's response was surely the most correct, because with no transformation involved, direct access is always faster.

My question was to illustrate a point, i.e. if there was some perl placeholder to accomodate for an anonymous hash being created by another function.