We discussed this one once. When you did it, it was not a big deal at the time as far as you were concerned. I absolutely understood.

This falls out as a natural consequence of starting to think about Perl as a list-oriented language (which it is) instead of thinking like you would in C. It has often been mentioned that Perl is the Cliff Notes of Unix. Well that includes the value of thinking in terms of hooking together a bunch of trivial little filters into a pipeline.

That is exactly you were doing.

Unfortunately in Perl the syntax makes a pipeline read the wrong way. But let us use a fake notation where |> means "pipe to", what you are doing is the same as:

@input |>  map {[$_, &expensive_func($_)}
       |>  sort { $a->[1] cmp $b->[1] }
       |>  map {$_->[0]}
       |>  my @output;
[download]

And now, written in a pseudo imitation of a Unix pipeline where actions naturally read in the same order they execute in, my analogy to a Unix pipeline should be clear.

For the record I often mentally write filters in a pseudo pipeline like the above, you apparently write them bottom to top. Either way anyone who gets past the notational issue and thinks "Unix pipeline" not only will find the Schwartzian sort trivial, they will also get a lot of insight into how to effectively use the underlying key idea for a wide variety of problems.