Good point. Being an XS module I would expect it to have good performance, though for some reason it won't build on my system so I haven't been able to test it.

I would appreciate if you could send my a bug report stating the cause of the build error (the output from make will do), your perl version, OS and processor (or perl -V output).

oh, and BTW...

use Sort::Key qw(keysort);

sub mkkey {
    my $key = deaccent $_;
    $key =~ s/(?<=\d)\Q$separator\E(?>=\d)//g;
    $key =~ s{0*(\d+)}{
        my $len = length $1;
        "\x00" . ('9' x ($len / 9)) . ($len % 9) . $1
    }eg;
    $key;
}

...

cmpthese(
    -30,
    {
        #'alphanum'        => sub { @temp = sort { alphanum( $a, $b ) 
+} @array; },
        #'Sort::Naturally' => sub { @temp = nsort(@array) },
        'natural_sort'    => sub { @temp = natural_sort(@array) },
        'Sort::Key' => sub { @temp = keysort \&mkkey, @array },
    }
);
[download]

says...

78848 items in array...
             s/iter natural_sort    Sort::Key
natural_sort   3.51           --         -31%
Sort::Key      2.41          46%           --
[download]

Small aside: 'Œ'/'œ' is common in French, as in 'œuf' ('egg'), but is missing from your %trans hash.

True. But the 'Œ'/'œ' ligature is not in ISO-Latin-1. If I'm going to expand into other codepages, I would be better off using something like Text::Unidecode to decompose the characters. It would be a substantial performance hit, but much easier to maintain.

It comes down to what is "good enough", I guess.

after seeing various complaints about Sort::Naturally then having questions/concerns about another option (Sort::Key::Natural) I "grew my own". it may not be "elegant" (it is kind of a brute force method) but it does seem to handle my cases OK. it may also be easier to customize because it is not using any "tricks".

I have no problem with many CPAN packages but many of them seem to be confusing to use or seem to be rather large files for what should be simple functions and some do not seem to work well :(. this example may not be the fastest, most elegant, or "cleanest" code but it does the job I need it to do which for most cases boils down to doing things in the "Microsoft" file name order (for my benefit). for the other cases where I may use this I doubt anybody would notice something incorrect anyway.

#figure this out later#my $separator_characters=" _-\\\\\\\.";      # 
+these are the separator characters ready for use in a regex
sub __natural_split_item($)
{
    my @out_array;
    #
    # by brute force we will separate a string into the output array
    # by these cases as they are found:
    #
    # separator characters
    # numerics
    # alpha/non numeric
    #
    # we may need to add other stuff in the future...
    #
    # when we change to a different type we will push the previous dat
+a into
    # the output array.
    #
    my $last_type=0;      # set to no previous
    my $last_split="";
    if(defined $_[0])        # we may get an undefined item....
    {
        for(my $i=0;$i<length $_[0];$i++)
        {
            my $thischar=substr $_[0],$i,1;         # will need to do 
+something for unicode if we need it....
            my $thistype;    # just do not use zero and do not duplica
+te values.
            #
            # separator characters may need to be handled a little dif
+ferently.
            # first, we need to change them into spaces and second we 
+need to
            # push them on the output array as single characters.  thi
+s may fix
            # the __ versus _ sort cases where __ shows up first but w
+e do the _
            # first.
            #
            # note that the number selected for $thistype does not mat
+ter - we are
            # only looking for a change in separator type.
            #
            #figure this out later#if($thischar =~ /[$separator_charac
+ters]/)                      # this character is a separator characte
+r
            if($thischar =~ /[ _\\\.]/)                      # this ch
+aracter is a separator character
            {
                $thistype=100;
                $thistype++ if($last_type == $thistype);              
+    # repeated separators of any sort must be treated a bit different
+ly
                $thischar=" ";
            }
            elsif($thischar =~ /^\d$/) { $thistype=200; }             
+    # this character is a numeric character
            else { $thistype=300; }                                   
+    # this character is a non numeric

            if($last_type!=0         # if we have a previous type (0 m
+eans no previous)
            && $last_type!=$thistype #    and we have changed type
            && $last_split ne ""     #    and we have something to pus
+h (we should if we get to this test)
              )
            {
                push @out_array,$last_split;
                $last_split="";
            }
            $last_type=$thistype;
            $last_split .= $thischar;    # add this character to the c
+urrent
        }
        push @out_array,$last_split;      # add the last component
    }
    return @out_array;
}

sub my_custom_natural_sort
{
    my @a_list=__natural_split_item $a;
    my @b_list=__natural_split_item $b;
    for (my $i=0;defined $a_list[$i] && defined $b_list[$i];$i++)
    {
        next if $a_list[$i] eq $b_list[$i];      # move on to next ite
+m if this split component is the same
        if(($a_list[$i]=~ /\d\d*/) && ($b_list[$i]=~ /\d\d*/))   # if 
+both numeric to a numeric test first
        {
            return $a_list[$i] <=> $b_list[$i] if $a_list[$i] != $b_li
+st[$i];    # simple numeric compare if not same value
            return $a_list[$i] cmp $b_list[$i] if $a_list[$i] ne $b_li
+st[$i];    # ascii compare so we can handle leading zero variationsif
+ not same value
        }
        return (lc $a_list[$i]) cmp (lc $b_list[$i]) if (lc $a_list[$i
+]) ne (lc $b_list[$i]);    # compare as same case first
        #return ($a_list[$i]) cmp ($b_list[$i]) if ($a_list[$i]) ne ($
+b_list[$i]);                # then compare as case sensitive (maybe)
    }
    return (length @a_list) <=> (length @b_list);    # just do list le
+ngth - longer list should be later.  if items the same then it does n
+ot matter....
}
[download]