annotate the part of the line used to sort,
and warn about questionable usage to stderr

--files0-from=F

read input from the files specified by
NUL-terminated names in file F;
If F is - then read names from standard input

-k, --key=POS1[,POS2]

start a key at POS1 (origin 1), end it at POS2
(default end of line). See POS syntax below

-m, --merge

merge already sorted files; do not sort

-o, --output=FILE

write result to FILE instead of standard output

-s, --stable

stabilize sort by disabling last-resort comparison

-S, --buffer-size=SIZE

use SIZE for main memory buffer

-t, --field-separator=SEP

use SEP instead of non-blank to blank transition

-T, --temporary-directory=DIR

use DIR for temporaries, not $TMPDIR or /tmp;
multiple options specify multiple directories

--parallel=N

change the number of sorts run concurrently to N

-u, --unique

with -c, check for strict ordering;
without -c, output only the first of an equal run

-z, --zero-terminated

end lines with 0 byte, not newline

--help

display this help and exit

--version

output version information and exit

POS is F[.C][OPTS], where F is the field number and C the character position
in the field; both are origin 1. If neither -t nor -b is in effect, characters
in a field are counted from the beginning of the preceding whitespace. OPTS is
one or more single-letter ordering options, which override global ordering
options for that key. If no key is given, use the entire line as the key.

SIZE may be followed by the following multiplicative suffixes:
% 1% of memory, b 1, K 1024 (default), and so on for M, G, T, P, E, Z, Y.

With no FILE, or when FILE is -, read standard input.

*** WARNING ***
The locale specified by the environment affects sort order.
Set LC_ALL=C to get the traditional sort order that uses
native byte values.

2. sort.3.man

Manpage of sort

sort

NAME

sort - perl pragma to control sort() behaviour

SYNOPSIS

use sort 'stable'; # guarantee stability
use sort '_quicksort'; # use a quicksort algorithm
use sort '_mergesort'; # use a mergesort algorithm
use sort 'defaults'; # revert to default behavior
no sort 'stable'; # stability not important

use sort '_qsort'; # alias for quicksort

my $current = sort::current(); # identify prevailing algorithm

DESCRIPTION

With the "sort" pragma you can control the behaviour of the builtin
"sort()" function.

In Perl versions 5.6 and earlier the quicksort algorithm was used to
implement "sort()", but in Perl 5.8 a mergesort algorithm was also made
available, mainly to guarantee worst case O(N log N) behaviour:
the worst case of quicksort is O(N**2). In Perl 5.8 and later,
quicksort defends against quadratic behaviour by shuffling large
arrays before sorting.

A stable sort means that for records that compare equal, the original
input ordering is preserved. Mergesort is stable, quicksort is not.
Stability will matter only if elements that compare equal can be
distinguished in some other way. That means that simple numerical
and lexical sorts do not profit from stability, since equal elements
are indistinguishable. However, with a comparison such as

{ substr($a, 0, 3) cmp substr($b, 0, 3) }

stability might matter because elements that compare equal on the
first 3 characters may be distinguished based on subsequent characters.
In Perl 5.8 and later, quicksort can be stabilized, but doing so will
add overhead, so it should only be done if it matters.

The best algorithm depends on many things. On average, mergesort
does fewer comparisons than quicksort, so it may be better when
complicated comparison routines are used. Mergesort also takes
advantage of pre-existing order, so it would be favored for using
"sort()" to merge several sorted arrays. On the other hand, quicksort
is often faster for small arrays, and on arrays of a few distinct
values, repeated many times. You can force the
choice of algorithm with this pragma, but this feels heavy-handed,
so the subpragmas beginning with a "_" may not persist beyond Perl 5.8.
The default algorithm is mergesort, which will be stable even if
you do not explicitly demand it.
But the stability of the default sort is a side-effect that could
change in later versions. If stability is important, be sure to
say so with a

use sort 'stable';

The "no sort" pragma doesn't
forbid what follows, it just leaves the choice open. Thus, after

no sort qw(_mergesort stable);

a mergesort, which happens to be stable, will be employed anyway.
Note that

no sort "_quicksort";
no sort "_mergesort";

have exactly the same effect, leaving the choice of sort algorithm open.

CAVEATS

This pragma is not lexically scoped: its effect is global to the program
it appears in. That means the following will probably not do what you
expect, because both pragmas take effect at compile time, before
either"sort()" happens.