Hashes are by their very nature unsorted. Calling each, keys, or values on a vanilla hash isn't going to return things in any sort of sorted order. Your sorter does nothing useful as any ordering is lost when you insert things into the new hash.

What you really need to do is sort a list of the keys using one of your coderefs, then use that to iterate over the contents.

The trick is to sort the keys (by value, if so desired) into an array, and loop over that array.

my @ordered_keys;

if ($sort eq 't') {
   # Calculate the order in which we want to process %tests.
   # (Sort keys by ascending numerical Total.)
   @ordered_keys = sort { $tests{$a}{Total} <=> $tests{$b}{Total} }
                   keys %tests;
}

elsif ($sort eq 'v') {
   # Calculate the order in which we want to process %tests.
   # (Sort keys by ascending numerical Value.)
   @ordered_keys = sort { $tests{$a}{Value} <=> $tests{$b}{Value} }
                   keys %tests;
}

foreach my $key (@ordered_keys) {
   my $val = $tests{$key};

   print "$key\n";
   print "  Total: $val->{Total}\n";
   print "  Value: $val->{Value}\n\n";
}
[download]

By the way, you were sorting alphabetically. Now, it's sorting numerically.

By the way, when dumping a hash or an array, pass a reference to the variable to Dumper (e.g. print Dumper \%tests;) for better results.

Update: The only purpose of using a sub would be to delay the calculation of @ordered_keys. If that's what you wish to do, what follows is a transformation of the above which postpones the calculation of @ordered_keys by use of a sub:

my $sorter;

if ($sort eq 't') {
   # Sort keys by ascending numerical Total.
   $sorter = sub {
      my ($tests) = @_;
      return sort { $tests->{$a}{Total} <=> $tests->{$b}{Total} }
                  keys %$tests;
   };
}

elsif ($sort eq 'v') {
   # Sort keys by ascending numerical Value.
   $sorter = sub {
      my ($tests) = @_;
      return sort { $tests->{$a}{Value} <=> $tests->{$b}{Value} }
                  keys %$tests;
   };
}

foreach my $key ($sorter->(\%tests)) {
   my $val = $tests{$key};

   print "$key\n";
   print "  Total: $val->{Total}\n";
   print "  Value: $val->{Value}\n\n";
}
[download]

foreach will build the list over which it iterates only once, so it doesn't suffer the same problem as your while solution.

use strict;
use warnings;

my $rhDataStruct =
   {
      q{URIBL_OB_SURBL+MPART_ALT_DIFF_COUNT} =>
         {
            Total => 10,
            Value => 3.716
         },
      q{BAYES_00+FORGED_RCVD_HELO} =>
         {
            Total => 5,
            Value => -2.464
         },
      q{BAYES_00+HTML_LINK_PUSH_HERE} =>
         {
            Total => 1,
            Value => -2.202
         },
      q{SPF_HELO_PASS} =>
         {
            Total => 16,
            Value => -0.001
         },
      q{BAYES_95+HTML_MIME_NO_HTML_TAG} =>
         {
            Total => 1,
            Value => 4.082
         }
   };

sub makeSorter
{
    my $rhToSort = shift;
    my $sortType = shift || q{};
    if ($sortType eq q{t})
    {
        return sub
           {
           return
           sort
           {
                   $rhToSort->{$a}->{Total}
                   <=>
                   $rhToSort->{$b}->{Total}
           }
               keys %$rhToSort;
           };
    }
    elsif ($sortType eq q{v})
    {
        return sub
           {
               return
               sort
               {
                   $rhToSort->{$a}->{Value}
                   <=>
                   $rhToSort->{$b}->{Value}
               }
               keys %$rhToSort;
           };
    }
    else
    {
        return sub
           {
               return sort keys %$rhToSort;
           };
    }
}
[download]

Here is the rest of the script that does some testing trying different sorts and adding to the data

and here is the output

I hope this is of use.

Cheers,

JohnGG

Update: Tidied testing code by putting repetitive prints into a subroutine.

Update 2: Corrected typo in updated code.

while ( my ($test,$val) = each %{$sorter->()} ) {

for my $mainkey ( sort keys %$hashref ) {
    # but then use it 
    my $total = $hashref -> { $mainkey ) { Total };
    my $value = $hashref -> { $mainkey ) { Value };
    # and do whatever with those
}
[download]

The reason that I use a has instead of a hashref is that it is used as a hash through the rest of the program. In order to continue this without having to rewrite everything, I just dereference it into a regular hash when I Storable::retrieve() it.

Eric

I'm not pushing that issue then, but you could still do something like this:

for my $mainkey ( sort keys %copy ) {
    my $subref = $copy{ $mainkey };
    my $total = $subref -> { Total };
    my $value = $subref -> { Value };
    # process $mainkey, $total and $value ...
}
[download]

-M

Free your mind

I have two comments concerning the solution you chose.

First, don't use prototypes unless necessary. They cause a lot of headaches.

Second, you can simplify your code by handling sorting and ascending/descending seperately.

sub Print_Tests
{
  my $sort  = shift || "a";
  my $order = shift || "d";

  my (@ordered_keys);

  # Determine the order.
  if ($sort eq 't') {
    @ordered_keys = sort { $tests{$a}{"Total"} <=> $tests{$b}{"Total"}
+ }
      keys %tests;
  } elsif ($sort eq 'v')) {
    @ordered_keys = sort { $tests{$a}{"Value"} <=> $tests{$b}{"Value"}
+ }
      keys %tests;
  } else {
    @ordered_keys = sort keys %tests;
  }

  @ordered_keys = reverse @ordered_keys
     if $order eq 'd';

  foreach my $key (@ordered_keys) {
    my $val = $tests{$key};

    print "$key\n";
    print "  Total: $val->{Total}\n";
    print "  Value: $val->{Value}\n\n";
  }
}
[download]