Also I don't like using autodetection of datatypes like you have above. My experience is that real-world data often throws you surprises like a field with mixed numbers and strings in it. I've run int that too often to trust code which will break on that case. (Although tye has a cute sprintf trick at Re: Sorting on Section Numbers which is acceptable with many datasets.)

That said, I have tackled this exact problem with closures. With something like this (untested):

# Take a list of sort functions, return a sort function
# that tests them in order, with short circuit logic.
sub ret_combined_sort_func {
  if (1 == @_) {
    return shift;
  }
  else {
    my @subs = @_;
    return sub {
      my $ret = 0;
      foreach (@subs) {
        $ret = $_->();
        return $ret if $ret;
      }
      # I guess we're "out of sorts" :-)
      return 0;
    }
  }
}
[download]

A note to people who like to generalize. I implicitly assume above that the sort functions are defined in the same package that sort will be called in. Or at least know the package. That is because the $a and $b that is set depends where sort is called, so the sort function had better look there. If you don't want to avoid that then you need to modify the closures to all use a ($$) prototype. sort will in recent (5.6 on up) versions of Perl then pass in the two scalars to compare rather than alias them in $a and $b. Now your sort functions can be defined in a different package than sort is eventually called in. (I thought that this was pointed out to me by dws. He doesn't remember that, and I can't find where it was pointed out. I've had several occasions to use it since though.)

Update: dws pointed out a piece of mangled grammar, and told me that he didn't remember telling me about using prototypes in a sort.

Update 2: "lease" should have been "least". Fixed.

One suggestion for your code, use eval's return value to create an sub rather than evaling the whole sort routine. Here is a quick example of the technique.

my $test = eval "sub { print 'hello world' }";
$test->(); # prints the ever-classic "hello world"
[download]

Regarding similar sorting techniques. I usually, like tilly, have used closures (although using closures somewhat differently than tilly).

my %hash = (    
    'Lisa'   => [ 'F',  6, 150, 'Blonde',  'Blue' ],
    'Homer'  => [ 'M', 40, 105,   'Bald',  'Blue' ],
    'Bart'   => [ 'M',  9, 120, 'Blonde', 'Brown' ],
    'Marge'  => [ 'F', 36, 135,   'Blue',  'Blue' ],
    'Maggie' => [ 'F',  1, 130, 'Blonde',  'Blue' ] 
);

sub createSortRoutine {
    my (@ordered_values) = @_;
    return sub {
        my ($left, $right) = @_;
        my $result;
        foreach (@ordered_values) {
            $result = ( ($hash{$left}->[$_] =~ /^\d+$/) ?
                 $hash{$left}->[$_] <=> $hash{$right}->[$_]
                 :
                 $hash{$left}->[$_] cmp $hash{$right}->[$_] )
                      unless $result;
        }
        return $result;
    };
}

my $sorter = createSortRoutine(0, 2, 3);

print join "\n" => sort { $sorter->($a, $b) } keys %hash;

# NOTE: this code not thoroughly tested, i lifted it from 
# and old module of mine and hacked it for this example.

__DATA__
Maggie
Marge
Lisa
Homer
Bart
[download]

There was also talk about a Sort::Records module by Guttman and Rossler that used the eval-a-dedicated-sub technique, but was even more full-featured; unfortunately I've never actually found the code for it...