++ed by:
ABRAXXA ADAMJS ALEXBIO ANDREFS ARJONES

117 PAUSE user(s)
93 non-PAUSE user(s).

Jesse Vincent

f_sort.t

Code test snippets here are adapted from `perldoc -f map`

Due to a bleadperl optimization (Dave Mitchell, circa apr 04), the (map|grep)(start|while) opcodes have different flags in 5.9, their private flags /1, /2 are gone in blead (for the cases covered)

When the optree stuff was integrated into 5.8.6, these tests failed, and were todo'd. Theyre now done, by version-specific tweaking in mkCheckRex(), therefore the skip is removed too.

Test Notes

# chunk: #!perl #examples poached from perldoc -f sort

NOTE: name is no longer a required arg for checkOptree, as label is synthesized out of others. HOWEVER, if the test-code has newlines in it, the label must be overridden by an explicit name.

This is because t/TEST is quite particular about the test output it processes, and multi-line labels violate its 1-line-per-test expectations.

# chunk: # sort lexically @articles = sort @files;

# chunk: # same thing, but with explicit sort routine @articles = sort {$a cmp $b} @files;

# chunk: # now case-insensitively @articles = sort {uc($a) cmp uc($b)} @files;

# chunk: # same thing in reversed order @articles = sort {$b cmp $a} @files;

# chunk: # sort numerically ascending @articles = sort {$a <=> $b} @files;

# chunk: # sort numerically descending @articles = sort {$b <=> $a} @files;

# chunk: # this sorts the %age hash by value instead of key # using an in-line function @eldest = sort { $age{$b} <=> $age{$a} } keys %age;

# chunk: # sort using explicit subroutine name sub byage { $age{$a} <=> $age{$b}; # presuming numeric } @sortedclass = sort byage @class;

# chunk: sub backwards { $b cmp $a } @harry = qw(dog cat x Cain Abel); @george = qw(gone chased yz Punished Axed); print sort @harry; # prints AbelCaincatdogx print sort backwards @harry; # prints xdogcatCainAbel print sort @george, 'to', @harry; # prints AbelAxedCainPunishedcatchaseddoggonetoxyz

# chunk: # inefficiently sort by descending numeric compare using # the first integer after the first = sign, or the # whole record case-insensitively otherwise @new = @old[ sort { $nums[$b] <=> $nums[$a] || $caps[$a] cmp $caps[$b] } 0..$#old ];

# chunk: # same thing, but without any temps @new = map { $_->[0] } sort { $b->[1] <=> $a->[1] || $a->[2] cmp $b->[2] } map { [$_, /=(\d+)/, uc($_)] } @old;

# chunk: # using a prototype allows you to use any comparison subroutine # as a sort subroutine (including other package's subroutines) package other; sub backwards ($$) { $_[1] cmp $_[0]; } # $a and $b are not set here package main; @new = sort other::backwards @old;

# chunk: # repeat, condensed. $main::a and $b are unaffected sub other::backwards ($$) { $_[1] cmp $_[0]; } @new = sort other::backwards @old;

# chunk: # guarantee stability, regardless of algorithm use sort 'stable'; @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;

# chunk: # force use of mergesort (not portable outside Perl 5.8) use sort '_mergesort'; @new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;

# chunk: # you should have a good reason to do this! @articles = sort {$FooPack::b <=> $FooPack::a} @files;

# chunk: # fancy @result = sort { $a <=> $b } grep { $_ == $_ } @input;

# chunk: # void return context sort sort { $a <=> $b } @input;

# chunk: # more void context, propagating ? sort { $a <=> $b } grep { $_ == $_ } @input;

# chunk: # scalar return context sort $s = sort { $a <=> $b } @input;

# chunk: $s = sort { $a <=> $b } grep { $_ == $_ } @input;




Hosting generously
sponsored by Bytemark