Disclaimer: I have not looked into the Perl internals of sorting, so this is based just on my naive observations.

The method of using $test = $a || shift is an interesting way to implement a dual-use function, but you get bitten by Perl magic as you see.

In the first case, Perl rightfully complains about the variables $a and $b only being used once, since that is what you effectively do.

In the second case, deep Perl (optimization) magic is at work, since the variables $a and $b get filled with sort parameters for speed reasons and thus get "used" as far as Perl (or rather, the warnings-part of perl) is concerned. So, for sorting, $a and $b have been declared globally by the sort magic, and then warnings finds them already used (and maybe even declared) and thus shuts up.

I don't see any good solution to your dilemma, as the two or three approaches I see only lead down to beaten but bad paths :

• Make a third routine, called by the two routines : Bad idea for performance reasons (if that's a reason). At least, performance is the reason why Perl uses the magic variables $a and $b instead of simply passing parameters around. If performance is of no concern, use this way.
• Make two routines, one to be called directly, and one to be called by sort. Even worse idea. Code duplication leads the way to hell and very subtle errors. If you have two routines seemingly intended to do the same, you should make sure they actually do the same.
• Predeclare $a and $b with my. Interesting idea - you should comment on _why_ you're predeclaring $a and $b. This seemed like a good idea, until I tested this variant and found a very interesting way to create hellish errors, illustrated below.

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

my ($a, $b);

# Bad bad bad thing !
($a, $b) = ( "5","6" );

sub mySort {
  return ($a||shift) cmp ($b||shift);
};

print "\n1: ", mySort( "1","2" );
print "\n2: ", join " ", sort qw!d b c a!;
print "\n3: ", mySort( "8","7" ), "\n";

print "\n\$a: $a, \$b : $b\n";
[download]

G:\>perl -w test.pl

1: -1
2: a b c d
3: -1

$a: 5, $b : 6
[download]

I'm not sure that there is no perlish idiom for handling such cases, but I haven't seen them yet :-)

Hi,

Thanks a lot for your help ! I just tried the solution Tyke
came up with. And it seems like a pretty good one (use vars qw/$a $b/;)
I tried it and it works perfectly and I haven't been able to
create a situation in which it doesn't work. So I think I'll go for
this one.

Thank you all for thinking along with me ! ;-)

And now for some lunch ! Bye, Leon

This solution has the same problems as my my-predeclare solution has. If somebody is stupid enough to assign something to $a and $b, then this method won't work for the single-call case. But on the other side, the single-call case will never work, if somebody actually uses variables called $a and $b in any way other than within a sort-callback.

If you add the line

  use vars qw/$a $b/;

Sounds like a bug in your version of Perl - which version are you using? It's my understanding that $a and $b are explicitly excluded from things like the 'used only once' checks for precisely this reason.

For the record, here on 5.005_02 it works as expected - without the error message.

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

Hmmm ... that's kind of weird.
I use version 5.6.0 for sun4-solaris

Thanks, Leon 'still puzzled' Spaans

my @dummy=sort byVersion ();
[download]

 my @First=split /\./,$a||shift;
 my @Second=split /\./,$b||shift;
 foreach(0..(($#First>$#Second)?$#Second:$#First))
[download]

Could anyone explain to me what the # in the variable name does?

The Llama and Camel books describe how # can be used for comments, formats and the shebang execute command. But in this code # affixed to the name of an array appears to be neither a comment or a format or a shebang. # affixed to the start of an array name automagically become — well, I don't know what it becomes.

Does anybody know?

$#list_name returns the index number of the last element in @list_name. This will give you an off-by-one error if you try to use it to count the number of elements in an list (so use $count = @list_name for that). Also useful for erasing a list: $#list_name = -1;

See perldoc perldata for more information.

my to_string{
    my $s=shift;
    return $$s;
}
[download]

GoldClaw

This has been covered before. Here is the solution I came up with:

@sorted = 

map { $_->[0] }
sort {
  $x=1;
  while (defined $a->[1][$x]) {
    defined $b->[1][$x] or return -1;
    if ($x%2) { ## Strict numeric comparison
      return +1 if $a->[1][$x] > $b->[1][$x];
      return -1 if $a->[1][$x] < $b->[1][$x];
    }
    else { ## Non-numeric comparison
      return +1 if $a->[1][$x] gt $b->[1][$x];
      return -1 if $a->[1][$x] lt $b->[1][$x];
    }       
    $x++;
  }
  return defined $b->[1][$x] ? 1 : 0;
}
map { [$_, [split(/(\d+)/, $_)]] }
@unsorted;
[download]