use warnings;
use strict;

my %numbers = qw(one 1 two 2 three 3 four 4 five 5 six 6 seven 7 eight
+ 8);

sort_em(\%numbers);

sub sort_em {
    our %nos =  %{$_[0]};
    print "UP:\n";
    print join "\n", sort { up(\%nos) }  keys %nos; 

    print "\n\nDOWN:\n";
    print join "\n", sort { down(\%nos) } keys %nos; 
}

sub up   { $_[0]->{$a} <=> $_[0]->{$b} }
sub down { $_[0]->{$b} <=> $_[0]->{$a} }
[download]

Keep in mind that perl currently doesn't do nested subs (this is the souce of many a warning for those using Apache::Registry with mod_perl; see the mod_perl guide for a detailed explanation).

You could possibly return a list of coderefs that you create and use sort_em more as a sort routine factory.

sub sort_em {
  my $src = shift;
  return {
           up => sub { $src->{$a} <=> $src->{$b} },
           down => sub { $src->{$b} <=> $src->{$a} },
         }
}

my %numbers = ( qw( a 5 c 4 d 1 ) );
my $num_sorts = sort_em( \%numbers );

print "UP:\n",
      join( "\n", map { "$_ $numbers{$_}" }
          sort { $num_sorts->{up}->() } keys %numbers ),
      "\nDOWN\n",
      join( "\n", map { "$_ $numbers{$_}" }
                  sort { $num_sorts->{down}->() } keys %numbers ),
      "\n";
[download]

> Keep in mind that perl currently doesn't do nested subs
Ack, how un-DWIM!

sub foo {
    my $x = "a var in foo()";
    sub bar {
        print "\$x is - [$x]\n";
    }
}
bar();

__output__

$x is - []
[download]

But if we use a closure, all is well with the scope of $x

sub foo {
    my $x = "a var in foo()";
    return sub {
        print "\$x is - [$x]\n";
    }
}
foo()->();

__output__

$x is - [a var in foo()]
[download]

I was vaguely aware of the fact that nested subs in perl were broken (i.e scoped to current package, not current sub) and now I know the full extent (but I guess the logic should've followed really). Oh well, not much longer til Perl6 anyway ...
HTH

broquaint

If %nos is a local-Variable (my), you have to give it (or better a reference to it) to the subs &up and &down.

Best regards,
perl -le "s==*F=e=>y~\*martinF~stronat~=>s~[^\w]~~g=>chop,print"

Sure it is! Just put the sub declarations in another package, use package at the top of your main code, and then use a fully qualified package name in place of up and down. However, since the code for these two subs is small, and refers to a specific variable in a wider scope, this may not be a good idea. Here is a rewrite of the sort_em sub that may point out why.

sub sort_em {
    my %nos =  @_; #Don't make a ref just to deref it, just 
                   #pass the hash. Use 'my' to indicate 
                   #lexical scope
    print "UP:\n";
    print join "\n", sort { $nos{$a} <=> $nos{$b} } keys %nos; #just p
+ass in short sorting routines on the line
     #of the sort

    print "\n\nDOWN:\n";
    print join "\n", sort { $nos{$b} <=> $nos{$a} } keys %nos; #same a
+s above

}
[download]

Note that the declaration of the subs up and down inside the braces of sort_em does not make them lexically scoped.

#!/usr/bin/perl -w
use strict;

my @l = (2, 4, 19, 3, 15, 30, 1, 31, 14);

print sort {&{bysort("up")}} @l;
print $/;
print sort {&{bysort("dn")}} @l;
print $/;

sub bysort {
  my $by = shift;
  if ($by eq "up") {
    return sub { $a <=> $b };
  } elsif ($by eq "dn") {
    return sub { $b <=> $a };
  } else {
    return sub { $a cmp $b };
  }
}
[download]

--
$you = new YOU;
honk() if $you->love(perl)

So I can pass the hash or whatever to my routine:

print join "\n", sort up(\%nos) }  keys %nos;
[download]

The reason I want to use a sort subroutine is that I don't know how I want to sort the thing until runtime. So I want to call my routine like this:

foreach my $id (sort $by_sort_method keys %contents) {
[download]

How do I do that?

Use something like this to create $by_sort_method:

sub create_sorter
{
       my $contents = shift;

       return sub {
               # sort however you want here
               $contents{$a}{FOO} cmp $contents{$b}{FOO}
       };
}

my $by_sort_method = create_sorter \%contents;

foreach my $id (sort $by_sort_method keys %contents) {
       ...
}
[download]