Think of built-in functions as subs with prototypes on steroids (whether you parse that as "(subs with prototypes) on steroids" or "subs with (prototypes on steroids)", either one is correct).

In this case, Perl is desperately trying to come up with a way to parse "sort do_nothing( @in )" in such a way as to match one of the two allowable formats. And it's getting it wrong. The bias seems to be for the "sort BLOCK EXPR" format over the "sort EXPR" format. Which largely makes sense from the abstract - "sort BLOCK EXPR" could be a subset of "sort EXPR", so we need to provide that bias.

Once we've gone down that road, do_nothing is being passed no arguments, returning an empty array in scalar context results in "0", and we end up having a block that always returns 0, and thus the input to sort is passed back out, unchanged.

With whitespace being significant in perl 6, that ambiguity goes away (to be substituted by whitespace being significant, unlike pretty much every other language).

my @results = @foo.sort(&comparator);
my @results = @foo.sort:{ $^a <=> $^b };
[download]

What whitespace? :)

my @out = sort(do_nothing(@in));
[download]

sub do_nothing { wantarray ? @_ : -1 }
[download]

sub do_nothing { wantarray ? @_ : ($b cmp $a) }
[download]

my @out = sort &do_nothing(@in);
[download]

I am going to take a guess that given sort do_nothing(@in), do_nothing is being parsed as the name of the sort sub, and the (@in) is being parsed as the list to sort on. That's what it appears to be doing from the Deparse output, anyway.

Update: maybe not. this code does the same thing, and it doesn't use a named sub at all:

print sort sub { print "Args: @_\n"; @_ }->(qw(one two three))
[download]

Another update: using a named sub, it acts differently than the anonymous sub, though it returns the same thing and the anonymous sub gets sorted, but this one doesn't:

sub byfoo { print "Args: $a $b\n"; @_ }
print sort byfoo(qw(one two three));
[download]

So perhaps my initial guess was correct, and I got tricked by the anonymous sub. I eagerly await a response from someone who can explain this! :-)

Final update: Ah, Tanktalus' post cleared it all up for me. How silly that I had forgotten sort can take a list and use the default comparison function! That explains why my anonymous coderef gets all the values at once, and they subsequently get sorted.

I am going to take a guess that given sort do_nothing(@in), do_nothing is being parsed as the name of the sort sub, and the (@in) is being parsed as the list to sort on. That's what it appears to be doing from the Deparse output, anyway.

Yes, that's exactly what Deparse shows, and that's my point: why is perl behaving this way. Perhaps the following variant makes the point more forcibly. I have redefined do_nothing to behave like a typical sort sub; the output now is sorted, but note that the sort sub (do_nothing) is being put to work with the syntax do_nothing( @in ):

use strict;

sub do_nothing { $a cmp $b }

my @in = qw( e n i g m a );

my @out = sort do_nothing( @in );

print "@out\n";

__END__

% perl enigma.pl
a e g i m n
[download]

the lowliest monk

   @_
[download]

sub do_nothing {}
[download]

Sort subroutine didn't return a numeric value at nothing.pl line X

I realize that; the puzzle (for me at least) is that sort does not sort the returned contents of @_. (Actually, this puzzle is "explained" by -MO=Deparse's output; now it is the perversity of this output that needs explaining.)

Something tells me that I'm missing something whoppingly obvious...

the lowliest monk