Module compare 

Functions

compare_dictionary

compare_general_numeric

General numeric sort (-g): handles scientific notation, infinity, NaN. O(n) parser.

compare_human_numeric

Human numeric sort (-h): handles suffixes K, M, G, T, P, E, Z, Y. GNU sort compares by suffix tier first (no-suffix < K < M < G < T < P < E < Z < Y), then by numeric value within the same tier. This means 1K > 999999 and 1G > 1023M.

compare_ignore_case

Case-insensitive lexicographic comparison. Tight loop specialized for fold-case only (no dict/nonprinting filtering), avoiding the overhead of the general compare_text_filtered path.

compare_ignore_nonprinting

compare_lexical

Compare two byte slices lexicographically (default sort).

compare_locale

Compare two byte slices using locale-aware collation (strcoll). Uses stack buffers (up to 256 bytes) to avoid heap allocation in the hot path. Falls back to heap-allocated CString for longer strings, and to byte comparison if the input contains interior null bytes.

compare_month

Month sort (-M).

compare_numeric

Numeric sort (-n): compare leading numeric strings. Handles optional leading whitespace, sign, and decimal point.

compare_random

Random sort (-R): hash-based shuffle that groups identical keys.

compare_version

Version sort (-V): GNU filevercmp-compatible version comparison. Implements the exact same algorithm as GNU coreutils’ filevercmp.

compare_with_opts

Master comparison function that dispatches based on KeyOpts.

human_numeric_to_sortable_u64

Convert a human-numeric string directly to a sortable u64. Encodes tier in the top 4 bits and the float value in the bottom 60 bits. This avoids the f64 precision loss that would occur from encoding tier + value in a single f64 (e.g., 1e18 + 3.0 == 1e18 + 1.0 due to 52-bit mantissa).

int_to_sortable_u64

Convert an i64 to a sortable u64 whose natural ordering matches signed integer ordering. Adds i64::MAX + 1 (0x8000000000000000) to shift the range to unsigned.

parse_general_numeric

parse_human_numeric

Legacy parse function for backward compatibility (not used in sort hot path).

parse_numeric_value

Fast custom numeric parser: parses sign + digits + optional decimal directly from bytes. Avoids UTF-8 validation and str::parse::() overhead entirely. Uses batch digit processing for the integer part (4 digits at a time) to reduce loop iterations and branch mispredictions.

select_comparator

Select a concrete comparison function based on KeyOpts. Returns (compare_fn, needs_leading_blank_strip, needs_reverse). The caller applies blank-stripping and reversal outside the function pointer, eliminating all per-comparison branching.

skip_leading_blanks

Strip leading blanks (space and tab).

try_parse_integer

Fast integer-only parser for numeric sort (-n). Returns Some(i64) if the value is a pure integer (no decimal point, no exponent). Returns None if the value has a decimal point or is not a valid integer. This avoids the f64 conversion path for integer-only data. Uses wrapping arithmetic (no overflow checks) for speed — values >18 digits may wrap but sort order is still consistent since all values wrap the same way.

Type Aliases

CompareFn

Concrete comparison function type. Selected once at setup time to avoid per-comparison flag checking in hot sort loops.