Coming from a perl background I have a lot of programs which do
operations on arrays, including sorts. For example today I came across
one of mine where I wrote:
@filelist =
map { $_->[0] . ($_->[1] ? '.'.$_->[1] : '') }
sort {$a->[0] <=> $b->[0] || $a->[1] <=> $b->[1] }
map { /(\d+)(?:\.(\d+))?/; [ $1, $2 || 0 ] }
grep {/^\d+(?:\.\d+)?$/}
readdir(INDIR);
It takes a list of files, extracts the numeric ones and orders them
numerically. If they have fractional parts it numbers them by treating
the fractional parts as integers (don't ask why ;-).
The bulk of that is easy to rewrite the Ruby way, except for
the multi-index sort:
sort { $a->[0] <=> $b->[0]
||
$a->[1] <=> $b->[1] }
The spaceship returns 0 when the first pair of elements are 0 and this
perl idiom takes advantage of the fact that 0 is false and therefore
'||' will evaluate its second operand. It's akin to saying "if the
first elements are the same then order on the second elements".
In Ruby 0 isn't false so the comparable Ruby expression won't trigger
the comparison on later indices. I've been wondering if there's a way
to efficiently implement this idiom in Ruby.
Ideas?
Rick
--
http://www.rickbradley.com MUPRN: 957 (82F/90F)
| like being trapped in
random email haiku | a video game. i woke
| up thrashing around.