From: Giftpflanze <gifti@tools.wmflabs.org>
Date: Wed, 1 Feb 2023 17:27:34 +0000 (+0000)
Subject: Rename and add sorting words
X-Git-Tag: 0.99~638
X-Git-Url: https://gitweb.factorcode.org/gitweb.cgi?p=factor.git;a=commitdiff_plain;h=db1ad197d9fabbeb6251ba75687716f75e1d998b

Rename and add sorting words

sorting:
natural-sort → sort
sort → sort-with
sort-with → sort-by
+ inv-sort
+ inv-sort-with
inv-sort-with → inv-sort-by
+ inv-sort-keys
+ inv-sort-values

sorting.slots → sorting.specification:
compare-slots → compare-with-spec
sort-by → sort-with-spec
sort-by-with → sort-with-spec-by
sort-keys-by → sort-keys-with-spec
sort-values-by → sort-values-with-spec

sorting.quick:
natural-sort! → sort!
sort! → sort-with!
sort-with! → sort-by!
+ inv-sort!
+ inv-sort-with!
inv-sort-with! → inv-sort-by!

sorting.bubble:
natural-bubble-sort! → bubble-sort!
bubble-sort! → bubble-sort-with!
---

diff --git a/basis/channels/channels-tests.factor b/basis/channels/channels-tests.factor
index ab7f164003..cdb9429fdd 100644
--- a/basis/channels/channels-tests.factor
+++ b/basis/channels/channels-tests.factor
@@ -24,7 +24,7 @@ USING: channels kernel sequences sorting threads tools.test ;
     2 over to
     1 over to
     3 swap to
-    natural-sort
+    sort
 ] unit-test
 
 { { 1 2 4 9 } } [
@@ -37,5 +37,5 @@ USING: channels kernel sequences sorting threads tools.test ;
     2dup from swap push
     2dup from swap push
     dupd from swap push
-    natural-sort
+    sort
 ] unit-test
diff --git a/basis/compiler/cfg/dominance/dominance.factor b/basis/compiler/cfg/dominance/dominance.factor
index 230022e8df..75a4523fa8 100644
--- a/basis/compiler/cfg/dominance/dominance.factor
+++ b/basis/compiler/cfg/dominance/dominance.factor
@@ -47,7 +47,7 @@ PRIVATE>
 
 : compute-dom-children ( dom-parents -- dom-childrens )
     H{ } clone [ '[ 2dup eq? [ 2drop ] [ _ push-at ] if ] assoc-each ] keep
-    [ [ number>> ] sort-with ] assoc-map ;
+    [ [ number>> ] sort-by ] assoc-map ;
 
 SYMBOLS: preorder maxpreorder ;
 
diff --git a/basis/compiler/cfg/linear-scan/assignment/assignment-tests.factor b/basis/compiler/cfg/linear-scan/assignment/assignment-tests.factor
index 354958a40b..e1c4610d3c 100644
--- a/basis/compiler/cfg/linear-scan/assignment/assignment-tests.factor
+++ b/basis/compiler/cfg/linear-scan/assignment/assignment-tests.factor
@@ -220,5 +220,5 @@ IN: compiler.cfg.linear-scan.assignment.tests
 
 { { 3 56 } } [
     { { 3 7 } { -1 56 } { -1 3 } } >min-heap [ -1 = ] heap-pop-while
-    natural-sort
+    sort
 ] unit-test
diff --git a/basis/compiler/cfg/linearization/linearization.factor b/basis/compiler/cfg/linearization/linearization.factor
index 98af558f6a..850ef1f562 100644
--- a/basis/compiler/cfg/linearization/linearization.factor
+++ b/basis/compiler/cfg/linearization/linearization.factor
@@ -38,7 +38,7 @@ SYMBOLS: loop-heads visited ;
     ] if ;
 
 : sorted-successors ( bb -- seq )
-    successors>> <reversed> [ loop-nesting-at ] sort-with ;
+    successors>> <reversed> [ loop-nesting-at ] sort-by ;
 
 : process-block ( bb -- bbs )
     dup visited get ?adjoin [ dup , sorted-successors ] [ drop { } ] if
diff --git a/basis/compiler/cfg/ssa/destruction/coalescing/coalescing.factor b/basis/compiler/cfg/ssa/destruction/coalescing/coalescing.factor
index e488b320d0..69d8aaeedd 100644
--- a/basis/compiler/cfg/ssa/destruction/coalescing/coalescing.factor
+++ b/basis/compiler/cfg/ssa/destruction/coalescing/coalescing.factor
@@ -54,7 +54,7 @@ M: ##tagged>integer coalesce-now
 
 M: ##phi coalesce-now
     [ dst>> ] [ inputs>> values ] bi zip-scalar
-    natural-sort t try-eliminate-copies ;
+    sort t try-eliminate-copies ;
 
 GENERIC: coalesce-later ( insn -- )
 
diff --git a/basis/compiler/cfg/ssa/interference/interference.factor b/basis/compiler/cfg/ssa/interference/interference.factor
index b20e639658..448a96c96d 100644
--- a/basis/compiler/cfg/ssa/interference/interference.factor
+++ b/basis/compiler/cfg/ssa/interference/interference.factor
@@ -2,7 +2,7 @@
 ! See https://factorcode.org/license.txt for BSD license.
 USING: accessors arrays combinators combinators.short-circuit
 compiler.cfg.dominance compiler.cfg.ssa.interference.live-ranges
-kernel locals math math.order sequences sorting.slots ;
+kernel locals math math.order sequences sorting.specification ;
 IN: compiler.cfg.ssa.interference
 
 TUPLE: vreg-info vreg value def-index bb pre-of color equal-anc-in equal-anc-out ;
@@ -89,7 +89,7 @@ TUPLE: vreg-info vreg value def-index bb pre-of color equal-anc-in equal-anc-out
 
 ! Merging lists of vregs sorted by dominance.
 M: vreg-info <=> ( vreg1 vreg2 -- <=> )
-    { { pre-of>> <=> } { def-index>> <=> } } compare-slots ;
+    { { pre-of>> <=> } { def-index>> <=> } } compare-with-spec ;
 
 SYMBOLS: blue red ;
 
diff --git a/basis/compiler/cfg/stacks/padding/padding-tests.factor b/basis/compiler/cfg/stacks/padding/padding-tests.factor
index 1c628a0820..07fd049773 100644
--- a/basis/compiler/cfg/stacks/padding/padding-tests.factor
+++ b/basis/compiler/cfg/stacks/padding/padding-tests.factor
@@ -122,7 +122,7 @@ IN: compiler.cfg.stacks.padding.tests
 
 : following-stack-state ( insns -- state )
     T{ ##branch } suffix insns>cfg trace-stack-state
-    >alist [ first ] sort-with last second ;
+    >alist [ first ] sort-by last second ;
 
 ! trace-stack-state
 {
diff --git a/basis/compiler/tests/redefine5.factor b/basis/compiler/tests/redefine5.factor
index b027230a48..2e0e786393 100644
--- a/basis/compiler/tests/redefine5.factor
+++ b/basis/compiler/tests/redefine5.factor
@@ -10,7 +10,7 @@ IN: compiler.tests.redefine5
     "USING: sorting kernel math.order ;
     IN: compiler.tests.redefine5
     GENERIC: my-generic ( a -- b )
-    M: object my-generic [ <=> ] sort ;
+    M: object my-generic sort ;
     : my-inline ( a -- b ) my-generic ;"
     eval( -- )
 ] unit-test
diff --git a/basis/compiler/tests/redefine8.factor b/basis/compiler/tests/redefine8.factor
index 874cb2633e..3e10b0c951 100644
--- a/basis/compiler/tests/redefine8.factor
+++ b/basis/compiler/tests/redefine8.factor
@@ -14,7 +14,7 @@ IN: compiler.tests.redefine8
     GENERIC: my-generic ( a -- b )
     ! We add the bogus quotation here to hinder inlining
     ! since otherwise we cannot trigger this bug.
-    M: my-mixin my-generic 1 + [ [ <=> ] sort ] drop ;"
+    M: my-mixin my-generic 1 + [ sort ] drop ;"
     eval( -- )
 ] unit-test
 
diff --git a/basis/compiler/tests/redefine9.factor b/basis/compiler/tests/redefine9.factor
index b8320d6749..57ec3c8b26 100644
--- a/basis/compiler/tests/redefine9.factor
+++ b/basis/compiler/tests/redefine9.factor
@@ -14,7 +14,7 @@ IN: compiler.tests.redefine9
     GENERIC: my-generic ( a -- b )
     ! We add the bogus quotation here to hinder inlining
     ! since otherwise we cannot trigger this bug.
-    M: my-mixin my-generic 1 + [ [ <=> ] sort ] drop ;"
+    M: my-mixin my-generic 1 + [ sort ] drop ;"
     eval( -- )
 ] unit-test
 
diff --git a/basis/compiler/tree/debugger/debugger-tests.factor b/basis/compiler/tree/debugger/debugger-tests.factor
index 3cdbbf5944..3902f9f596 100644
--- a/basis/compiler/tree/debugger/debugger-tests.factor
+++ b/basis/compiler/tree/debugger/debugger-tests.factor
@@ -1,5 +1,5 @@
 USING: compiler.tree.debugger tools.test sorting sequences io math.order ;
 IN: compiler.tree.debugger.tests
 
-[ [ <=> ] sort ] optimized.
+[ [ <=> ] sort-with ] optimized.
 [ <reversed> [ print ] each ] optimizer-report.
diff --git a/basis/compiler/tree/debugger/debugger.factor b/basis/compiler/tree/debugger/debugger.factor
index ea585e0ce0..c2c0f2e0be 100644
--- a/basis/compiler/tree/debugger/debugger.factor
+++ b/basis/compiler/tree/debugger/debugger.factor
@@ -174,7 +174,7 @@ SYMBOL: node-count
             { methods-called "==== Non-inlined method calls:" }
             { intrinsics-called "==== Open-coded intrinsic calls:" }
         } [
-            nl print get keys natural-sort stack.
+            nl print get keys sort stack.
         ] assoc-each
     ] with-variables ;
 
diff --git a/basis/compiler/tree/def-use/def-use-tests.factor b/basis/compiler/tree/def-use/def-use-tests.factor
index ac401cf531..08a3d23245 100644
--- a/basis/compiler/tree/def-use/def-use-tests.factor
+++ b/basis/compiler/tree/def-use/def-use-tests.factor
@@ -52,7 +52,7 @@ IN: compiler.tree.def-use.tests
     [ [ 1 ] [ 2 ] compose swap [ 1 ] [ 2 ] if + * ]
     [ dup slice? [ dup array? [ ] [ ] if ] [ ] if ]
     [ dup [ drop f ] [ "A" throw ] if ]
-    [ [ <=> ] sort ]
+    [ [ <=> ] sort-with ]
     [ [ <=> ] with search ]
 } [
     [ ] swap [ test-def-use ] curry unit-test
diff --git a/basis/compiler/tree/def-use/simplified/simplified-tests.factor b/basis/compiler/tree/def-use/simplified/simplified-tests.factor
index c810230f4d..40d6fd748d 100644
--- a/basis/compiler/tree/def-use/simplified/simplified-tests.factor
+++ b/basis/compiler/tree/def-use/simplified/simplified-tests.factor
@@ -6,7 +6,7 @@ IN: compiler.tree.def-use.simplified
 { { #call #return } } [
     [ 1 dup reverse ] build-tree compute-def-use
     first out-d>> first actually-used-by
-    [ node>> class-of ] map natural-sort
+    [ node>> class-of ] map sort
 ] unit-test
 
 : word-1 ( a -- b ) dup [ word-1 ] when ; inline recursive
@@ -14,11 +14,11 @@ IN: compiler.tree.def-use.simplified
 { { #introduce } } [
     [ word-1 ] build-tree analyze-recursive compute-def-use
     last in-d>> first actually-defined-by
-    [ node>> class-of ] map natural-sort
+    [ node>> class-of ] map sort
 ] unit-test
 
 { { #if #return } } [
     [ word-1 ] build-tree analyze-recursive compute-def-use
     first out-d>> first actually-used-by
-    [ node>> class-of ] map natural-sort
+    [ node>> class-of ] map sort
 ] unit-test
diff --git a/basis/compiler/tree/propagation/propagation-tests.factor b/basis/compiler/tree/propagation/propagation-tests.factor
index 83dd33f5f9..ee6bd7f609 100644
--- a/basis/compiler/tree/propagation/propagation-tests.factor
+++ b/basis/compiler/tree/propagation/propagation-tests.factor
@@ -884,7 +884,7 @@ MIXIN: empty-mixin
 
 { V{ t } } [ [ macosx unix? ] final-literals ] unit-test
 
-{ V{ array } } [ [ [ <=> ] sort [ <=> ] sort ] final-classes ] unit-test
+{ V{ array } } [ [ [ <=> ] sort-with [ <=> ] sort-with ] final-classes ] unit-test
 
 { V{ float } } [ [ fsqrt ] final-classes ] unit-test
 
diff --git a/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor b/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor
index 331b201690..06e1109fc7 100644
--- a/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor
+++ b/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor
@@ -33,7 +33,7 @@ TUPLE: empty-tuple ;
     [ [ ] [ ] curry curry dup 2 slot swap 3 slot dup 2 slot swap 3 slot drop ]
     [ [ ] [ ] curry curry call ]
     [ 1 cons boa over [ "A" throw ] when car>> ]
-    [ [ <=> ] sort ]
+    [ [ <=> ] sort-with ]
     [ [ <=> ] with search ]
     [ cons boa car>> void { } cdecl [ ] alien-callback ]
 } [ [ ] swap [ test-unboxing ] curry unit-test ] each
diff --git a/basis/compression/huffman/huffman.factor b/basis/compression/huffman/huffman.factor
index 6f050b9eff..6f7559ca49 100644
--- a/basis/compression/huffman/huffman.factor
+++ b/basis/compression/huffman/huffman.factor
@@ -110,7 +110,7 @@ TUPLE: huffman-tree
     } cond ;
 
 : sort-values! ( obj -- sortedseq )
-    >alist [ <==> ] sort ;
+    >alist [ <==> ] sort-with ;
 
 : get-next-code ( code current -- next )
     [ reverse bit-array>integer 1 + ] [ length ] bi <bits> >bit-array reverse dup length pick length swap - [ f ] replicate append nip ;
diff --git a/basis/compression/inflate/inflate.factor b/basis/compression/inflate/inflate.factor
index fdc6b81e12..41f248aef1 100644
--- a/basis/compression/inflate/inflate.factor
+++ b/basis/compression/inflate/inflate.factor
@@ -49,7 +49,7 @@ CONSTANT: clen-shuffle { 16 17 18 0 8 7 9 6 10 5 11 4 12 3 13 2 14 1 15 }
 : get-table ( values size -- table )
     16 f <array> <enumerated>
     [ '[ _ push-at ] 2each ] keep
-    seq>> rest-slice [ natural-sort ] map ; inline
+    seq>> rest-slice [ sort ] map ; inline
 
 :: decode-huffman-tables ( bitstream -- tables )
     5 bitstream bs:read 257 +
diff --git a/basis/cpu/arm/assembler/32/32.factor b/basis/cpu/arm/assembler/32/32.factor
index e9ac535798..7c70a7663e 100644
--- a/basis/cpu/arm/assembler/32/32.factor
+++ b/basis/cpu/arm/assembler/32/32.factor
@@ -1,4 +1,5 @@
 ! Copyright (C) 2023 Doug Coleman.
+! Copyright (C) 2023 Giftpflanze.
 ! See https://factorcode.org/license.txt for BSD license.
 USING: cpu.arm.assembler cpu.arm.assembler.opcodes kernel math ;
 IN: cpu.arm.assembler.32
diff --git a/basis/cpu/arm/assembler/64/64.factor b/basis/cpu/arm/assembler/64/64.factor
index 837c4a062b..7af5754519 100644
--- a/basis/cpu/arm/assembler/64/64.factor
+++ b/basis/cpu/arm/assembler/64/64.factor
@@ -1,4 +1,5 @@
 ! Copyright (C) 2023 Doug Coleman.
+! Copyright (C) 2023 Giftpflanze.
 ! See https://factorcode.org/license.txt for BSD license.
 USING: cpu.arm.assembler cpu.arm.assembler.opcodes kernel math
 math.bitwise ;
diff --git a/basis/cpu/arm/assembler/assembler.factor b/basis/cpu/arm/assembler/assembler.factor
index ff9a81a511..891a53066b 100644
--- a/basis/cpu/arm/assembler/assembler.factor
+++ b/basis/cpu/arm/assembler/assembler.factor
@@ -1,4 +1,5 @@
 ! Copyright (C) 2020 Doug Coleman.
+! Copyright (C) 2023 Giftpflanze.
 ! See https://factorcode.org/license.txt for BSD license.
 USING: combinators cpu.arm.assembler.opcodes grouping kernel
 math math.bitwise math.parser sequences ;
diff --git a/basis/cpu/arm/assembler/opcodes/opcodes.factor b/basis/cpu/arm/assembler/opcodes/opcodes.factor
index 461bb027e7..458a6f7e09 100644
--- a/basis/cpu/arm/assembler/opcodes/opcodes.factor
+++ b/basis/cpu/arm/assembler/opcodes/opcodes.factor
@@ -1,4 +1,5 @@
 ! Copyright (C) 2020 Doug Coleman.
+! Copyright (C) 2023 Giftpflanze.
 ! See https://factorcode.org/license.txt for BSD license.
 USING: accessors assocs classes.error classes.parser effects
 effects.parser endian kernel lexer make math math.bitwise
diff --git a/basis/db/sqlite/sqlite-tests.factor b/basis/db/sqlite/sqlite-tests.factor
index 7a2dc8e232..0ece1abb05 100644
--- a/basis/db/sqlite/sqlite-tests.factor
+++ b/basis/db/sqlite/sqlite-tests.factor
@@ -137,7 +137,7 @@ things "THINGS" {
         1 1 things boa insert-tuple
         1 0 things boa insert-tuple
         f f things boa select-tuples
-        [ [ one>> ] [ two>> ] bi 2array ] map natural-sort
+        [ [ one>> ] [ two>> ] bi 2array ] map sort
        things drop-table
     ] with-db
 ] unit-test
diff --git a/basis/db/tuples/tuples-tests.factor b/basis/db/tuples/tuples-tests.factor
index e0f7e441d9..ceec0b1dec 100644
--- a/basis/db/tuples/tuples-tests.factor
+++ b/basis/db/tuples/tuples-tests.factor
@@ -680,7 +680,7 @@ select-me "select_me"
     [ { "test" "test2" } ] [
         select-me new NULL >>data [ "test" >>data ] update-tuples
         select-me new [ data>> ] collector [ each-tuple ] dip
-        natural-sort
+        sort
     ] unit-test
 
     [ { "test1" "test2" } ] [
@@ -688,13 +688,13 @@ select-me "select_me"
             dup data>> "test" = [ "test1" >>data ] [ drop f ] if
         ] update-tuples
         select-me new [ data>> ] collector [ each-tuple ] dip
-        natural-sort
+        sort
     ] unit-test
 
     [ { "test2" } ] [
         select-me new [ data>> "test1" = ] reject-tuples
         select-me new [ data>> ] collector [ each-tuple ] dip
-        natural-sort
+        sort
     ] unit-test ;
 
 [ test-mapping ] test-sqlite
diff --git a/basis/editors/vim/generate-syntax/generate-syntax.factor b/basis/editors/vim/generate-syntax/generate-syntax.factor
index e14ec10474..fa04fee4e5 100644
--- a/basis/editors/vim/generate-syntax/generate-syntax.factor
+++ b/basis/editors/vim/generate-syntax/generate-syntax.factor
@@ -53,7 +53,7 @@ CONSTANT: highlighted-vocabs {
 
 : write-keywords ( vocab -- )
     lookup-vocab
-    [ name>> ] [ vocab-words [ name>> ] map ] bi natural-sort [
+    [ name>> ] [ vocab-words [ name>> ] map ] bi sort [
         [ vocab-name>syntax-group-name
             [ "SynKeywordFactorWord " write write " | " write ] keep
         ] dip
diff --git a/basis/escape-strings/escape-strings.factor b/basis/escape-strings/escape-strings.factor
index d595b1fead..dadf2ab6a2 100644
--- a/basis/escape-strings/escape-strings.factor
+++ b/basis/escape-strings/escape-strings.factor
@@ -35,7 +35,7 @@ IN: escape-strings
     [ length ] histogram-by
     dup keys length [0..b]
     [ [ of ] keep over [ 10^ < ] [ nip ] if ] with find nip
-    [ '[ length _ = ] filter natural-sort ] keep ! remove natural-sort here
+    [ '[ length _ = ] filter sort ] keep ! remove sort here
     [
         [ drop "" ] [
             10^ <iota> [
diff --git a/basis/fixups/fixups.factor b/basis/fixups/fixups.factor
index 77a2019bb6..338add29fb 100644
--- a/basis/fixups/fixups.factor
+++ b/basis/fixups/fixups.factor
@@ -7,6 +7,7 @@ IN: fixups
 CONSTANT: vocab-renames {
     { "math.intervals" { "intervals" "0.99" } }
     { "math.ranges" { "ranges" "0.99" } }
+    { "sorting.slots" { "sorting.specification" "0.99" } }
 }
 
 CONSTANT: word-renames {
@@ -51,6 +52,13 @@ CONSTANT: word-renames {
     { "deep-subseq?" { "deep-subseq-of?" "0.99" } }
     { "overtomorrow" { "overmorrow" "0.99" } }
     { "INITIALIZE:" { "INITIALIZED-SYMBOL:" "0.99" } }
+    { "natural-sort" { "sort" "0.99" } }
+    { "sort-by-with" { "sort-with-spec-by" "0.99" } }
+    { "sort-keys-by" { "sort-keys-with-spec" "0.99" } }
+    { "sort-values-by" { "sort-values-with-spec" "0.99" } }
+    { "compare-slots" { "compare-with-spec" "0.99" } }
+    { "natural-sort!" { "sort!" "0.99" } }
+    { "natural-bubble-sort!" { "bubble-sort!" "0.99" } }
 }
 
 : compute-assoc-fixups ( continuation name assoc -- seq )
diff --git a/basis/globs/globs-tests.factor b/basis/globs/globs-tests.factor
index 0adc3b0290..686b1e50fe 100644
--- a/basis/globs/globs-tests.factor
+++ b/basis/globs/globs-tests.factor
@@ -77,17 +77,17 @@ tools.test ;
         "a/e/g" make-directory
         "a/e/g/e" touch-file
 
-        "**" glob natural-sort
-        "**/" glob natural-sort
-        "**/*" glob natural-sort
-        "**/**" glob natural-sort
-        "**/b" glob natural-sort
-        "**/e" glob natural-sort
-        ! "**//e" glob natural-sort
-        ! "**/**/e" glob natural-sort
-        "**/e/**" glob natural-sort
-        "a/**" glob natural-sort
-        "a" glob natural-sort
-        "a/b" glob natural-sort
+        "**" glob sort
+        "**/" glob sort
+        "**/*" glob sort
+        "**/**" glob sort
+        "**/b" glob sort
+        "**/e" glob sort
+        ! "**//e" glob sort
+        ! "**/**/e" glob sort
+        "**/e/**" glob sort
+        "a/**" glob sort
+        "a" glob sort
+        "a/b" glob sort
     ] with-test-directory
 ] unit-test
diff --git a/basis/heaps/heaps-tests.factor b/basis/heaps/heaps-tests.factor
index 0107eab6e1..9b87817238 100644
--- a/basis/heaps/heaps-tests.factor
+++ b/basis/heaps/heaps-tests.factor
@@ -92,7 +92,7 @@ DEFER: (assert-heap-invariant)
     dup assert-heap-invariant
     data>>
     [ [ key>> ] map ] bi@
-    [ natural-sort ] bi@ ;
+    [ sort ] bi@ ;
 
 11 [
     [ t ] swap [ 2^ delete-test sequence= ] curry unit-test
diff --git a/basis/help/apropos/apropos.factor b/basis/help/apropos/apropos.factor
index 1efe70e6ff..cd8ed38b8f 100644
--- a/basis/help/apropos/apropos.factor
+++ b/basis/help/apropos/apropos.factor
@@ -46,7 +46,7 @@ M: more-completions article-title
     ] "" make ;
 
 M: more-completions article-content
-    seq>> [ second >lower ] sort-with keys \ $completions prefix ;
+    seq>> [ second >lower ] sort-by keys \ $completions prefix ;
 
 :: (apropos) ( search completions category -- element )
     completions [
diff --git a/basis/help/search/search.factor b/basis/help/search/search.factor
index 4f0f025697..87dd0ad205 100644
--- a/basis/help/search/search.factor
+++ b/basis/help/search/search.factor
@@ -41,7 +41,7 @@ MEMO: article-words ( name -- words )
         ] [
             first '[ article-words [ _ head? ] any? ] filter
         ] if
-    ] if-empty [ article-name ] sort-with ;
+    ] if-empty [ article-name ] sort-by ;
 
 PRIVATE>
 
diff --git a/basis/help/vocabs/vocabs.factor b/basis/help/vocabs/vocabs.factor
index 500afffbda..a4ade54c9d 100644
--- a/basis/help/vocabs/vocabs.factor
+++ b/basis/help/vocabs/vocabs.factor
@@ -206,7 +206,7 @@ C: <vocab-author> vocab-author
     [
         "Words" $heading
 
-        natural-sort
+        sort
         [ [ class? ] filter describe-classes ]
         [
             [ [ class? ] [ symbol? ] bi and ] reject
@@ -266,7 +266,7 @@ C: <vocab-author> vocab-author
 : keyed-vocabs ( str quot -- seq )
     [ all-disk-vocabs-recursive ] 2dip '[
         [ _ swap @ member? ] filter no-prefixes
-        [ name>> ] sort-with
+        [ name>> ] sort-by
     ] assoc-map ; inline
 
 : tagged ( tag -- assoc )
diff --git a/basis/http/server/static/static.factor b/basis/http/server/static/static.factor
index e83e6c4c61..38ca7a3513 100644
--- a/basis/http/server/static/static.factor
+++ b/basis/http/server/static/static.factor
@@ -114,26 +114,26 @@ TUPLE: file-responder root hook special index-names allow-listings ;
         [ ?toggle-sort-order ] 2bi append
     ] curry tri@ ;
 
-: listing-sort-with ( seq quot: ( elt -- key ) -- sortedseq )
-    sort-with sort-asc? [ reverse ] unless ; inline
+: listing-sort-by ( seq quot: ( elt -- key ) -- sortedseq )
+    sort-by sort-asc? [ reverse ] unless ; inline
 
-: sort-with-name ( {file,info} -- sorted )
-    [ first ] listing-sort-with ;
+: sort-by-name ( {file,info} -- sorted )
+    [ first ] listing-sort-by ;
 
-: sort-with-modified ( {file,info} -- sorted )
-    [ second modified>> ] listing-sort-with ;
+: sort-by-modified ( {file,info} -- sorted )
+    [ second modified>> ] listing-sort-by ;
 
 : size-without-directories ( info -- size )
     dup directory? [ drop -1 ] [ size>> ] if ;
 
-: sort-with-size ( {file,info} -- sorted )
-    [ second size-without-directories ] listing-sort-with ;
+: sort-by-size ( {file,info} -- sorted )
+    [ second size-without-directories ] listing-sort-by ;
 
 : sort-listing ( zipped-files-infos -- sorted )
     sort-column {
-        { "M" [ sort-with-modified ] }
-        { "S" [ sort-with-size ] }
-        [ drop sort-with-name ]
+        { "M" [ sort-by-modified ] }
+        { "S" [ sort-by-size ] }
+        [ drop sort-by-name ]
     } case ; inline
 
 : zip-files-infos ( files -- zipped )
diff --git a/basis/interval-maps/interval-maps.factor b/basis/interval-maps/interval-maps.factor
index 8397511956..79ff552aab 100644
--- a/basis/interval-maps/interval-maps.factor
+++ b/basis/interval-maps/interval-maps.factor
@@ -45,7 +45,7 @@ PRIVATE>
     interval-map check-instance array>> [ third-unsafe ] map ;
 
 : <interval-map> ( specification -- map )
-    all-intervals [ first-unsafe second-unsafe ] sort-with
+    all-intervals [ first-unsafe second-unsafe ] sort-by
     >intervals ensure-disjoint interval-map boa ;
 
 : <interval-set> ( specification -- map )
diff --git a/basis/io/directories/directories-tests.factor b/basis/io/directories/directories-tests.factor
index 2f2d95ff13..92d7e52d8d 100644
--- a/basis/io/directories/directories-tests.factor
+++ b/basis/io/directories/directories-tests.factor
@@ -179,7 +179,7 @@ tools.test ;
 { t } [
     [
         10 [ "io.paths.test" "gogogo" unique-file ] replicate
-        "." [ ] find-files [ absolute-path ] map [ natural-sort ] same?
+        "." [ ] find-files [ absolute-path ] map [ sort ] same?
     ] with-test-directory
 ] unit-test
 
@@ -279,8 +279,8 @@ tools.test ;
 
             ! preserve file traversal order, but sort
             ! alphabetically for cross-platform testing
-            dup length 3 / group natural-sort
-            [ natural-sort ] map concat
+            dup length 3 / group sort
+            [ sort ] map concat
         ] with-variable
 
         +breadth-first+ traversal-method [
@@ -290,7 +290,7 @@ tools.test ;
             ! preserve file traversal order, but sort
             ! alphabetically for cross-platform testing
             [ [ length ] bi@ = ] monotonic-split
-            [ natural-sort ] map concat
+            [ sort ] map concat
         ] with-variable
     ] with-test-directory
 ] unit-test
diff --git a/basis/math/primes/factors/factors.factor b/basis/math/primes/factors/factors.factor
index e492cbe500..20a485e46f 100644
--- a/basis/math/primes/factors/factors.factor
+++ b/basis/math/primes/factors/factors.factor
@@ -24,7 +24,7 @@ IN: math.primes.factors
     ] [
         group-factors dup empty? [
             [ first2 [0..b] [ ^ ] with map ] map
-            [ product ] product-map natural-sort
+            [ product ] product-map sort
         ] unless
     ] if ;
 
diff --git a/basis/math/primes/pollard-rho-brent/pollard-rho-brent.factor b/basis/math/primes/pollard-rho-brent/pollard-rho-brent.factor
index 8e434e352d..6ec9f81528 100644
--- a/basis/math/primes/pollard-rho-brent/pollard-rho-brent.factor
+++ b/basis/math/primes/pollard-rho-brent/pollard-rho-brent.factor
@@ -70,4 +70,4 @@ DEFER: pollard-rho-brent-factors
         ] [
             [ (pollard-rho-brent-factors) ] { } make
         ] if
-    ] if natural-sort ;
+    ] if sort ;
diff --git a/basis/math/statistics/statistics.factor b/basis/math/statistics/statistics.factor
index 82dfa36ff4..68856813f4 100644
--- a/basis/math/statistics/statistics.factor
+++ b/basis/math/statistics/statistics.factor
@@ -83,10 +83,10 @@ M: ranges:range sum-of-quads
 PRIVATE>
 
 : trimmed-mean ( seq p -- x )
-    swap natural-sort trim-points <slice> mean ;
+    swap sort trim-points <slice> mean ;
 
 : winsorized-mean ( seq p -- x )
-    swap natural-sort trim-points
+    swap sort trim-points
     [ <slice> ]
     [ nip dupd nth <array> ]
     [ [ 1 - ] dip nth <array> ] 3tri
@@ -420,6 +420,6 @@ PRIVATE>
         dup dcg [
             drop 0.0
         ] [
-            swap natural-sort <reversed> dcg /f
+            swap sort <reversed> dcg /f
         ] if-zero
     ] if-empty ;
diff --git a/basis/mime/multipart/multipart-tests.factor b/basis/mime/multipart/multipart-tests.factor
index 956fd27ad5..bb36e6da2b 100644
--- a/basis/mime/multipart/multipart-tests.factor
+++ b/basis/mime/multipart/multipart-tests.factor
@@ -55,7 +55,7 @@ CONSTANT: upload3 "--3f116598c7f0431b9f98148ed235c822\r\nContent-Disposition: fo
     { "text" "text2" }
 } [
     upload3 [ separator3 parse-multipart ] with-string-reader
-    keys natural-sort
+    keys sort
 ] unit-test
 
 SYMBOL: mime-test-server
diff --git a/basis/models/sort/sort.factor b/basis/models/sort/sort.factor
index e9daeb1c31..576fc5024c 100644
--- a/basis/models/sort/sort.factor
+++ b/basis/models/sort/sort.factor
@@ -4,4 +4,4 @@ USING: models.arrow.smart sorting ;
 IN: models.sort
 
 : <sort> ( values sort -- model )
-    [ '[ _ call( obj1 obj2 -- <=> ) ] sort ] <smart-arrow> ; inline
+    [ '[ _ call( obj1 obj2 -- <=> ) ] sort-with ] <smart-arrow> ; inline
diff --git a/basis/regexp/minimize/minimize.factor b/basis/regexp/minimize/minimize.factor
index 8029d9d175..689e15701d 100644
--- a/basis/regexp/minimize/minimize.factor
+++ b/basis/regexp/minimize/minimize.factor
@@ -23,7 +23,7 @@ IN: regexp.minimize
 
 :: initialize-partitions ( transition-table -- partitions )
     ! Partition table is sorted-array => ?
-    transition-table transitions>> keys natural-sort :> states
+    transition-table transitions>> keys sort :> states
     states length 2/ sq <hash-set> :> out
     states [| s1 i1 |
         states [| s2 |
@@ -47,7 +47,7 @@ IN: regexp.minimize
     ] each partitions dup cardinality size = not ;
 
 : partition>classes ( partitions -- synonyms ) ! old-state => new-state
-    members natural-sort <reversed> [ swap ] H{ } assoc-map-as ;
+    members inv-sort [ swap ] H{ } assoc-map-as ;
 
 : (state-classes) ( transition-table -- partition )
     [ initialize-partitions ] keep '[ _ partition-more ] loop ;
diff --git a/basis/see/see.factor b/basis/see/see.factor
index b6ecf57032..df14c4249c 100644
--- a/basis/see/see.factor
+++ b/basis/see/see.factor
@@ -255,15 +255,15 @@ M: error-class see* see-class ;
     dup implementors
     [ [ reader? ] [ writer? ] bi or ] reject
     [ lookup-method ] with map
-    natural-sort ;
+    sort ;
 
 : seeing-methods ( generic -- seq )
-    "methods" word-prop values natural-sort ;
+    "methods" word-prop values sort ;
 
 PRIVATE>
 
 : see-all ( seq -- )
-    natural-sort [ nl nl ] [ see* ] interleave ;
+    sort [ nl nl ] [ see* ] interleave ;
 
 : methods ( word -- seq )
     [
diff --git a/basis/sequences/parser/parser.factor b/basis/sequences/parser/parser.factor
index f7ed06c164..2dc1659f7b 100644
--- a/basis/sequences/parser/parser.factor
+++ b/basis/sequences/parser/parser.factor
@@ -2,7 +2,7 @@
 ! See https://factorcode.org/license.txt for BSD license.
 USING: accessors circular combinators.short-circuit io kernel
 math math.order sequences sequences.parser sequences.private
-sorting.functor sorting.slots unicode ;
+sorting unicode ;
 IN: sequences.parser
 
 TUPLE: sequence-parser sequence n ;
@@ -132,10 +132,7 @@ TUPLE: sequence-parser sequence n ;
         sequence-parser [ n + ] change-n drop
     ] if ;
 
-<< "length" [ length ] define-sorting >>
-
-: sort-tokens ( seq -- seq' )
-    { length>=< <=> } sort-by ;
+: sort-tokens ( seq -- seq' ) [ length ] inv-sort-by ;
 
 : take-first-matching ( sequence-parser seq -- seq )
     swap
diff --git a/basis/sorting/human/human-tests.factor b/basis/sorting/human/human-tests.factor
index c19346579a..feebd1242e 100644
--- a/basis/sorting/human/human-tests.factor
+++ b/basis/sorting/human/human-tests.factor
@@ -1,20 +1,20 @@
-USING: sorting.human tools.test sorting.slots sorting ;
+USING: sorting.human tools.test sorting ;
 
 { { "x1y" "x2" "x10y" } }
-[ { "x1y" "x10y" "x2" } { human<=> } sort-by ] unit-test
+[ { "x1y" "x10y" "x2" } [ human<=> ] sort-with ] unit-test
 
 { { "4dup" "nip" } }
-[ { "4dup" "nip" } [ human<=> ] sort ] unit-test
+[ { "4dup" "nip" } [ human<=> ] sort-with ] unit-test
 
 { { "4dup" "nip" } }
-[ { "nip" "4dup" } [ human<=> ] sort ] unit-test
+[ { "nip" "4dup" } [ human<=> ] sort-with ] unit-test
 
 { { "4dup" "4nip" "5drop" "nip" "nip2" "nipd" } }
-[ { "nip" "4dup" "4nip" "5drop" "nip2" "nipd" } [ human<=> ] sort ] unit-test
+[ { "nip" "4dup" "4nip" "5drop" "nip2" "nipd" } [ human<=> ] sort-with ] unit-test
 
 
 { { "Abc" "abc" "def" "gh" } }
-[ { "abc" "Abc" "def" "gh" } [ human<=> ] sort ] unit-test
+[ { "abc" "Abc" "def" "gh" } [ human<=> ] sort-with ] unit-test
 
 { { "abc" "Abc" "def" "gh" } }
-[ { "abc" "Abc" "def" "gh" } [ humani<=> ] sort ] unit-test
+[ { "abc" "Abc" "def" "gh" } [ humani<=> ] sort-with ] unit-test
diff --git a/basis/sorting/human/human.factor b/basis/sorting/human/human.factor
index 103d0048a4..dbb4decb96 100644
--- a/basis/sorting/human/human.factor
+++ b/basis/sorting/human/human.factor
@@ -49,5 +49,5 @@ M: alphanum <=>
 << "human" [ find-numbers [ <alphanum> ] map ] define-sorting >>
 << "humani" [ find-numbers [ <alphanum-insensitive> ] map ] define-sorting >>
 
-: human-sort ( seq -- seq' ) [ human<=> ] sort ;
-: humani-sort ( seq -- seq' ) [ humani<=> ] sort ;
+: human-sort ( seq -- seq' ) [ human<=> ] sort-with ;
+: humani-sort ( seq -- seq' ) [ humani<=> ] sort-with ;
diff --git a/basis/sorting/slots/authors.txt b/basis/sorting/slots/authors.txt
deleted file mode 100644
index 5674120196..0000000000
--- a/basis/sorting/slots/authors.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-Doug Coleman
-Slava Pestov
diff --git a/basis/sorting/slots/slots-docs.factor b/basis/sorting/slots/slots-docs.factor
deleted file mode 100644
index 178805e437..0000000000
--- a/basis/sorting/slots/slots-docs.factor
+++ /dev/null
@@ -1,48 +0,0 @@
-! Copyright (C) 2009 Doug Coleman.
-! See https://factorcode.org/license.txt for BSD license.
-USING: help.markup help.syntax kernel quotations math.order
-sequences ;
-IN: sorting.slots
-
-HELP: compare-slots
-{ $values
-  { "obj1" object }
-  { "obj2" object }
-  { "sort-specs" "a sequence of accessors ending with a comparator" }
-  { "<=>" { $link +lt+ } " " { $link +eq+ } " or " { $link +gt+ } }
-}
-{ $description "Compares two objects using a chain of intrinsic linear orders such that if two objects are " { $link +eq+ } ", then the next comparator is tried. The comparators are slot-name/comparator pairs." } ;
-
-HELP: sort-by
-{ $values
-    { "seq" sequence } { "sort-specs" "a sequence of accessors ending with a comparator" }
-    { "seq'" sequence }
-}
-{ $description "Sorts a sequence of tuples by the sort-specs in " { $snippet "sort-spec" } ". A sort-spec is a sequence of slot accessors ending in a comparator." }
-{ $examples
-    "Sort by slot a, then b descending:"
-    { $example
-        "USING: accessors math.order prettyprint sorting.slots ;"
-        "IN: scratchpad"
-        "TUPLE: sort-me a b ;"
-        "{"
-        "    T{ sort-me f 2 3 } T{ sort-me f 3 2 }"
-        "    T{ sort-me f 4 3 } T{ sort-me f 2 1 }"
-        "}"
-        "{ { a>> <=> } { b>> >=< } } sort-by ."
-        "{\n    T{ sort-me { a 2 } { b 3 } }\n    T{ sort-me { a 2 } { b 1 } }\n    T{ sort-me { a 3 } { b 2 } }\n    T{ sort-me { a 4 } { b 3 } }\n}"
-    }
-} ;
-
-ARTICLE: "sorting.slots" "Sorting by slots"
-"The " { $vocab-link "sorting.slots" } " vocabulary can sort tuples by slot in ascending or descending order, using subsequent slots as tie-breakers." $nl
-"Comparing two objects by a sequence of slots:"
-{ $subsections compare-slots }
-"Sorting a sequence of tuples by a slot/comparator pairs:"
-{ $subsections
-    sort-by
-    sort-keys-by
-    sort-values-by
-} ;
-
-ABOUT: "sorting.slots"
diff --git a/basis/sorting/slots/slots-tests.factor b/basis/sorting/slots/slots-tests.factor
deleted file mode 100644
index 4772a4d1d5..0000000000
--- a/basis/sorting/slots/slots-tests.factor
+++ /dev/null
@@ -1,100 +0,0 @@
-! Copyright (C) 2009 Doug Coleman.
-! See https://factorcode.org/license.txt for BSD license.
-USING: accessors math.order sorting.slots tools.test
-arrays sequences kernel assocs multiline sorting.functor ;
-IN: sorting.literals.tests
-
-TUPLE: sort-test a b c tuple2 ;
-
-TUPLE: tuple2 d ;
-
-{
-    {
-        T{ sort-test { a 1 } { b 3 } { c 9 } }
-        T{ sort-test { a 1 } { b 1 } { c 10 } }
-        T{ sort-test { a 1 } { b 1 } { c 11 } }
-        T{ sort-test { a 2 } { b 5 } { c 2 } }
-        T{ sort-test { a 2 } { b 5 } { c 3 } }
-    }
-} [
-    {
-        T{ sort-test f 1 3 9 }
-        T{ sort-test f 1 1 10 }
-        T{ sort-test f 1 1 11 }
-        T{ sort-test f 2 5 3 }
-        T{ sort-test f 2 5 2 }
-    } { { a>> <=> } { b>> >=< } { c>> <=> } } sort-by
-] unit-test
-
-{
-    {
-        T{ sort-test { a 1 } { b 3 } { c 9 } }
-        T{ sort-test { a 1 } { b 1 } { c 10 } }
-        T{ sort-test { a 1 } { b 1 } { c 11 } }
-        T{ sort-test { a 2 } { b 5 } { c 2 } }
-        T{ sort-test { a 2 } { b 5 } { c 3 } }
-    }
-} [
-    {
-        T{ sort-test f 1 3 9 }
-        T{ sort-test f 1 1 10 }
-        T{ sort-test f 1 1 11 }
-        T{ sort-test f 2 5 3 }
-        T{ sort-test f 2 5 2 }
-    } { { a>> <=> } { b>> >=< } { c>> <=> } } sort-by
-] unit-test
-
-{ { } }
-[ { } { { a>> <=> } { b>> >=< } { c>> <=> } } sort-by ] unit-test
-
-{ { } }
-[ { } { } sort-by ] unit-test
-
-{
-    {
-        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 1 } } } }
-        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 2 } } } }
-        T{ sort-test { a 5 } { tuple2 T{ tuple2 { d 3 } } } }
-        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 3 } } } }
-        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 3 } } } }
-        T{ sort-test { a 5 } { tuple2 T{ tuple2 { d 4 } } } }
-    }
-} [
-    {
-        T{ sort-test f 6 f f T{ tuple2 f 1 } }
-        T{ sort-test f 5 f f T{ tuple2 f 4 } }
-        T{ sort-test f 6 f f T{ tuple2 f 3 } }
-        T{ sort-test f 6 f f T{ tuple2 f 3 } }
-        T{ sort-test f 5 f f T{ tuple2 f 3 } }
-        T{ sort-test f 6 f f T{ tuple2 f 2 } }
-    } { { tuple2>> d>> <=> } { a>> <=> } } sort-by
-] unit-test
-
-
-{ { "a" "b" "c" } } [ { "b" "c" "a" } { <=> <=> } sort-by ] unit-test
-{ { "b" "c" "a" } } [ { "b" "c" "a" } { } sort-by ] unit-test
-
-<< "length-test" [ length ] define-sorting >>
-
-{ { { 1 } { 1 2 3 } { 1 3 2 } { 3 2 1 } } }
-[
-    { { 3 2 1 } { 1 2 3 } { 1 3 2 } { 1 } }
-    { length-test<=> <=> } sort-by
-] unit-test
-
-{ { { { 0 } 1 } { { 1 } 2 } { { 1 } 1 } { { 3 1 } 2 } } }
-[
-    { { { 3 1 } 2 } { { 1 } 2 } { { 0 } 1 } { { 1 } 1 } }
-    { length-test<=> <=> } sort-keys-by
-] unit-test
-
-{ { { 0 { 1 } } { 1 { 1 } } { 3 { 2 4 } } { 1 { 2 0 0 0 } } } }
-[
-    { { 3 { 2 4 } } { 1 { 2 0 0 0 } } { 0 { 1 } } { 1 { 1 } } }
-    { length-test<=> <=> } sort-values-by
-] unit-test
-
-{ { { "apples" 1 } { "bananas" 2 } { "cherries" 3 } } } [
-    H{ { "apples" 1 } { "bananas" 2 } { "cherries" 3 } }
-    { { sequences:length <=> } } sort-keys-by
-] unit-test
diff --git a/basis/sorting/slots/slots.factor b/basis/sorting/slots/slots.factor
deleted file mode 100644
index 66c387401b..0000000000
--- a/basis/sorting/slots/slots.factor
+++ /dev/null
@@ -1,30 +0,0 @@
-! Copyright (C) 2009 Slava Pestov, Doug Coleman.
-! See https://factorcode.org/license.txt for BSD license.
-USING: arrays assocs fry kernel math.order sequences sorting ;
-IN: sorting.slots
-
-: execute-comparator ( obj1 obj2 word -- <=>/f )
-    execute( obj1 obj2 -- <=> ) dup +eq+ eq? [ drop f ] when ;
-
-: execute-accessor ( obj1 obj2 word -- obj1' obj2' )
-    '[ _ execute( tuple -- value ) ] bi@ ;
-
-: compare-slots ( obj1 obj2 sort-specs -- <=> )
-    ! sort-spec: { accessors comparator }
-    [
-        dup array? [
-            unclip-last-slice
-            [ [ execute-accessor ] each ] dip
-        ] when execute-comparator
-    ] 2with map-find drop +eq+ or ;
-
-: sort-by-with ( seq sort-specs quot: ( obj -- key ) -- seq' )
-    swap '[ _ bi@ _ compare-slots ] sort ; inline
-
-: sort-by ( seq sort-specs -- seq' ) [ ] sort-by-with ;
-
-: sort-keys-by ( alist sort-seq -- seq' )
-    [ >alist ] dip [ first ] sort-by-with ;
-
-: sort-values-by ( seq sort-seq -- seq' )
-    [ >alist ] dip [ second ] sort-by-with ;
diff --git a/basis/sorting/slots/summary.txt b/basis/sorting/slots/summary.txt
deleted file mode 100644
index 240a4ff714..0000000000
--- a/basis/sorting/slots/summary.txt
+++ /dev/null
@@ -1 +0,0 @@
-Sorting by tuple slots
diff --git a/basis/sorting/specification/authors.txt b/basis/sorting/specification/authors.txt
new file mode 100644
index 0000000000..5674120196
--- /dev/null
+++ b/basis/sorting/specification/authors.txt
@@ -0,0 +1,2 @@
+Doug Coleman
+Slava Pestov
diff --git a/basis/sorting/specification/specification-docs.factor b/basis/sorting/specification/specification-docs.factor
new file mode 100644
index 0000000000..fb87d2667a
--- /dev/null
+++ b/basis/sorting/specification/specification-docs.factor
@@ -0,0 +1,48 @@
+! Copyright (C) 2009 Doug Coleman.
+! See https://factorcode.org/license.txt for BSD license.
+USING: help.markup help.syntax kernel quotations math.order
+sequences ;
+IN: sorting.specification
+
+HELP: compare-with-spec
+{ $values
+  { "obj1" object }
+  { "obj2" object }
+  { "sort-spec" "a sequence of sequences of accessors and a comparator" }
+  { "<=>" { $link +lt+ } ", " { $link +eq+ } " or " { $link +gt+ } }
+}
+{ $description "Compares two objects using a chain of intrinsic linear orders such that if two objects are " { $link +eq+ } ", then the next ordering is tried." } ;
+
+HELP: sort-with-spec
+{ $values
+    { "seq" sequence } { "sort-spec" "a sequence of sequences of accessors and a comparator" }
+    { "seq'" sequence }
+}
+{ $description "Sorts a sequence of objects by the sorting specification in " { $snippet "sort-spec" } ". A sorting specification is a sequence of sequences, each consisting of accessors and a comparator." }
+{ $examples
+    "Sort by slot a, then b descending:"
+    { $example
+        "USING: accessors math.order prettyprint sorting.specification ;"
+        "IN: scratchpad"
+        "TUPLE: sort-me a b ;"
+        "{"
+        "    T{ sort-me f 2 3 } T{ sort-me f 3 2 }"
+        "    T{ sort-me f 4 3 } T{ sort-me f 2 1 }"
+        "}"
+        "{ { a>> <=> } { b>> >=< } } sort-with-spec ."
+        "{\n    T{ sort-me { a 2 } { b 3 } }\n    T{ sort-me { a 2 } { b 1 } }\n    T{ sort-me { a 3 } { b 2 } }\n    T{ sort-me { a 4 } { b 3 } }\n}"
+    }
+} ;
+
+ARTICLE: "sorting.specification" "Sorting by multiple keys"
+"The " { $vocab-link "sorting.specification" } " vocabulary can sort objects by multiple keys in ascending or descending order, using subsequent keys as tie-breakers." $nl
+"Comparing two objects with a sorting specification:"
+{ $subsections compare-with-spec }
+"Sorting a sequence of objects with a sorting specification:"
+{ $subsections
+    sort-with-spec
+    sort-keys-with-spec
+    sort-values-with-spec
+} ;
+
+ABOUT: "sorting.specification"
diff --git a/basis/sorting/specification/specification-tests.factor b/basis/sorting/specification/specification-tests.factor
new file mode 100644
index 0000000000..05fdbb8ff8
--- /dev/null
+++ b/basis/sorting/specification/specification-tests.factor
@@ -0,0 +1,100 @@
+! Copyright (C) 2009 Doug Coleman.
+! See https://factorcode.org/license.txt for BSD license.
+USING: accessors math.order sorting.specification tools.test
+arrays sequences kernel assocs multiline sorting.functor ;
+IN: sorting.specification.tests
+
+TUPLE: sort-test a b c tuple2 ;
+
+TUPLE: tuple2 d ;
+
+{
+    {
+        T{ sort-test { a 1 } { b 3 } { c 9 } }
+        T{ sort-test { a 1 } { b 1 } { c 10 } }
+        T{ sort-test { a 1 } { b 1 } { c 11 } }
+        T{ sort-test { a 2 } { b 5 } { c 2 } }
+        T{ sort-test { a 2 } { b 5 } { c 3 } }
+    }
+} [
+    {
+        T{ sort-test f 1 3 9 }
+        T{ sort-test f 1 1 10 }
+        T{ sort-test f 1 1 11 }
+        T{ sort-test f 2 5 3 }
+        T{ sort-test f 2 5 2 }
+    } { { a>> <=> } { b>> >=< } { c>> <=> } } sort-with-spec
+] unit-test
+
+{
+    {
+        T{ sort-test { a 1 } { b 3 } { c 9 } }
+        T{ sort-test { a 1 } { b 1 } { c 10 } }
+        T{ sort-test { a 1 } { b 1 } { c 11 } }
+        T{ sort-test { a 2 } { b 5 } { c 2 } }
+        T{ sort-test { a 2 } { b 5 } { c 3 } }
+    }
+} [
+    {
+        T{ sort-test f 1 3 9 }
+        T{ sort-test f 1 1 10 }
+        T{ sort-test f 1 1 11 }
+        T{ sort-test f 2 5 3 }
+        T{ sort-test f 2 5 2 }
+    } { { a>> <=> } { b>> >=< } { c>> <=> } } sort-with-spec
+] unit-test
+
+{ { } } [
+    { } { { a>> <=> } { b>> >=< } { c>> <=> } } sort-with-spec
+] unit-test
+
+{ { } } [ { } { } sort-with-spec ] unit-test
+
+{
+    {
+        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 1 } } } }
+        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 2 } } } }
+        T{ sort-test { a 5 } { tuple2 T{ tuple2 { d 3 } } } }
+        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 3 } } } }
+        T{ sort-test { a 6 } { tuple2 T{ tuple2 { d 3 } } } }
+        T{ sort-test { a 5 } { tuple2 T{ tuple2 { d 4 } } } }
+    }
+} [
+    {
+        T{ sort-test f 6 f f T{ tuple2 f 1 } }
+        T{ sort-test f 5 f f T{ tuple2 f 4 } }
+        T{ sort-test f 6 f f T{ tuple2 f 3 } }
+        T{ sort-test f 6 f f T{ tuple2 f 3 } }
+        T{ sort-test f 5 f f T{ tuple2 f 3 } }
+        T{ sort-test f 6 f f T{ tuple2 f 2 } }
+    } { { tuple2>> d>> <=> } { a>> <=> } } sort-with-spec
+] unit-test
+
+
+{ { "a" "b" "c" } } [ { "b" "c" "a" } { <=> <=> } sort-with-spec ] unit-test
+{ { "b" "c" "a" } } [ { "b" "c" "a" } { } sort-with-spec ] unit-test
+
+<< "length-test" [ length ] define-sorting >>
+
+{ { { 1 } { 1 2 3 } { 1 3 2 } { 3 2 1 } } }
+[
+    { { 3 2 1 } { 1 2 3 } { 1 3 2 } { 1 } }
+    { length-test<=> <=> } sort-with-spec
+] unit-test
+
+{ { { { 0 } 1 } { { 1 } 2 } { { 1 } 1 } { { 3 1 } 2 } } }
+[
+    { { { 3 1 } 2 } { { 1 } 2 } { { 0 } 1 } { { 1 } 1 } }
+    { length-test<=> <=> } sort-keys-with-spec
+] unit-test
+
+{ { { 0 { 1 } } { 1 { 1 } } { 3 { 2 4 } } { 1 { 2 0 0 0 } } } }
+[
+    { { 3 { 2 4 } } { 1 { 2 0 0 0 } } { 0 { 1 } } { 1 { 1 } } }
+    { length-test<=> <=> } sort-values-with-spec
+] unit-test
+
+{ { { "apples" 1 } { "bananas" 2 } { "cherries" 3 } } } [
+    H{ { "apples" 1 } { "bananas" 2 } { "cherries" 3 } }
+    { { sequences:length <=> } } sort-keys-with-spec
+] unit-test
diff --git a/basis/sorting/specification/specification.factor b/basis/sorting/specification/specification.factor
new file mode 100644
index 0000000000..6132da38b1
--- /dev/null
+++ b/basis/sorting/specification/specification.factor
@@ -0,0 +1,30 @@
+! Copyright (C) 2009 Slava Pestov, Doug Coleman.
+! See https://factorcode.org/license.txt for BSD license.
+USING: arrays assocs kernel math.order sequences sorting ;
+IN: sorting.specification
+
+: execute-comparator ( obj1 obj2 word -- <=>/f )
+    execute( obj1 obj2 -- <=> ) dup +eq+ eq? [ drop f ] when ;
+
+: execute-accessor ( obj1 obj2 word -- obj1' obj2' )
+    '[ _ execute( tuple -- value ) ] bi@ ;
+
+: compare-with-spec ( obj1 obj2 sort-spec -- <=> )
+    ! sort-spec: { { accessor ... comparator } ... }
+    [
+        dup array? [
+            unclip-last-slice
+            [ [ execute-accessor ] each ] dip
+        ] when execute-comparator
+    ] 2with map-find drop +eq+ or ;
+
+: sort-with-spec-by ( seq sort-spec quot: ( obj -- key ) -- sortedseq )
+    swap '[ _ bi@ _ compare-with-spec ] sort-with ; inline
+
+: sort-with-spec ( seq sort-spec -- seq' ) [ ] sort-with-spec-by ;
+
+: sort-keys-with-spec ( assoc sort-spec -- alist )
+    [ >alist ] dip [ first ] sort-with-spec-by ;
+
+: sort-values-with-spec ( assoc sort-spec -- alist )
+    [ >alist ] dip [ second ] sort-with-spec-by ;
diff --git a/basis/sorting/specification/summary.txt b/basis/sorting/specification/summary.txt
new file mode 100644
index 0000000000..81dd16e755
--- /dev/null
+++ b/basis/sorting/specification/summary.txt
@@ -0,0 +1 @@
+Sorting by multiple keys
diff --git a/basis/sorting/title/title-tests.factor b/basis/sorting/title/title-tests.factor
index 03d806a4c9..790fb13935 100644
--- a/basis/sorting/title/title-tests.factor
+++ b/basis/sorting/title/title-tests.factor
@@ -1,6 +1,6 @@
 ! Copyright (C) 2009 Doug Coleman.
 ! See https://factorcode.org/license.txt for BSD license.
-USING: tools.test sorting.title sorting.slots ;
+USING: tools.test sorting sorting.title ;
 IN: sorting.title.tests
 
 : sort-me ( -- seq )
@@ -42,5 +42,5 @@ IN: sorting.title.tests
         "la vida loca"
     }
 } [
-    sort-me { title<=> } sort-by
+    sort-me [ title<=> ] sort-with
 ] unit-test
diff --git a/basis/splitting/monotonic/monotonic.factor b/basis/splitting/monotonic/monotonic.factor
index e1a7a72ed2..030dd3ecc3 100644
--- a/basis/splitting/monotonic/monotonic.factor
+++ b/basis/splitting/monotonic/monotonic.factor
@@ -53,7 +53,7 @@ TUPLE: upward-slice < slice ;
         drop
         [ downward-slices ]
         [ stable-slices ]
-        [ upward-slices ] tri 3append [ from>> ] sort-with
+        [ upward-slices ] tri 3append [ from>> ] sort-by
     ] [
         zero? [ drop { } ] [ [ 0 1 ] dip stable-slice boa ] if
     ] if ;
diff --git a/basis/suffix-arrays/suffix-arrays.factor b/basis/suffix-arrays/suffix-arrays.factor
index 9b8f1bfaf7..fec9dffef9 100644
--- a/basis/suffix-arrays/suffix-arrays.factor
+++ b/basis/suffix-arrays/suffix-arrays.factor
@@ -30,7 +30,7 @@ IN: suffix-arrays
 PRIVATE>
 
 : >suffix-array ( seq -- suffix-array )
-    members [ suffixes ] map concat natural-sort ;
+    members [ suffixes ] map concat sort ;
 
 SYNTAX: SA{ \ } [ >suffix-array ] parse-literal ;
 
diff --git a/basis/tools/annotations/annotations.factor b/basis/tools/annotations/annotations.factor
index 7de102651e..64d6cca431 100644
--- a/basis/tools/annotations/annotations.factor
+++ b/basis/tools/annotations/annotations.factor
@@ -148,6 +148,6 @@ PRIVATE>
 
 : word-timing. ( -- )
     word-timing get >alist
-    [ second first ] sort-with
+    [ second first ] sort-by
     [ first2 first2 [ 1,000,000,000 /f ] dip 3array ] map
     simple-table. ;
diff --git a/basis/tools/coverage/coverage-tests.factor b/basis/tools/coverage/coverage-tests.factor
index f61fa71f90..e386c98653 100644
--- a/basis/tools/coverage/coverage-tests.factor
+++ b/basis/tools/coverage/coverage-tests.factor
@@ -11,7 +11,7 @@ tools.test vocabs.loader ;
 {
   { halftested mconcat testcond testfry testif testifprivate testmacro untested
 }
-} [ "tools.coverage.testvocab" [ ] map-words natural-sort ] unit-test
+} [ "tools.coverage.testvocab" [ ] map-words sort ] unit-test
 
 { t } [
   "tools.coverage.testvocab"
@@ -21,7 +21,7 @@ tools.test vocabs.loader ;
 
 {
   { testifprivate }
-} [ "tools.coverage.testvocab.private" [ ] map-words natural-sort ] unit-test
+} [ "tools.coverage.testvocab.private" [ ] map-words sort ] unit-test
 
 { t } [
   "tools.coverage.testvocab.private"
@@ -44,7 +44,7 @@ tools.test vocabs.loader ;
     { testmacro { } }
     { untested { [ ] } }
   }
-} [ "tools.coverage.testvocab" [ reload ] [ test-coverage natural-sort ] bi ] unit-test
+} [ "tools.coverage.testvocab" [ reload ] [ test-coverage sort ] bi ] unit-test
 
 { 0.75 } [ "tools.coverage.testvocab.child" [ reload ] [ %coverage ] bi ] unit-test
 
@@ -70,6 +70,6 @@ tools.test vocabs.loader ;
 }
 } [
   "tools.coverage.testvocab.child" reload
-  "tools.coverage.testvocab" [ reload ] [ test-coverage-recursively ] bi natural-sort
-  [ first2 natural-sort 2array ] map
+  "tools.coverage.testvocab" [ reload ] [ test-coverage-recursively ] bi sort
+  [ first2 sort 2array ] map
 ] unit-test
diff --git a/basis/tools/crossref/crossref.factor b/basis/tools/crossref/crossref.factor
index 9fbcb13f49..3b91dfa18e 100644
--- a/basis/tools/crossref/crossref.factor
+++ b/basis/tools/crossref/crossref.factor
@@ -124,7 +124,7 @@ M: f smart-usage drop \ f smart-usage ;
             [ "method-generic" word-prop ] when
             vocabulary>>
         ] map
-    ] gather natural-sort remove sift ; inline
+    ] gather sort remove sift ; inline
 
 : vocabs. ( seq -- )
     [ dup >vocab-link write-object nl ] each ;
diff --git a/basis/tools/destructors/destructors.factor b/basis/tools/destructors/destructors.factor
index 9d82549fea..ea723e73d2 100644
--- a/basis/tools/destructors/destructors.factor
+++ b/basis/tools/destructors/destructors.factor
@@ -11,7 +11,7 @@ IN: tools.destructors
     members [ class-of ] collect-by ;
 
 : (disposables.) ( set -- )
-    class-tally >alist [ first2 [ length ] keep 3array ] map [ second ] sort-with
+    class-tally >alist [ first2 [ length ] keep 3array ] map [ second ] sort-by
     standard-table-style [
         [
             [ "Disposable class" write ] with-cell
@@ -31,7 +31,7 @@ IN: tools.destructors
     ] tabular-output nl ;
 
 : sort-disposables ( seq -- seq' )
-    [ disposable? ] partition [ [ id>> ] sort-with ] dip append ;
+    [ disposable? ] partition [ [ id>> ] sort-by ] dip append ;
 
 PRIVATE>
 
diff --git a/basis/tools/files/files.factor b/basis/tools/files/files.factor
index 4b4ffb9771..4ad3ba90bc 100644
--- a/basis/tools/files/files.factor
+++ b/basis/tools/files/files.factor
@@ -2,8 +2,8 @@
 ! See https://factorcode.org/license.txt for BSD license.
 USING: accessors arrays calendar calendar.english
 calendar.format combinators io.directories io.files.info kernel
-math math.parser prettyprint sequences sorting.slots splitting
-system vocabs ;
+math math.parser prettyprint sequences sorting.specification
+splitting system vocabs ;
 IN: tools.files
 
 <PRIVATE
@@ -76,7 +76,7 @@ M: object file-spec>string
 : list-files-slow ( listing-tool -- array )
     [ path>> ] [ sort>> ] [ specs>> ] tri '[
         [ dup name>> link-info file-listing boa ] map
-        _ [ sort-by ] when*
+        _ [ sort-with-spec ] when*
         [ _ [ file-spec>string ] with map ] map
     ] with-directory-entries ; inline
 
diff --git a/basis/tools/memory/memory.factor b/basis/tools/memory/memory.factor
index 5678354a73..23b919d306 100644
--- a/basis/tools/memory/memory.factor
+++ b/basis/tools/memory/memory.factor
@@ -87,7 +87,7 @@ PRIVATE>
     [ '[ _ _ heap-stat-step ] each ] 2keep ;
 
 : heap-stats. ( -- )
-    heap-stats dup keys natural-sort standard-table-style [
+    heap-stats dup keys sort standard-table-style [
         [ { "Class" "Bytes" "Instances" } [ write-cell ] each ] with-row
         [
             [
diff --git a/basis/tools/profiler/sampling/sampling.factor b/basis/tools/profiler/sampling/sampling.factor
index cae79e6cc6..c9aac35a54 100644
--- a/basis/tools/profiler/sampling/sampling.factor
+++ b/basis/tools/profiler/sampling/sampling.factor
@@ -201,7 +201,7 @@ PRIVATE>
     H{ } [ "  " <repetition> concat ] cache write ;
 
 : by-total-time ( nodes -- nodes' )
-    >alist [ second total-time>> ] inv-sort-with ;
+    >alist [ second total-time>> ] inv-sort-by ;
 
 : duration. ( duration -- )
     1000 * "%9.1f" printf ;
diff --git a/basis/tools/scaffold/scaffold.factor b/basis/tools/scaffold/scaffold.factor
index 104b62965b..606927dee4 100644
--- a/basis/tools/scaffold/scaffold.factor
+++ b/basis/tools/scaffold/scaffold.factor
@@ -219,7 +219,7 @@ M: object add-using
 : interesting-words ( vocab -- array )
     vocab-words
     [ { [ "help" word-prop ] [ predicate? ] } 1|| ] reject
-    natural-sort ;
+    sort ;
 
 : interesting-words. ( vocab -- )
     interesting-words [ (help.) nl ] each ;
@@ -241,7 +241,7 @@ M: object add-using
 : write-using ( vocab -- )
     "USING:" write
     using get members
-    { "help.markup" "help.syntax" } append natural-sort remove
+    { "help.markup" "help.syntax" } append sort remove
     [ bl write ] each
     " ;" print ;
 
diff --git a/basis/ui/gadgets/grid-lines/grid-lines-tests.factor b/basis/ui/gadgets/grid-lines/grid-lines-tests.factor
index 00b1c3ceca..20170a6b7a 100644
--- a/basis/ui/gadgets/grid-lines/grid-lines-tests.factor
+++ b/basis/ui/gadgets/grid-lines/grid-lines-tests.factor
@@ -17,7 +17,7 @@ IN: ui.gadgets.grid-lines.tests
     1array
     <grid>
     { 100 100 } >>dim
-    compute-grid-lines natural-sort
+    compute-grid-lines sort
 ] unit-test
 
 {
@@ -33,7 +33,7 @@ IN: ui.gadgets.grid-lines.tests
     <grid>
     { 10 10 } >>gap
     dup prefer
-    compute-grid-lines natural-sort
+    compute-grid-lines sort
 ] unit-test
 
 {
@@ -51,7 +51,7 @@ IN: ui.gadgets.grid-lines.tests
     2array
     <grid>
     { 200.0 200 } >>dim
-    compute-grid-lines natural-sort
+    compute-grid-lines sort
 ] unit-test
 
 {
diff --git a/basis/ui/gadgets/menus/menus.factor b/basis/ui/gadgets/menus/menus.factor
index 5c82c6c501..baa4a21d2a 100644
--- a/basis/ui/gadgets/menus/menus.factor
+++ b/basis/ui/gadgets/menus/menus.factor
@@ -155,7 +155,7 @@ menu H{
 : <operations-menu> ( target hook -- menu )
     over object-operations
     [ primary-operation? ] partition
-    [ reverse ] [ [ command-name ] sort-with ] bi*
+    [ reverse ] [ [ command-name ] sort-by ] bi*
     { ---- } glue <commands-menu> ;
 
 : show-operations-menu ( gadget target hook -- )
diff --git a/basis/ui/tools/inspector/inspector.factor b/basis/ui/tools/inspector/inspector.factor
index b185e7d6cb..2c8c84d19e 100644
--- a/basis/ui/tools/inspector/inspector.factor
+++ b/basis/ui/tools/inspector/inspector.factor
@@ -91,7 +91,7 @@ M: string make-slot-descriptions
     ] { } map-index-as ;
 
 M: hashtable make-slot-descriptions
-    call-next-method [ key-string>> ] sort-with ;
+    call-next-method [ key-string>> ] sort-by ;
 
 TUPLE: inspector-table < table ;
 
diff --git a/basis/unicode/unicode.factor b/basis/unicode/unicode.factor
index 9988f9606e..cad7d0f2e0 100644
--- a/basis/unicode/unicode.factor
+++ b/basis/unicode/unicode.factor
@@ -212,7 +212,7 @@ PRIVATE>
     0 insensitive= ;
 
 : sort-strings ( strings -- sorted )
-    [ collation-key/nfd 2array ] map natural-sort values ;
+    [ collation-key/nfd 2array ] map sort values ;
 
 : string<=> ( str1 str2 -- <=> )
     [ collation-key/nfd 2array ] compare ;
diff --git a/basis/unix/linux/proc/proc.factor b/basis/unix/linux/proc/proc.factor
index 576ce1c164..dc7512d9f6 100644
--- a/basis/unix/linux/proc/proc.factor
+++ b/basis/unix/linux/proc/proc.factor
@@ -2,8 +2,8 @@
 ! See https://factorcode.org/license.txt for BSD license.
 USING: accessors arrays combinators combinators.smart
 io.encodings.utf8 io.files kernel math math.order math.parser
-memoize sequences sorting.slots splitting splitting.monotonic
-strings io.pathnames calendar words ;
+memoize sequences sorting.specification splitting
+splitting.monotonic strings io.pathnames calendar words ;
 IN: unix.linux.proc
 
 ! /proc/*
@@ -110,7 +110,7 @@ ERROR: unknown-cpuinfo-line string ;
     { "" } split harvest [ lines>processor-info ] map ;
 
 : sort-cpus ( seq -- seq )
-    { { physical-id>> <=> } { core-id>> <=> } } sort-by
+    { { physical-id>> <=> } { core-id>> <=> } } sort-with-spec
     [ [ physical-id>> ] bi@ = ] monotonic-split
     [ [ [ core-id>> ] bi@ = ] monotonic-split ] map ;
 
diff --git a/basis/vocabs/hierarchy/hierarchy.factor b/basis/vocabs/hierarchy/hierarchy.factor
index 407e270825..0d50928854 100644
--- a/basis/vocabs/hierarchy/hierarchy.factor
+++ b/basis/vocabs/hierarchy/hierarchy.factor
@@ -18,7 +18,7 @@ M: vocab-prefix vocab-name name>> ;
     { [ directory? ] [ name>> "." head? not ] } 1&& ;
 
 : visible-dirs ( seq -- seq' )
-    [ visible-dir? ] filter [ name>> ] sort-with ;
+    [ visible-dir? ] filter [ name>> ] sort-by ;
 
 ERROR: vocab-root-required root ;
 
@@ -106,7 +106,7 @@ MEMO: all-disk-vocabs-recursive ( -- assoc )
 
 : collect-vocabs ( quot -- seq )
     [ all-disk-vocabs-recursive filter-vocabs ] dip
-    gather natural-sort ; inline
+    gather sort ; inline
 
 : maybe-include-root/prefix ( root prefix -- vocab-link/f )
     over [
diff --git a/basis/vocabs/metadata/resources/resources-tests.factor b/basis/vocabs/metadata/resources/resources-tests.factor
index 79700eb1b3..94fc5d97d4 100644
--- a/basis/vocabs/metadata/resources/resources-tests.factor
+++ b/basis/vocabs/metadata/resources/resources-tests.factor
@@ -21,10 +21,10 @@ IN: vocabs.metadata.resources.tests
 
 ! vocab-resource-files
 { { "bar" "bas" "foo" } }
-[ "vocabs.metadata.resources.test.1" vocab-resource-files natural-sort ] unit-test
+[ "vocabs.metadata.resources.test.1" vocab-resource-files sort ] unit-test
 
 { { "bar.wtf" "foo.wtf" } }
-[ "vocabs.metadata.resources.test.2" vocab-resource-files natural-sort ] unit-test
+[ "vocabs.metadata.resources.test.2" vocab-resource-files sort ] unit-test
 
 {
     {
@@ -36,5 +36,5 @@ IN: vocabs.metadata.resources.tests
         "resource-dir/foo"
     }
 } [
-    "vocabs.metadata.resources.test.3" vocab-resource-files natural-sort
+    "vocabs.metadata.resources.test.3" vocab-resource-files sort
 ] unit-test
diff --git a/basis/vocabs/prettyprint/prettyprint.factor b/basis/vocabs/prettyprint/prettyprint.factor
index f92a4b1bac..890ab2a8ef 100644
--- a/basis/vocabs/prettyprint/prettyprint.factor
+++ b/basis/vocabs/prettyprint/prettyprint.factor
@@ -14,8 +14,7 @@ IN: vocabs.prettyprint
 
 <PRIVATE
 
-: sort-vocabs ( seq -- seq' )
-    [ vocab-name ] sort-with ;
+: sort-vocabs ( seq -- seq' ) [ vocab-name ] sort-by ;
 
 : pprint-using ( seq -- )
     "syntax" lookup-vocab '[ _ = ] reject
diff --git a/basis/xmode/catalog/catalog.factor b/basis/xmode/catalog/catalog.factor
index e1f70d6a94..d59e128d6f 100644
--- a/basis/xmode/catalog/catalog.factor
+++ b/basis/xmode/catalog/catalog.factor
@@ -30,7 +30,7 @@ MEMO: modes ( -- modes )
     file>xml parse-modes-tag ;
 
 MEMO: mode-names ( -- modes )
-    modes keys natural-sort ;
+    modes keys sort ;
 
 : reset-catalog ( -- )
     \ modes reset-memoized ;
diff --git a/basis/xmode/keyword-map/keyword-map.factor b/basis/xmode/keyword-map/keyword-map.factor
index 7a9bdfb0bc..83842d8d8a 100644
--- a/basis/xmode/keyword-map/keyword-map.factor
+++ b/basis/xmode/keyword-map/keyword-map.factor
@@ -31,7 +31,7 @@ M: keyword-map >alist
     assoc>> >alist ;
 
 : (keyword-map-no-word-sep) ( assoc -- str )
-    keys union-all [ alpha? ] reject natural-sort ;
+    keys union-all [ alpha? ] reject sort ;
 
 : keyword-map-no-word-sep* ( keyword-map -- str )
     dup no-word-sep>> [ ] [
diff --git a/core/classes/algebra/algebra.factor b/core/classes/algebra/algebra.factor
index d9a9057715..81bd5ea331 100644
--- a/core/classes/algebra/algebra.factor
+++ b/core/classes/algebra/algebra.factor
@@ -270,15 +270,14 @@ ERROR: topological-sort-failed ;
     [ topological-sort-failed ] unless* ;
 
 : sort-classes ( seq -- newseq )
-    [ class-name ] sort-with >vector
+    [ class-name ] sort-by >vector
     [ dup empty? not ]
     [ dup largest-class [ swap remove-nth! ] dip ]
     produce nip ;
 
 : smallest-class ( classes -- class/f )
     [ f ] [
-        natural-sort <reversed>
-        [ ] [ [ class<= ] most ] map-reduce
+        inv-sort [ ] [ [ class<= ] most ] map-reduce
     ] if-empty ;
 
 : flatten-class ( class -- seq )
diff --git a/core/classes/classes-tests.factor b/core/classes/classes-tests.factor
index ff2798030b..b61ff7b807 100644
--- a/core/classes/classes-tests.factor
+++ b/core/classes/classes-tests.factor
@@ -21,7 +21,7 @@ M: method-forget-class method-forget-test ;
 { { } { } } [
     all-words [ class? ] filter
     implementors-map get keys
-    [ natural-sort ] bi@
+    [ sort ] bi@
     [ diff ] [ swap diff ] 2bi
 ] unit-test
 
diff --git a/core/graphs/graphs-tests.factor b/core/graphs/graphs-tests.factor
index 4a69a371c9..0c096ace8f 100644
--- a/core/graphs/graphs-tests.factor
+++ b/core/graphs/graphs-tests.factor
@@ -16,7 +16,7 @@ H{
 } "g" set
 
 { { 2 3 4 5 } } [
-    2 [ "g" get at sets:members ] closure sets:members natural-sort
+    2 [ "g" get at sets:members ] closure sets:members sort
 ] unit-test
 
 { t } [ 2 [ "g" get at sets:members ] HS{ } closure-as hash-set? ] unit-test
diff --git a/core/hash-sets/hash-sets-tests.factor b/core/hash-sets/hash-sets-tests.factor
index 34adcaddfa..90e4f4ac59 100644
--- a/core/hash-sets/hash-sets-tests.factor
+++ b/core/hash-sets/hash-sets-tests.factor
@@ -3,7 +3,7 @@
 USING: accessors hash-sets kernel math prettyprint sequences
 sets sorting tools.test ;
 
-{ { 1 2 3 } } [ HS{ 1 2 3 } members natural-sort ] unit-test
+{ { 1 2 3 } } [ HS{ 1 2 3 } members sort ] unit-test
 
 { "HS{ 1 2 3 4 }" } [ HS{ 1 2 3 4 } unparse ] unit-test
 
@@ -18,7 +18,7 @@ sets sorting tools.test ;
 { t } [ 1 HS{ 1 } ?delete ] unit-test
 { f } [ 1 HS{ } ?delete ] unit-test
 { HS{ 1 2 } } [ HS{ 1 2 } fast-set ] unit-test
-{ { 1 2 } } [ HS{ 1 2 } members natural-sort ] unit-test
+{ { 1 2 } } [ HS{ 1 2 } members sort ] unit-test
 
 { HS{ 1 2 3 4 } } [ HS{ 1 2 3 } HS{ 2 3 4 } union ] unit-test
 { HS{ 2 3 } } [ HS{ 1 2 3 } HS{ 2 3 4 } intersect ] unit-test
diff --git a/core/sets/sets-tests.factor b/core/sets/sets-tests.factor
index f612c74da5..4d27f8c8e0 100644
--- a/core/sets/sets-tests.factor
+++ b/core/sets/sets-tests.factor
@@ -23,8 +23,8 @@ IN: sets.tests
 { 0 } [ 5 <bit-set> 10 over delete cardinality ] unit-test
 { HS{ 1 } } [ HS{ 1 2 } 2 over delete ] unit-test
 
-{ { 1 2 3 } } [ { 1 1 1 2 2 3 3 3 3 3 } dup set-like natural-sort ] unit-test
-{ { 1 2 3 } } [ HS{ 1 2 3 } { } set-like natural-sort ] unit-test
+{ { 1 2 3 } } [ { 1 1 1 2 2 3 3 3 3 3 } dup set-like sort ] unit-test
+{ { 1 2 3 } } [ HS{ 1 2 3 } { } set-like sort ] unit-test
 { { 1 2 3 } } [ { 1 2 2 3 3 } { } set-like ] unit-test
 { { 3 2 1 } } [ { 3 3 2 2 1 } { } set-like ] unit-test
 { t } [ 4 <bit-set> 1 <bit-set> set-like 4 <bit-set> = ] unit-test
diff --git a/core/sorting/sorting-docs.factor b/core/sorting/sorting-docs.factor
index ce284c5938..bc3d7286f3 100644
--- a/core/sorting/sorting-docs.factor
+++ b/core/sorting/sorting-docs.factor
@@ -7,31 +7,32 @@ ARTICLE: "sequences-sorting" "Sorting sequences"
 $nl
 "The algorithm only allocates two additional arrays, both the size of the input sequence, and uses iteration rather than recursion, and thus is suitable for sorting large sequences."
 $nl
-"Sorting combinators all take comparator quotations with stack effect " { $snippet "( elt1 elt2 -- <=> )" } ", where the output value is one of the three " { $link "order-specifiers" } "."
+"Sorting combinators take comparator quotations with stack effect " { $snippet "( elt1 elt2 -- <=> )" } ", where the output value is one of the three " { $link "order-specifiers" } "."
 $nl
 "Sorting a sequence with a custom comparator:"
-{ $subsections sort }
+{ $subsections sort-with }
 "Sorting a sequence with common comparators:"
 { $subsections
-    sort-with
-    inv-sort-with
-    natural-sort
+    sort
+    inv-sort
+    sort-by
+    inv-sort-by
     sort-keys
     sort-values
 } ;
 
 ABOUT: "sequences-sorting"
 
-HELP: sort
+HELP: sort-with
 { $values { "seq" sequence } { "quot" { $quotation ( obj1 obj2 -- <=> ) } } { "sortedseq" "a new sorted sequence" } }
 { $description "Sorts the elements of " { $snippet "seq" } " into a new array using a stable sort." }
 { $notes "The algorithm used is the merge sort." } ;
 
-HELP: sort-with
+HELP: sort-by
 { $values { "seq" sequence } { "quot" { $quotation ( elt -- key ) } } { "sortedseq" "a new sorted sequence" } }
 { $description "Sorts the elements of " { $snippet "seq" } " by applying " { $link compare } " with " { $snippet "quot" } " to each pair of elements in the sequence." } ;
 
-HELP: inv-sort-with
+HELP: inv-sort-by
 { $values { "seq" sequence } { "quot" { $quotation ( elt -- key ) } } { "sortedseq" "a new sorted sequence" } }
 { $description "Sorts the elements of " { $snippet "seq" } " by applying " { $link compare } " with " { $snippet "quot" } " to each pair of elements in the sequence and inverting the results." } ;
 
@@ -43,7 +44,7 @@ HELP: sort-values
 { $values { "obj" object } { "sortedseq" "a new sorted sequence" } }
 { $description "Sorts the elements of " { $snippet "obj" } " (converting to an alist first if not a sequence), comparing second elements of pairs using the " { $link <=> } " word." } ;
 
-HELP: natural-sort
+HELP: sort
 { $values { "seq" sequence } { "sortedseq" "a new sorted sequence" } }
 { $description "Sorts a sequence of objects in natural order using the " { $link <=> } " word." } ;
 
@@ -51,8 +52,4 @@ HELP: sort-pair
 { $values { "a" object } { "b" object } { "c" object } { "d" object } }
 { $description "If " { $snippet "a" } " is greater than " { $snippet "b" } ", exchanges " { $snippet "a" } " with " { $snippet "b" } "." } ;
 
-HELP: midpoint@
-{ $values { "seq" sequence } { "n" integer } }
-{ $description "Outputs the index of the midpoint of " { $snippet "seq" } "." } ;
-
-{ <=> compare natural-sort sort-with inv-sort-with sort-keys sort-values } related-words
+{ <=> compare sort sort-by inv-sort-by sort-keys sort-values } related-words
diff --git a/core/sorting/sorting-tests.factor b/core/sorting/sorting-tests.factor
index 3f84bd4abc..359007f129 100644
--- a/core/sorting/sorting-tests.factor
+++ b/core/sorting/sorting-tests.factor
@@ -1,22 +1,22 @@
 USING: grouping kernel math math.order random sequences sets
 sorting tools.test vocabs ;
 
-{ { } } [ { } natural-sort ] unit-test
+{ { } } [ { } sort ] unit-test
 
 { { 270000000 270000001 } }
-[ T{ slice f 270000000 270000002 T{ iota f 270000002 } } natural-sort ]
+[ T{ slice f 270000000 270000002 T{ iota f 270000002 } } sort ]
 unit-test
 
 { t } [
     100 [
         drop
         100 [ 20 random [ 1000 random ] replicate ] replicate
-        dup natural-sort
+        dup sort
         [ set= ] [ nip [ before=? ] monotonic? ] 2bi and
     ] all-integers?
 ] unit-test
 
-[ { 1 2 } [ 2drop 1 ] sort ] must-not-fail
+[ { 1 2 } [ 2drop 1 ] sort-with ] must-not-fail
 
 ! Is it a stable sort?
 { t } [ { { 1 "a" } { 1 "b" } { 1 "c" } } dup sort-keys = ] unit-test
@@ -24,4 +24,4 @@ unit-test
 { { { 1 "a" } { 1 "b" } { 1 "c" } { 1 "e" } { 2 "d" } } }
 [ { { 1 "a" } { 1 "b" } { 1 "c" } { 2 "d" } { 1 "e" } } sort-keys ] unit-test
 
-[ all-words natural-sort ] must-not-fail
+[ all-words sort ] must-not-fail
diff --git a/core/sorting/sorting.factor b/core/sorting/sorting.factor
index f2e50daef2..1867f4321d 100644
--- a/core/sorting/sorting.factor
+++ b/core/sorting/sorting.factor
@@ -131,17 +131,22 @@ TUPLE: merge-state
 
 PRIVATE>
 
-: sort ( seq quot: ( obj1 obj2 -- <=> ) -- sortedseq )
+: sort-with ( seq quot: ( obj1 obj2 -- <=> ) -- sortedseq )
     [ <merge> ] dip
     [ sort-pairs ] [ sort-loop ] [ drop accum>> underlying>> ] 2tri ; inline
 
-: natural-sort ( seq -- sortedseq ) [ <=> ] sort ;
+: inv-sort-with ( seq quot: ( obj1 obj2 -- <=> ) -- sortedseq )
+    '[ @ invert-comparison ] sort-with ; inline
 
-: sort-with ( seq quot: ( elt -- key ) -- sortedseq )
-    [ compare ] curry sort ; inline
+: sort ( seq -- sortedseq ) [ <=> ] sort-with ;
 
-: inv-sort-with ( seq quot: ( elt -- key ) -- sortedseq )
-    [ compare invert-comparison ] curry sort ; inline
+: inv-sort ( seq -- sortedseq ) [ >=< ] sort-with ;
+
+: sort-by ( seq quot: ( elt -- key ) -- sortedseq )
+    [ compare ] curry sort-with ; inline
+
+: inv-sort-by ( seq quot: ( elt -- key ) -- sortedseq )
+    [ compare invert-comparison ] curry sort-with ; inline
 
 <PRIVATE
 
@@ -150,24 +155,44 @@ PRIVATE>
 
 PRIVATE>
 
-GENERIC: sort-keys ( obj -- sortedseq )
+GENERIC: sort-keys ( assoc -- sorted-keys )
 
 M: object sort-keys >alist sort-keys ;
 
 M: sequence sort-keys
-    0 check-bounds [ first-unsafe ] sort-with ;
+    0 check-bounds [ first-unsafe ] sort-by ;
 
 M: hashtable sort-keys
-    >alist [ { array } declare first-unsafe ] sort-with ;
+    >alist [ { array } declare first-unsafe ] sort-by ;
+
+GENERIC: inv-sort-keys ( assoc -- sorted-keys )
+
+M: object inv-sort-keys >alist inv-sort-keys ;
+
+M: sequence inv-sort-keys
+    0 check-bounds [ first-unsafe ] inv-sort-by ;
 
-GENERIC: sort-values ( obj -- sortedseq )
+M: hashtable inv-sort-keys
+    >alist [ { array } declare first-unsafe ] inv-sort-by ;
+
+GENERIC: sort-values ( assoc -- sorted-values )
 
 M: object sort-values >alist sort-values ;
 
 M: sequence sort-values
-    1 check-bounds [ second-unsafe ] sort-with ;
+    1 check-bounds [ second-unsafe ] sort-by ;
 
 M: hashtable sort-values
-    >alist [ { array } declare second-unsafe ] sort-with ;
+    >alist [ { array } declare second-unsafe ] sort-by ;
 
 : sort-pair ( a b -- c d ) 2dup after? [ swap ] when ;
+
+GENERIC: inv-sort-values ( assoc -- sorted-values )
+
+M: object inv-sort-values >alist inv-sort-values ;
+
+M: sequence inv-sort-values
+    1 check-bounds [ second-unsafe ] inv-sort-by ;
+
+M: hashtable inv-sort-values
+    >alist [ { array } declare second-unsafe ] inv-sort-by ;
diff --git a/core/source-files/errors/errors.factor b/core/source-files/errors/errors.factor
index 8445b0f299..3abdfe3c9a 100644
--- a/core/source-files/errors/errors.factor
+++ b/core/source-files/errors/errors.factor
@@ -27,7 +27,7 @@ M: source-file-error compute-restarts error>> compute-restarts ;
         swap >>error ; inline
 
 : sort-errors ( errors -- alist )
-    [ [ line#>> 0 or ] sort-with ] { } assoc-map-as sort-keys ;
+    [ [ line#>> 0 or ] sort-by ] { } assoc-map-as sort-keys ;
 
 : group-by-source-file ( errors -- assoc )
     [ path>> ] collect-by ;
diff --git a/core/vocabs/parser/parser.factor b/core/vocabs/parser/parser.factor
index 86de9d5fab..43137631d9 100644
--- a/core/vocabs/parser/parser.factor
+++ b/core/vocabs/parser/parser.factor
@@ -10,7 +10,7 @@ IN: vocabs.parser
 ERROR: no-word-error name ;
 
 : word-restarts ( possibilities -- restarts )
-    natural-sort [
+    sort [
         [ vocabulary>> "Use the " " vocabulary" surround ] keep
     ] { } map>assoc ;
 
diff --git a/core/vocabs/vocabs.factor b/core/vocabs/vocabs.factor
index a778ff4235..b56374f868 100644
--- a/core/vocabs/vocabs.factor
+++ b/core/vocabs/vocabs.factor
@@ -99,7 +99,7 @@ GENERIC: vocab-changed ( vocab obj -- )
 ERROR: no-vocab name ;
 
 : loaded-vocab-names ( -- seq )
-    dictionary get keys natural-sort ;
+    dictionary get keys sort ;
 
 : vocab-words ( vocab-spec -- seq )
     vocab-words-assoc values ;
diff --git a/extra/alien/fortran/fortran.factor b/extra/alien/fortran/fortran.factor
index d28475bbb4..c7dc34665d 100644
--- a/extra/alien/fortran/fortran.factor
+++ b/extra/alien/fortran/fortran.factor
@@ -357,7 +357,7 @@ M: character-type (<fortran-result>)
     ] bi* ;
 
 : (fortran-in-shuffle) ( ret par -- seq )
-    [ second ] sort-with append ;
+    [ second ] sort-by append ;
 
 : (fortran-out-shuffle) ( ret par -- seq )
     append ;
diff --git a/extra/anagrams/anagrams.factor b/extra/anagrams/anagrams.factor
index b68f428a7b..023b361885 100644
--- a/extra/anagrams/anagrams.factor
+++ b/extra/anagrams/anagrams.factor
@@ -6,7 +6,7 @@ sequences sequences.extras sorting sets ;
 IN: anagrams
 
 : make-anagram-hash ( strings -- assoc )
-    [ natural-sort ] collect-by
+    [ sort ] collect-by
     [ members ] assoc-map
     [ nip length 1 > ] assoc-filter ;
 
@@ -17,7 +17,7 @@ MEMO: dict-anagrams ( -- assoc )
     dict-words make-anagram-hash ;
 
 : anagrams ( str -- seq/f )
-    >lower natural-sort dict-anagrams at ;
+    >lower sort dict-anagrams at ;
 
 : most-anagrams ( -- seq )
     dict-anagrams values all-longest ;
diff --git a/extra/annotations/annotations-docs.factor b/extra/annotations/annotations-docs.factor
index eee45528a3..1af0c2bdb4 100644
--- a/extra/annotations/annotations-docs.factor
+++ b/extra/annotations/annotations-docs.factor
@@ -47,7 +47,7 @@ PRIVATE>
 {
     "The " { $vocab-link "annotations" } " vocabulary provides syntax for comment-like annotations that can be looked up with Factor's " { $link usage } " mechanism."
 }
-annotation-tags natural-sort
+annotation-tags sort
 [
     [ \ $subsection swap comment-word 2array ] map append
     "To look up annotations:" suffix
diff --git a/extra/benchmark/interval-sets/interval-sets.factor b/extra/benchmark/interval-sets/interval-sets.factor
index 0b2b12e811..693bb6c38f 100644
--- a/extra/benchmark/interval-sets/interval-sets.factor
+++ b/extra/benchmark/interval-sets/interval-sets.factor
@@ -7,7 +7,7 @@ sorting ;
 IN: benchmark.interval-sets
 
 : interval-sets-benchmark ( -- )
-    10,000 [ random-32 ] replicate natural-sort
+    10,000 [ random-32 ] replicate sort
     2 <groups> <interval-set>
     3,000,000 swap '[ random-32 _ interval-in? drop ] times ;
 
diff --git a/extra/benchmark/sort/sort.factor b/extra/benchmark/sort/sort.factor
index 70744c13de..9221f0ec28 100644
--- a/extra/benchmark/sort/sort.factor
+++ b/extra/benchmark/sort/sort.factor
@@ -5,7 +5,7 @@ CONSTANT: numbers-to-sort $[ 300,000 200 random-integers ]
 CONSTANT: alist-to-sort $[ 1,000 <iota> dup zip ]
 
 : sort-benchmark ( -- )
-    10 [ numbers-to-sort natural-sort drop ] times
+    10 [ numbers-to-sort sort drop ] times
     5,000 [ alist-to-sort sort-keys drop ] times ;
 
 MAIN: sort-benchmark
diff --git a/extra/benchmark/splay/splay.factor b/extra/benchmark/splay/splay.factor
index 1872fb2fac..ce074a7feb 100644
--- a/extra/benchmark/splay/splay.factor
+++ b/extra/benchmark/splay/splay.factor
@@ -15,6 +15,6 @@ IN: benchmark.splay
 : splay-benchmark ( -- )
     100,000 initial-alist 10,000 cut
     [ >splay ] [ randomize 10,000 head ] bi
-    change-random keys dup natural-sort assert= ;
+    change-random keys dup sort assert= ;
 
 MAIN: splay-benchmark
diff --git a/extra/build-from-source/windows/windows.factor b/extra/build-from-source/windows/windows.factor
index 52df5c49a5..ebdb2ee1cd 100644
--- a/extra/build-from-source/windows/windows.factor
+++ b/extra/build-from-source/windows/windows.factor
@@ -4,7 +4,7 @@ USING: accessors build-from-source environment html.parser
 html.parser.analyzer http.client io.backend io.directories
 io.encodings.utf8 io.files io.files.temp io.launcher
 io.pathnames kernel multiline qw sequences sorting.human
-sorting.slots windows.shell32 ;
+windows.shell32 ;
 IN: build-from-source.windows
 
 ! choco install -y meson StrawberryPerl nasm winflexbison3 glfw3
diff --git a/extra/c/lexer/lexer.factor b/extra/c/lexer/lexer.factor
index be88612966..8869d59d58 100644
--- a/extra/c/lexer/lexer.factor
+++ b/extra/c/lexer/lexer.factor
@@ -2,7 +2,7 @@
 ! See https://factorcode.org/license.txt for BSD license.
 USING: accessors combinators combinators.short-circuit kernel
 math.order ranges sequences sequences.generalizations
-sequences.parser sorting.functor sorting.slots unicode ;
+sequences.parser sorting unicode ;
 IN: c.lexer
 
 : take-c-comment ( sequence-parser -- seq/f )
@@ -91,10 +91,7 @@ IN: c.lexer
 : take-c-identifier ( sequence-parser -- string/f )
     [ (take-c-identifier) ] with-sequence-parser ;
 
-<< "length" [ length ] define-sorting >>
-
-: sort-tokens ( seq -- seq' )
-    { length>=< <=> } sort-by ;
+: sort-tokens ( seq -- seq' ) [ length ] inv-sort-by ;
 
 : take-c-integer ( sequence-parser -- string/f )
     [
diff --git a/extra/codebook/codebook.factor b/extra/codebook/codebook.factor
index ecf8455546..9ead19053b 100644
--- a/extra/codebook/codebook.factor
+++ b/extra/codebook/codebook.factor
@@ -54,7 +54,7 @@ TUPLE: code-file
         dup detect-file dup binary?
         [ f ] [ 2dup dupd first-line find-mode ] if
         code-file boa
-    ] map [ mode>> ] filter [ name>> ] sort-with ;
+    ] map [ mode>> ] filter [ name>> ] sort-by ;
 
 : html-name-char ( char -- str )
     {
@@ -67,7 +67,7 @@ TUPLE: code-file
     [ html-name-char ] { } map-as concat ".html" append ;
 
 : toc-list ( files -- list )
-    [ name>> ] map natural-sort [
+    [ name>> ] map sort [
         [ file-html-name ] keep
         [XML <li><a href=<->><-></a></li> XML]
     ] map ;
diff --git a/extra/color-table/color-table.factor b/extra/color-table/color-table.factor
index a479388b96..00ef2894af 100644
--- a/extra/color-table/color-table.factor
+++ b/extra/color-table/color-table.factor
@@ -1,9 +1,9 @@
 ! Copyright (C) 2009 Slava Pestov.
 ! See https://factorcode.org/license.txt for BSD license.
 USING: accessors colors combinators combinators.smart formatting
-kernel literals math math.functions models sorting.human
-sorting.slots strings ui ui.gadgets.scrollers
-ui.gadgets.search-tables ui.gadgets.tables ;
+kernel literals math math.functions models sorting.human strings
+ui ui.gadgets.scrollers ui.gadgets.search-tables
+ui.gadgets.tables ;
 IN: color-table
 
 ! ui.gadgets.tables demo
@@ -39,7 +39,7 @@ M: color-renderer row-value
     drop named-color ;
 
 : <color-table> ( -- table )
-    named-colors { humani<=> } sort-by <model>
+    named-colors humani-sort <model>
     color-renderer
     [ ] <search-table> dup table>>
         5 >>gap
diff --git a/extra/command-loop/command-loop.factor b/extra/command-loop/command-loop.factor
index 8e6aa02414..14b63a1144 100644
--- a/extra/command-loop/command-loop.factor
+++ b/extra/command-loop/command-loop.factor
@@ -25,7 +25,7 @@ GENERIC: run-command-loop ( command-loop -- )
         nl
         "Commands available:" print
         "===================" print
-        nip commands>> [ name>> ] map natural-sort
+        nip commands>> [ name>> ] map sort
         [ 6 <groups> ] [ longest length 4 + ] bi
         '[ [ _ CHAR: \s pad-tail write ] each nl ] each nl
     ] [
diff --git a/extra/compiler/cfg/gvn/testing/testing.factor b/extra/compiler/cfg/gvn/testing/testing.factor
index 2c27728e60..1d0d1d37ca 100644
--- a/extra/compiler/cfg/gvn/testing/testing.factor
+++ b/extra/compiler/cfg/gvn/testing/testing.factor
@@ -26,7 +26,7 @@ M: object expr>str unparse ;
     ] if ;
 
 : gvns ( -- str )
-    vregs>vns get >alist natural-sort [
+    vregs>vns get >alist sort [
         first2 value-mapping
     ] map "" concat-as ;
 
@@ -36,9 +36,9 @@ M: object expr>str unparse ;
     ] keep ;
 
 : congruence-classes ( -- str )
-    vregs>vns get invert-assoc >alist natural-sort [
+    vregs>vns get invert-assoc >alist sort [
         first2
-        natural-sort [ number>string ] map ", " join
+        sort [ number>string ] map ", " join
         over exprs>vns get value-at expr>str
         "<%d> : {%s} (%s)\\l" sprintf
     ] map "" concat-as ;
diff --git a/extra/contributors/contributors.factor b/extra/contributors/contributors.factor
index 4187326181..ddb074cc04 100644
--- a/extra/contributors/contributors.factor
+++ b/extra/contributors/contributors.factor
@@ -33,7 +33,7 @@ CONSTANT: aliases {
 
 : contributors ( -- )
     changelog histogram merge-aliases
-    sort-values <reversed>
+    inv-sort-values
     simple-table. ;
 
 MAIN: contributors
diff --git a/extra/cursors/cursors-tests.factor b/extra/cursors/cursors-tests.factor
index 7650f8a24b..a99f8b363f 100644
--- a/extra/cursors/cursors-tests.factor
+++ b/extra/cursors/cursors-tests.factor
@@ -31,13 +31,13 @@ IN: cursors.tests
     [
         H{ { "roses" "lutefisk" } { "tulips" "lox" } }
         [ ": " glue , ] assoc-each
-    ] { } make natural-sort
+    ] { } make sort
 ] unit-test
 
 { { "roses: lutefisk" "tulips: lox" } }
 [
     H{ { "roses" "lutefisk" } { "tulips" "lox" } }
-    [ ": " glue ] { } assoc>map natural-sort
+    [ ": " glue ] { } assoc>map sort
 ] unit-test
 
 : compile-test-each ( xs -- )
@@ -58,11 +58,11 @@ IN: cursors.tests
 { { "roses: lutefisk" "tulips: lox" } }
 [
     [ H{ { "roses" "lutefisk" } { "tulips" "lox" } } compile-test-assoc-each ]
-    { } make natural-sort
+    { } make sort
 ] unit-test
 
 { { "roses: lutefisk" "tulips: lox" } }
 [
     H{ { "roses" "lutefisk" } { "tulips" "lox" } } compile-test-assoc>map
-    natural-sort
+    sort
 ] unit-test
diff --git a/extra/did-you-mean/did-you-mean.factor b/extra/did-you-mean/did-you-mean.factor
index c31bf5ffc2..7f1c9f0b67 100644
--- a/extra/did-you-mean/did-you-mean.factor
+++ b/extra/did-you-mean/did-you-mean.factor
@@ -8,7 +8,7 @@ vocabs.parser ;
 IN: did-you-mean
 
 : did-you-mean-restarts ( possibilities -- restarts )
-    natural-sort
+    sort
     [ [ [ vocabulary>> ] [ name>> ] bi "Use %s:%s" sprintf ] keep ]
     { } map>assoc ;
 
diff --git a/extra/enigma/enigma-tests.factor b/extra/enigma/enigma-tests.factor
index e07c2bb961..330151d7e9 100644
--- a/extra/enigma/enigma-tests.factor
+++ b/extra/enigma/enigma-tests.factor
@@ -1,7 +1,7 @@
 
 USING: enigma kernel math sequences sorting tools.test ;
 
-{ t } [ <reflector> natural-sort 26 <iota> sequence= ] unit-test
+{ t } [ <reflector> sort 26 <iota> sequence= ] unit-test
 
 { "" } [ "" 4 <enigma> encode ] unit-test
 
diff --git a/extra/fuel/xref/xref.factor b/extra/fuel/xref/xref.factor
index 6a5d92f290..31da53a38b 100644
--- a/extra/fuel/xref/xref.factor
+++ b/extra/fuel/xref/xref.factor
@@ -25,10 +25,10 @@ IN: fuel.xref
     [ word? ] filter [ word>xref ] map ;
 
 : group-xrefs ( xrefs -- xrefs' )
-    natural-sort [ second ] collect-by
+    sort [ second ] collect-by
     ! Change key from 'name' to { name path }
     [ [ [ third ] map-find drop 2array ] keep ] assoc-map
-    >alist natural-sort ;
+    >alist sort ;
 
 : filter-prefix ( seq prefix -- seq )
     [ drop-prefix nip empty? ] curry filter members ;
@@ -71,4 +71,4 @@ PRIVATE>
 : get-vocabs/prefix ( prefix -- seq ) all-disk-vocab-names swap filter-prefix ;
 
 : get-vocabs-words/prefix ( prefix names/f -- seq )
-    [ vocabs-words ] [ current-words ] if* natural-sort swap filter-prefix ;
+    [ vocabs-words ] [ current-words ] if* sort swap filter-prefix ;
diff --git a/extra/gemini/server/server.factor b/extra/gemini/server/server.factor
index 2677ee1ae1..fb7fed7bbd 100644
--- a/extra/gemini/server/server.factor
+++ b/extra/gemini/server/server.factor
@@ -58,7 +58,7 @@ TUPLE: gemini-server < threaded-server
     path [
         [ name>> "." head? ] reject
         [ { [ directory? ] [ regular-file? ] } 1|| ] filter
-        [ name>> ] sort-with
+        [ name>> ] sort-by
         [
             [ name>> ] [ directory? [ "/" append ] when ] bi
             [
diff --git a/extra/gml/core/core.factor b/extra/gml/core/core.factor
index 41c6985a80..66604e2bf3 100644
--- a/extra/gml/core/core.factor
+++ b/extra/gml/core/core.factor
@@ -74,7 +74,7 @@ GML: slice ( array n k -- slice )
 GML:: subarray ( array n k -- slice )
     k n k + array subseq ;
 GML: sort-number-permutation ( array -- permutation )
-    zip-index sort-keys reverse values ;
+    zip-index sort-keys <reversed> values ;
 
 ! Dictionaries
 ERROR: not-a-dict object ;
diff --git a/extra/gopher/server/server.factor b/extra/gopher/server/server.factor
index 5c57c6773f..8607754b82 100644
--- a/extra/gopher/server/server.factor
+++ b/extra/gopher/server/server.factor
@@ -64,7 +64,7 @@ TUPLE: gopher-server < threaded-server
     path [
         [ name>> "." head? ] reject
         [ { [ directory? ] [ regular-file? ] } 1|| ] filter
-        [ name>> ] sort-with
+        [ name>> ] sort-by
         [
             [ gopher-type ] [ name>> ] [ directory? [ "/" append ] when ] tri
             [
diff --git a/extra/gpu/render/render.factor b/extra/gpu/render/render.factor
index aba301cf0c..7ded41d31e 100644
--- a/extra/gpu/render/render.factor
+++ b/extra/gpu/render/render.factor
@@ -547,7 +547,7 @@ SYNTAX: UNIFORM-TUPLE:
     [ [ length ] [ c:int >c-array ] bi glDrawBuffers ] if ;
 
 : bind-named-output-attachments ( program-instance framebuffer attachments -- )
-    rot '[ first _ swap output-index ] sort-with values
+    rot '[ first _ swap output-index ] sort-by values
     bind-unnamed-output-attachments ;
 
 : bind-output-attachments ( program-instance framebuffer attachments -- )
diff --git a/extra/help/lint/coverage/coverage-tests.factor b/extra/help/lint/coverage/coverage-tests.factor
index 202ea456db..987d4f55ce 100644
--- a/extra/help/lint/coverage/coverage-tests.factor
+++ b/extra/help/lint/coverage/coverage-tests.factor
@@ -19,8 +19,8 @@ PRIVATE>
 { f } [ \ a-defined-word empty-examples? ] unit-test
 { f } [ \ keep empty-examples? ] unit-test
 
-{ { $description $values } } [ \ an-empty-word-with-a-unique-name missing-sections natural-sort ] unit-test
-{ { $description $values } } [ \ a-defined-word missing-sections natural-sort ] unit-test
+{ { $description $values } } [ \ an-empty-word-with-a-unique-name missing-sections sort ] unit-test
+{ { $description $values } } [ \ a-defined-word missing-sections sort ] unit-test
 { { } } [ \ keep missing-sections ] unit-test
 
 { { "a.b" "a.b.c" } } [ { "a.b" "a.b.private" "a.b.c.private" "a.b.c" } filter-private ] unit-test
diff --git a/extra/help/lint/coverage/coverage.factor b/extra/help/lint/coverage/coverage.factor
index 891a50e465..ddfbcc6b7f 100644
--- a/extra/help/lint/coverage/coverage.factor
+++ b/extra/help/lint/coverage/coverage.factor
@@ -90,7 +90,7 @@ M: word-help-coverage summary
     } case ;
 
 : sorted-loaded-child-vocabs ( prefix -- assoc )
-    loaded-child-vocab-names natural-sort ; inline
+    loaded-child-vocab-names sort ; inline
 
 : filter-private ( seq -- no-private )
     [ ".private" ?tail nip ] reject ; inline
@@ -143,7 +143,7 @@ M: string <word-help-coverage>
 
 : <vocab-help-coverage> ( vocab-spec -- coverage )
     dup loaded-vocab? [
-        [ auto-use? off vocab-words natural-sort [ <word-help-coverage> ] map ] with-scope
+        [ auto-use? off vocab-words sort [ <word-help-coverage> ] map ] with-scope
     ] [
         unloaded-vocab
     ] if ;
diff --git a/extra/ifaddrs/ifaddrs.factor b/extra/ifaddrs/ifaddrs.factor
index 3adec513f8..d96478d3c3 100644
--- a/extra/ifaddrs/ifaddrs.factor
+++ b/extra/ifaddrs/ifaddrs.factor
@@ -30,5 +30,5 @@ DESTRUCTOR: freeifaddrs
         { void* } [ getifaddrs io-error ] with-out-parameters
         &freeifaddrs ifaddrs deref
         [ ifa_next>> ] follow
-        [ ifa_name>> ] map members natural-sort
+        [ ifa_name>> ] map members sort
     ] with-destructors ;
diff --git a/extra/images/atlas/atlas.factor b/extra/images/atlas/atlas.factor
index 236fce210c..f22541d8a0 100644
--- a/extra/images/atlas/atlas.factor
+++ b/extra/images/atlas/atlas.factor
@@ -44,7 +44,7 @@ ERROR: atlas-image-formats-dont-match images ;
     stripe-height ;
 
 :: (pack-images) ( images atlas-width sort-quot -- placements )
-    images sort-quot inv-sort-with [ f image-placement boa ] map :> image-placements
+    images sort-quot inv-sort-by [ f image-placement boa ] map :> image-placements
     0 :> @y!
     [ image-placements atlas-width @y (pack-stripe) ] [ @y + @y! ] while*
     image-placements ; inline
diff --git a/extra/koszul/koszul.factor b/extra/koszul/koszul.factor
index 1c6ef39f81..de1cf4fc92 100644
--- a/extra/koszul/koszul.factor
+++ b/extra/koszul/koszul.factor
@@ -68,7 +68,7 @@ SYMBOL: terms
     ] if ;
 
 : permutation ( seq -- perm )
-    [ natural-sort ] keep [ index ] curry map ;
+    [ sort ] keep [ index ] curry map ;
 
 : (inversions) ( n seq -- n )
     [ > ] with count ;
@@ -83,7 +83,7 @@ SYMBOL: terms
         2drop 0 { }
     ] [
         dup permutation inversions -1^ rot *
-        swap natural-sort
+        swap sort
     ] if ;
 
 : wedge ( x y -- x.y )
@@ -147,11 +147,11 @@ DEFER: (d)
     ] map sift 2nip ;
 
 : basis ( generators -- seq )
-    natural-sort dup length 2^ <iota> [ nth-basis-elt ] with map ;
+    sort dup length 2^ <iota> [ nth-basis-elt ] with map ;
 
 : (tensor) ( seq1 seq2 -- seq )
     [
-        [ prepend natural-sort ] curry map
+        [ prepend sort ] curry map
     ] with map concat ;
 
 : tensor ( graded-basis1 graded-basis2 -- bigraded-basis )
diff --git a/extra/lint/vocabs/vocabs.factor b/extra/lint/vocabs/vocabs.factor
index a5b319b5c1..962ced0010 100644
--- a/extra/lint/vocabs/vocabs.factor
+++ b/extra/lint/vocabs/vocabs.factor
@@ -232,7 +232,7 @@ PRIVATE>
 
 : find-unused-in-string ( string -- seq )
     strip-code [ get-imported-words ] [ find-used-words ] bi
-        reject-unused-vocabs natural-sort ;
+        reject-unused-vocabs sort ;
 
 : find-unused-in-file ( path -- seq )
     utf8 file-contents find-unused-in-string ;
@@ -243,4 +243,4 @@ PRIVATE>
 : find-unused. ( name -- )
     dup find-unused dup empty?
         [ print-no-unused-vocabs ]
-           [ print-unused-vocabs ] if ;
\ No newline at end of file
+           [ print-unused-vocabs ] if ;
diff --git a/extra/lru-cache/lru-cache-tests.factor b/extra/lru-cache/lru-cache-tests.factor
index 3516446b74..bb4ee9b00a 100644
--- a/extra/lru-cache/lru-cache-tests.factor
+++ b/extra/lru-cache/lru-cache-tests.factor
@@ -9,7 +9,7 @@ USING: assocs kernel lru-cache sorting tools.test ;
     3 3 pick set-at
     4 4 pick set-at
     5 5 pick set-at
-    >alist natural-sort
+    >alist sort
 ] unit-test
 
 {
@@ -22,7 +22,7 @@ USING: assocs kernel lru-cache sorting tools.test ;
     1 over at drop
     4 4 pick set-at
     5 5 pick set-at
-    >alist natural-sort
+    >alist sort
 ] unit-test
 
 {
@@ -37,7 +37,7 @@ USING: assocs kernel lru-cache sorting tools.test ;
     2 over at drop
     4 4 pick set-at
     5 5 pick set-at
-    >alist natural-sort
+    >alist sort
 ] unit-test
 
 {
@@ -49,7 +49,7 @@ USING: assocs kernel lru-cache sorting tools.test ;
     3 3 pick set-at
     4 4 pick set-at
     5 5 pick set-at
-    >alist natural-sort
+    >alist sort
 ] unit-test
 
 {
@@ -62,7 +62,7 @@ USING: assocs kernel lru-cache sorting tools.test ;
     1 1 pick set-at
     4 4 pick set-at
     5 5 pick set-at
-    >alist natural-sort
+    >alist sort
 ] unit-test
 
 {
@@ -74,7 +74,7 @@ USING: assocs kernel lru-cache sorting tools.test ;
     3 3 pick set-at
     4 4 pick set-at
     5 5 pick set-at
-    >alist natural-sort
+    >alist sort
 ] unit-test
 
 {
@@ -87,5 +87,5 @@ USING: assocs kernel lru-cache sorting tools.test ;
     1 over delete-at
     4 4 pick set-at
     5 5 pick set-at
-    >alist natural-sort
+    >alist sort
 ] unit-test
diff --git a/extra/machine-learning/decision-trees/decision-trees.factor b/extra/machine-learning/decision-trees/decision-trees.factor
index 5693907daa..8bff74af8d 100644
--- a/extra/machine-learning/decision-trees/decision-trees.factor
+++ b/extra/machine-learning/decision-trees/decision-trees.factor
@@ -10,7 +10,7 @@ IN: machine-learning.decision-trees
     normalized-histogram values entropy 2 log / ;
 
 : group-by-sorted ( seq quot: ( elt -- key ) -- groups )
-    [ sort-with ] keep group-by ; inline
+    [ sort-by ] keep group-by ; inline
 
 : subsets-weighted-entropy ( data-target idx -- seq )
     ! Group the data according to the given index.
diff --git a/extra/machine-learning/label-binarizer/label-binarizer.factor b/extra/machine-learning/label-binarizer/label-binarizer.factor
index be016f86d5..a118ade1f1 100644
--- a/extra/machine-learning/label-binarizer/label-binarizer.factor
+++ b/extra/machine-learning/label-binarizer/label-binarizer.factor
@@ -10,7 +10,7 @@ TUPLE: label-binarizer classes_ ;
     label-binarizer new ; inline
 
 M: label-binarizer fit-y
-    [ members natural-sort ] dip classes_<< ;
+    [ members sort ] dip classes_<< ;
 
 M: label-binarizer transform-y
     classes_>> dup length '[
diff --git a/extra/machine-learning/label-encoder/label-encoder.factor b/extra/machine-learning/label-encoder/label-encoder.factor
index dd0c485557..1da7d0b7a3 100644
--- a/extra/machine-learning/label-encoder/label-encoder.factor
+++ b/extra/machine-learning/label-encoder/label-encoder.factor
@@ -9,7 +9,7 @@ TUPLE: label-encoder classes_ ;
 : <label-encoder> ( -- le ) label-encoder new ; inline
 
 M: label-encoder fit-y ( y transformer -- )
-    [ members natural-sort ] dip classes_<< ;
+    [ members sort ] dip classes_<< ;
 
 M: label-encoder transform-y ( y transformer -- y' )
     classes_>> '[ _ bisect-left ] map ;
diff --git a/extra/managed-server/chat/chat.factor b/extra/managed-server/chat/chat.factor
index 40a74d8f0d..fba2bb0d7c 100644
--- a/extra/managed-server/chat/chat.factor
+++ b/extra/managed-server/chat/chat.factor
@@ -29,7 +29,7 @@ CONSTANT: line-beginning "-!- "
 : handle-help ( string -- )
     [
         "Commands: "
-        commands get keys natural-sort ", " join append send-line
+        commands get keys sort ", " join append send-line
     ] [
         chat-docs get ?at
         [ send-line ]
diff --git a/extra/mason/test/test.factor b/extra/mason/test/test.factor
index 6720392645..0416ae5b6f 100644
--- a/extra/mason/test/test.factor
+++ b/extra/mason/test/test.factor
@@ -47,7 +47,7 @@ IN: mason.test
 :: do-step ( errors summary-file details-file -- )
     errors
     [ error-type +linkage-error+ eq? ] reject
-    [ path>> ] map members natural-sort summary-file to-file
+    [ path>> ] map members sort summary-file to-file
     errors details-file utf8 [ errors. ] with-file-writer ;
 
 : do-tests ( -- )
diff --git a/extra/math/extras/extras.factor b/extra/math/extras/extras.factor
index e3ac7af7da..50de007595 100644
--- a/extra/math/extras/extras.factor
+++ b/extra/math/extras/extras.factor
@@ -170,7 +170,7 @@ PRIVATE>
 <PRIVATE
 
 :: (gini) ( seq -- x )
-    seq natural-sort :> sorted
+    seq sort :> sorted
     seq length :> len
     sorted 0 [ + ] cum-reduce :> ( a b )
     b len a * / :> c
diff --git a/extra/math/transforms/bwt/bwt.factor b/extra/math/transforms/bwt/bwt.factor
index a698a5c150..bbe083fed9 100644
--- a/extra/math/transforms/bwt/bwt.factor
+++ b/extra/math/transforms/bwt/bwt.factor
@@ -7,7 +7,7 @@ IN: math.transforms.bwt
 ! Semi-efficient versions of Burrows-Wheeler Transform
 
 :: bwt ( seq -- i newseq )
-    seq all-rotations natural-sort
+    seq all-rotations sort
     [ [ n>> 0 = ] find drop ] keep
     [ last ] seq map-as ;
 
diff --git a/extra/memcached/memcached-tests.factor b/extra/memcached/memcached-tests.factor
index 248929194e..0fb6ad14e1 100644
--- a/extra/memcached/memcached-tests.factor
+++ b/extra/memcached/memcached-tests.factor
@@ -101,5 +101,5 @@ PRIVATE>
 [ "5" x m/set ] with-memcached
 [ "valuex" y m/set ] with-memcached
 { { "5" "valuex" } } [
-    [ x y z 3array m/getseq values natural-sort ] with-memcached
+    [ x y z 3array m/getseq values sort ] with-memcached
 ] unit-test
diff --git a/extra/multi-methods/multi-methods.factor b/extra/multi-methods/multi-methods.factor
index dfd3bbf459..83324d456f 100644
--- a/extra/multi-methods/multi-methods.factor
+++ b/extra/multi-methods/multi-methods.factor
@@ -52,7 +52,7 @@ SYMBOL: total
 
         [ [ canonicalize-specializer-1 ] dip ] assoc-map
 
-        hooks [ natural-sort ] change
+        hooks [ sort ] change
 
         [ [ canonicalize-specializer-2 ] dip ] assoc-map
 
diff --git a/extra/pair-methods/pair-methods.factor b/extra/pair-methods/pair-methods.factor
index 01c94d4aad..d39249340e 100644
--- a/extra/pair-methods/pair-methods.factor
+++ b/extra/pair-methods/pair-methods.factor
@@ -22,7 +22,7 @@ ERROR: no-pair-method a b generic ;
 
 : sorted-pair-methods ( word -- alist )
     "pair-generic-methods" word-prop >alist
-    [ first method-sort-key ] inv-sort-with ;
+    [ first method-sort-key ] inv-sort-by ;
 
 : pair-generic-definition ( word -- def )
     [ sorted-pair-methods [ first2 pair-method-cond ] map ]
diff --git a/extra/papier/render/render.factor b/extra/papier/render/render.factor
index ce325b8562..746c162d22 100644
--- a/extra/papier/render/render.factor
+++ b/extra/papier/render/render.factor
@@ -53,7 +53,7 @@ TYPED:: <papier-renderer> ( -- renderer: papier-renderer )
 
 : order-slabs ( slabs eye -- slabs' )
     ! NO
-    ! '[ center>> _ v- norm-sq ] inv-sort-with ; inline
+    ! '[ center>> _ v- norm-sq ] inv-sort-by ; inline
     drop ;
 
 : render-slabs ( slabs -- vertices indexes )
diff --git a/extra/path-finding/path-finding-tests.factor b/extra/path-finding/path-finding-tests.factor
index e672edb959..c0e57c0d13 100644
--- a/extra/path-finding/path-finding-tests.factor
+++ b/extra/path-finding/path-finding-tests.factor
@@ -106,7 +106,7 @@ MEMO: routes ( -- hash ) $[ { "ABD" "BC" "C" "DCE" "ECF" } [ unclip swap 2array
     "" 2sequence H{ { "AB" 1 } { "AD" 2 } { "BC" 5 } { "DC" 2 } { "DE" 1 } { "EC" 2 } { "EF" 1 } } at ;
 
 : test2 ( fromto -- path considered )
-    first2 [ n ] [ c ] [ 2drop 0 ] <astar> [ find-path ] [ considered natural-sort >string ] bi ;
+    first2 [ n ] [ c ] [ 2drop 0 ] <astar> [ find-path ] [ considered sort >string ] bi ;
 >>
 
 ! Check path from A to C -- all nodes but F must have been examined
@@ -129,7 +129,7 @@ MEMO: costs ( -- costs )
     routes keys [ dup dup n [ dup [ c ] dip swap 2array ] with { } map-as >hashtable 2array ] map >hashtable ;
 
 : test3 ( fromto -- path considered )
-    first2 costs <dijkstra> [ find-path ] [ considered natural-sort >string ] bi ;
+    first2 costs <dijkstra> [ find-path ] [ considered sort >string ] bi ;
 
 >>
 
diff --git a/extra/project-euler/004/004.factor b/extra/project-euler/004/004.factor
index b2334cc432..5cc7a4d309 100644
--- a/extra/project-euler/004/004.factor
+++ b/extra/project-euler/004/004.factor
@@ -24,7 +24,7 @@ IN: project-euler.004
     100 999 [a..b] [ 10 divisor? ] reject ;
 
 : max-palindrome ( seq -- palindrome )
-    natural-sort [ palindrome? ] find-last nip ;
+    sort [ palindrome? ] find-last nip ;
 
 PRIVATE>
 
diff --git a/extra/project-euler/009/009.factor b/extra/project-euler/009/009.factor
index ac44102b19..93213ae0df 100644
--- a/extra/project-euler/009/009.factor
+++ b/extra/project-euler/009/009.factor
@@ -34,7 +34,7 @@ IN: project-euler.009
         [ sq ] bi@
         [ - 2 / , ]      ! b = (p² - q²) / 2
         [ + 2 / , ] 2bi  ! c = (p² + q²) / 2
-    ] { } make natural-sort ;
+    ] { } make sort ;
 
 : (ptriplet) ( target p q triplet -- target p q )
     sum pickd = [ next-pq 2dup abc (ptriplet) ] unless ;
diff --git a/extra/project-euler/022/022.factor b/extra/project-euler/022/022.factor
index 1b2d058697..ff27a5a9ff 100644
--- a/extra/project-euler/022/022.factor
+++ b/extra/project-euler/022/022.factor
@@ -37,7 +37,7 @@ IN: project-euler.022
 PRIVATE>
 
 : euler022 ( -- answer )
-    source-022 natural-sort name-scores sum ;
+    source-022 sort name-scores sum ;
 
 ! [ euler022 ] 100 ave-time
 ! 74 ms ave run time - 5.13 SD (100 trials)
diff --git a/extra/project-euler/043/043.factor b/extra/project-euler/043/043.factor
index d0b0ab66c0..d8dc345fc3 100644
--- a/extra/project-euler/043/043.factor
+++ b/extra/project-euler/043/043.factor
@@ -82,7 +82,7 @@ PRIVATE>
     [ unclip 1 head prefix concat ] map [ all-unique? ] filter ;
 
 : add-missing-digit ( seq -- seq )
-    dup natural-sort 10 <iota> swap diff prepend ;
+    dup sort 10 <iota> swap diff prepend ;
 
 : interesting-pandigitals ( -- seq )
     17 candidates { 13 11 7 5 3 2 } [
diff --git a/extra/project-euler/052/052.factor b/extra/project-euler/052/052.factor
index b947e3cb5e..c5d73ec3af 100644
--- a/extra/project-euler/052/052.factor
+++ b/extra/project-euler/052/052.factor
@@ -27,7 +27,7 @@ IN: project-euler.052
     <iota> [ 1 + * ] with map ; inline
 
 : all-same-digits? ( seq -- ? )
-    [ number>digits natural-sort ] map all-equal? ;
+    [ number>digits sort ] map all-equal? ;
 
 : candidate? ( n -- ? )
     { [ odd? ] [ 3 divisor? ] } 1&& ;
diff --git a/extra/project-euler/062/062.factor b/extra/project-euler/062/062.factor
index 675b551a74..41ac21903d 100644
--- a/extra/project-euler/062/062.factor
+++ b/extra/project-euler/062/062.factor
@@ -24,7 +24,7 @@ IN: project-euler.062
 <PRIVATE
 
 : cube ( n -- n^3 ) 3 ^ ; inline
-: >key ( n -- k ) cube number>digits natural-sort ; inline
+: >key ( n -- k ) cube number>digits sort ; inline
 : has-entry? ( n assoc -- ? ) [ >key ] dip key? ; inline
 
 : (euler062) ( n assoc -- n )
diff --git a/extra/project-euler/112/112.factor b/extra/project-euler/112/112.factor
index 5181015976..f02077c7d1 100644
--- a/extra/project-euler/112/112.factor
+++ b/extra/project-euler/112/112.factor
@@ -34,7 +34,7 @@ IN: project-euler.112
 <PRIVATE
 
 : bouncy? ( n -- ? )
-    number>digits dup natural-sort
+    number>digits dup sort
     [ = not ] [ reverse = not ] 2bi and ;
 
 PRIVATE>
diff --git a/extra/project-euler/common/common.factor b/extra/project-euler/common/common.factor
index 43eabaefb1..f796e78956 100644
--- a/extra/project-euler/common/common.factor
+++ b/extra/project-euler/common/common.factor
@@ -85,7 +85,7 @@ PRIVATE>
     number>string dup reverse = ;
 
 : pandigital? ( n -- ? )
-    number>string natural-sort >string "123456789" = ;
+    number>string sort >string "123456789" = ;
 
 : pentagonal? ( n -- ? )
     dup 0 > [ 24 * 1 + sqrt 1 + 6 / 1 mod zero? ] [ drop f ] if ; inline
diff --git a/extra/punycode/punycode.factor b/extra/punycode/punycode.factor
index 82104a5485..ba02eb6951 100644
--- a/extra/punycode/punycode.factor
+++ b/extra/punycode/punycode.factor
@@ -32,7 +32,7 @@ CONSTANT: DIGITS $[ "abcdefghijklmnopqrstuvwxyz0123456789" >byte-array ]
     ] while BASE delta * delta SKEW + /i + ;
 
 : segregate ( str -- base extended )
-    [ N < ] partition members natural-sort ;
+    [ N < ] partition members sort ;
 
 :: find-pos ( str ch i pos -- i' pos' )
     i pos 1 + str [
diff --git a/extra/quadtrees/quadtrees-tests.factor b/extra/quadtrees/quadtrees-tests.factor
index f3186ac841..7c4fa546d6 100644
--- a/extra/quadtrees/quadtrees-tests.factor
+++ b/extra/quadtrees/quadtrees-tests.factor
@@ -81,7 +81,7 @@ IN: quadtrees.tests
         "c" { -0.5  -0.75 } value>>key
         "d" {  0.75  0.25 } value>>key
 
-    { -0.6 -0.8 } { 0.8 1.0 } <rect> swap in-rect natural-sort
+    { -0.6 -0.8 } { 0.8 1.0 } <rect> swap in-rect sort
 ] unit-test
 
 { T{ quadtree f T{ rect f { -1.0 -1.0 } { 2.0 2.0 } } f f
@@ -197,7 +197,7 @@ IN: quadtrees.tests
         "g" {  0.25  0.25 } value>>key
         "h" {  0.75  0.75 } value>>key
 
-        >alist natural-sort
+        >alist sort
 ] unit-test
 
 TUPLE: pointy-thing center ;
diff --git a/extra/redis/redis-tests.factor b/extra/redis/redis-tests.factor
index 6670e97b00..e9156e418d 100644
--- a/extra/redis/redis-tests.factor
+++ b/extra/redis/redis-tests.factor
@@ -30,7 +30,7 @@ IN: redis.tests
 { { "aa" "ab" "ac" } } [
     [
         { "aa" "ab" "ac" "bd" } [ "hello" swap redis-set ] each
-        "a*" redis-keys natural-sort
+        "a*" redis-keys sort
     ] with-redis-test
 ] unit-test
 
diff --git a/extra/reports/noise/noise.factor b/extra/reports/noise/noise.factor
index 1719d09225..9dccb37a3e 100644
--- a/extra/reports/noise/noise.factor
+++ b/extra/reports/noise/noise.factor
@@ -120,7 +120,7 @@ M: lambda-word word-noise-factor
 : noisy-words ( -- alist )
     all-words flatten-generics
     [ word-noise-factor ] zip-with
-    sort-values reverse ;
+    inv-sort-values ;
 
 : noise. ( alist -- )
     standard-table-style [
@@ -140,7 +140,7 @@ M: lambda-word word-noise-factor
 
 : noisy-vocabs ( -- alist )
     loaded-vocab-names [ vocab-noise-factor ] zip-with
-    sort-values reverse ;
+    inv-sort-values ;
 
 : noise-report ( -- )
     "NOISY WORDS:" print
diff --git a/extra/rosetta-code/anagrams-deranged/anagrams-deranged.factor b/extra/rosetta-code/anagrams-deranged/anagrams-deranged.factor
index b9d5788d10..ea35eb08a9 100644
--- a/extra/rosetta-code/anagrams-deranged/anagrams-deranged.factor
+++ b/extra/rosetta-code/anagrams-deranged/anagrams-deranged.factor
@@ -27,7 +27,7 @@ IN: rosettacode.anagrams-deranged
     utf8 file-lines
     H{ } clone [
         '[
-            [ natural-sort >string ] keep
+            [ sort >string ] keep
             _ [ swap suffix  ] with change-at
         ] each
     ] keep ;
@@ -39,7 +39,7 @@ IN: rosettacode.anagrams-deranged
     parse-dict-file anagrams [ derangements ] map concat ;
 
 : (longest-deranged-anagrams) ( path -- anagrams )
-    deranged-anagrams [ first length ] sort-with last ;
+    deranged-anagrams [ first length ] sort-by last ;
 
 : default-word-list ( -- path )
     URL" https://puzzlers.org/pub/wordlists/unixdict.txt"
diff --git a/extra/rosetta-code/count-the-coins/count-the-coins.factor b/extra/rosetta-code/count-the-coins/count-the-coins.factor
index 922c028650..8370626971 100644
--- a/extra/rosetta-code/count-the-coins/count-the-coins.factor
+++ b/extra/rosetta-code/count-the-coins/count-the-coins.factor
@@ -42,4 +42,4 @@ PRIVATE>
 ! How many ways can we make the given amount of cents
 ! with the given set of coins?
 : make-change ( cents coins -- ways )
-    members [ ] inv-sort-with (make-change) ;
+    members inv-sort (make-change) ;
diff --git a/extra/rosetta-code/knapsack/knapsack.factor b/extra/rosetta-code/knapsack/knapsack.factor
index 84a048ac42..377c57e601 100644
--- a/extra/rosetta-code/knapsack/knapsack.factor
+++ b/extra/rosetta-code/knapsack/knapsack.factor
@@ -97,7 +97,7 @@ CONSTANT: limit 400
     solve-knapsack
     "Total value: " write number>string print
     "Items packed: " print
-    natural-sort
+    sort
     [ "   " write print ] each ;
 
 MAIN: knapsack-main
diff --git a/extra/rosetta-code/top-rank/top-rank.factor b/extra/rosetta-code/top-rank/top-rank.factor
index a0d0c0dcbf..e44766b0f6 100644
--- a/extra/rosetta-code/top-rank/top-rank.factor
+++ b/extra/rosetta-code/top-rank/top-rank.factor
@@ -48,7 +48,7 @@ CONSTANT: employees {
 
 : prepare-departments ( seq -- departments )
     [ department>> ] collect-by
-    [ [ salary>> ] inv-sort-with ] assoc-map ;
+    [ [ salary>> ] inv-sort-by ] assoc-map ;
 
 : first-n-each ( seq n quot -- )
     [ index-or-length head-slice ] dip each ; inline
diff --git a/extra/s3/s3.factor b/extra/s3/s3.factor
index f2f6496181..4fdfd3a774 100644
--- a/extra/s3/s3.factor
+++ b/extra/s3/s3.factor
@@ -3,7 +3,7 @@
 USING: accessors assocs base64 calendar calendar.format
 calendar.parser checksums.hmac checksums.sha combinators http
 http.client kernel make math.order namespaces sequences
-sorting sorting.slots strings xml xml.traversal ;
+sorting strings xml xml.traversal ;
 IN: s3
 
 SYMBOL: key-id
@@ -16,7 +16,7 @@ TUPLE: s3-request path mime-type date method headers bucket data ;
 : hashtable>headers ( hashtable -- seq )
     [
         [ swap % ":" % % "\n" % ] "" make
-    ] { } assoc>map [ <=> ] sort ;
+    ] { } assoc>map sort ;
 
 : signature ( s3-request -- string )
     [
@@ -84,7 +84,7 @@ PRIVATE>
     f "/" H{ } clone s3-get nip >string string>xml (buckets) ;
 
 : sorted-buckets ( -- seq )
-    buckets { { date>> rfc3339>timestamp <=> } } sort-by ;
+    buckets [ date>> rfc3339>timestamp ] sort-by ;
 
 <PRIVATE
 : bucket-url ( bucket -- string )
diff --git a/extra/semver/semver-tests.factor b/extra/semver/semver-tests.factor
index 10fc73d656..d93152e001 100644
--- a/extra/semver/semver-tests.factor
+++ b/extra/semver/semver-tests.factor
@@ -218,5 +218,5 @@ CONSTANT: semver-gt-comparisons {
         "2.0.0"
         "2.1.0"
         "2.1.1"
-    } dup clone randomize [ semver<=> ] sort =
+    } dup clone randomize [ semver<=> ] sort-with =
 ] unit-test
diff --git a/extra/snake-game/game/game.factor b/extra/snake-game/game/game.factor
index 1ce9c04b40..9490168140 100644
--- a/extra/snake-game/game/game.factor
+++ b/extra/snake-game/game/game.factor
@@ -81,7 +81,7 @@ C: <snake-part> snake-part
     [ dir>> move-loc ] accumulate nip ;
 
 : snake-occupied-indices ( snake head-loc -- points )
-    snake-occupied-locs [ game-loc>index ] map natural-sort ;
+    snake-occupied-locs [ game-loc>index ] map sort ;
 
 : snake-unoccupied-indices ( snake head-loc -- points )
     [ all-indices ] 2dip snake-occupied-indices without ;
diff --git a/extra/sorting/bubble/bubble-tests.factor b/extra/sorting/bubble/bubble-tests.factor
index 0dbe1263e5..d14521ccd4 100644
--- a/extra/sorting/bubble/bubble-tests.factor
+++ b/extra/sorting/bubble/bubble-tests.factor
@@ -1,5 +1,5 @@
 USING: kernel sorting.bubble tools.test ;
 
-{ { } } [ { } dup natural-bubble-sort! ] unit-test
-{ { 1 } } [ { 1 } dup natural-bubble-sort! ] unit-test
-{ { 1 2 3 4 5 } } [ { 1 4 2 5 3 } dup natural-bubble-sort! ] unit-test
+{ { } } [ { } dup bubble-sort! ] unit-test
+{ { 1 } } [ { 1 } dup bubble-sort! ] unit-test
+{ { 1 2 3 4 5 } } [ { 1 4 2 5 3 } dup bubble-sort! ] unit-test
diff --git a/extra/sorting/bubble/bubble.factor b/extra/sorting/bubble/bubble.factor
index 74115774c8..adb5c0a164 100644
--- a/extra/sorting/bubble/bubble.factor
+++ b/extra/sorting/bubble/bubble.factor
@@ -8,7 +8,7 @@ IN: sorting.bubble
 
 <PRIVATE
 
-:: (bubble-sort!) ( seq quot: ( obj1 obj2 -- <=> ) -- )
+:: (bubble-sort-with!) ( seq quot: ( obj1 obj2 -- <=> ) -- )
     seq length 1 - [
         f over [0..b) [| i |
             i i 1 + [ seq nth-unsafe ] bi@ 2dup quot call +gt+ =
@@ -19,8 +19,7 @@ IN: sorting.bubble
 
 PRIVATE>
 
-: bubble-sort! ( seq quot: ( obj1 obj2 -- <=> ) -- )
-    over length 2 < [ 2drop ] [ (bubble-sort!) ] if ; inline
+: bubble-sort-with! ( seq quot: ( obj1 obj2 -- <=> ) -- )
+    over length 2 < [ 2drop ] [ (bubble-sort-with!) ] if ; inline
 
-: natural-bubble-sort! ( seq -- )
-    [ <=> ] bubble-sort! ;
+: bubble-sort! ( seq -- ) [ <=> ] bubble-sort-with! ;
diff --git a/extra/sorting/extras/extras.factor b/extra/sorting/extras/extras.factor
index ae90b05109..7adb719171 100644
--- a/extra/sorting/extras/extras.factor
+++ b/extra/sorting/extras/extras.factor
@@ -5,11 +5,11 @@ IN: sorting.extras
 : argsort ( seq quot: ( obj1 obj2 -- <=> ) -- sortedseq )
     [ zip-index ] dip
     [ [ first-unsafe ] bi@ ] prepose
-    sort [ second-unsafe ] map! ; inline
+    sort-with [ second-unsafe ] map! ; inline
 
 : map-sort ( ... seq quot: ( ... elt -- ... key ) -- ... sortedseq )
     [ keep ] curry { } map>assoc
-    [ { array } declare first-unsafe ] sort-with
+    [ { array } declare first-unsafe ] sort-by
     [ { array } declare second-unsafe ] map ; inline
 
 :: bisect-left ( obj seq -- i )
diff --git a/extra/sorting/quick/quick-tests.factor b/extra/sorting/quick/quick-tests.factor
index ddaefbee31..f2319eed33 100644
--- a/extra/sorting/quick/quick-tests.factor
+++ b/extra/sorting/quick/quick-tests.factor
@@ -1,12 +1,12 @@
 USING: kernel sequences sorting.quick tools.test ;
 
-{ { } } [ { } dup natural-sort! ] unit-test
-{ { 1 } } [ { 1 } dup natural-sort! ] unit-test
-{ { 1 2 3 4 5 } } [ { 1 4 2 5 3 } dup natural-sort! ] unit-test
+{ { } } [ { } dup sort! ] unit-test
+{ { 1 } } [ { 1 } dup sort! ] unit-test
+{ { 1 2 3 4 5 } } [ { 1 4 2 5 3 } dup sort! ] unit-test
 
 {
     { "dino" "fred" "wilma" "betty" "barney" "pebbles" "bamm-bamm" }
 } [
     { "fred" "wilma" "pebbles" "dino" "barney" "betty" "bamm-bamm" }
-    dup [ length ] sort-with!
+    dup [ length ] sort-by!
 ] unit-test
diff --git a/extra/sorting/quick/quick.factor b/extra/sorting/quick/quick.factor
index 08476e18e7..d153504aa8 100644
--- a/extra/sorting/quick/quick.factor
+++ b/extra/sorting/quick/quick.factor
@@ -39,18 +39,28 @@ IN: sorting.quick
 
 PRIVATE>
 
-: sort! ( seq quot: ( obj1 obj2 -- <=> ) -- )
+: sort-with! ( seq quot: ( obj1 obj2 -- <=> ) -- )
     [ 0 over length check-array-capacity 1 - ] dip quicksort ; inline
 
-: sort-with! ( seq quot: ( elt -- key ) -- )
-    [ compare ] curry sort! ; inline
+: inv-sort-with! ( seq quot: ( obj1 obj2 -- <=> ) -- )
+    '[ @ invert-comparison ] sort-with! ; inline
 
-: inv-sort-with! ( seq quot: ( elt -- key ) -- )
-    [ compare invert-comparison ] curry sort! ; inline
+: sort-by! ( seq quot: ( elt -- key ) -- )
+    [ compare ] curry sort-with! ; inline
 
-GENERIC: natural-sort! ( seq -- )
+: inv-sort-by! ( seq quot: ( elt -- key ) -- )
+    [ compare invert-comparison ] curry sort-with! ; inline
 
-M: object natural-sort!  [ <=> ] sort! ;
-M: array natural-sort! [ <=> ] sort! ;
-M: vector natural-sort! [ <=> ] sort! ;
-M: string natural-sort! [ <=> ] sort! ;
+GENERIC: sort! ( seq -- )
+
+M: object sort! [ <=> ] sort-with! ;
+M: array sort! [ <=> ] sort-with! ;
+M: vector sort! [ <=> ] sort-with! ;
+M: string sort! [ <=> ] sort-with! ;
+
+GENERIC: inv-sort! ( seq -- )
+
+M: object inv-sort! [ <=> ] inv-sort-with! ;
+M: array inv-sort! [ <=> ] inv-sort-with! ;
+M: vector inv-sort! [ <=> ] inv-sort-with! ;
+M: string inv-sort! [ <=> ] inv-sort-with! ;
diff --git a/extra/spelling/spelling.factor b/extra/spelling/spelling.factor
index 027f9e0584..3e9f091132 100644
--- a/extra/spelling/spelling.factor
+++ b/extra/spelling/spelling.factor
@@ -48,7 +48,7 @@ CONSTANT: ALPHABET "abcdefghijklmnopqrstuvwxyz"
     word 1array dictionary filter-known
     [ word edits1 dictionary filter-known ] when-empty
     [ word edits2 dictionary filter-known ] when-empty
-    [ dictionary at ] sort-with reverse! ;
+    [ dictionary at ] sort-by reverse! ;
 
 : words ( string -- words )
     >lower [ letter? not ] split-when harvest ;
diff --git a/extra/tools/tree/tree.factor b/extra/tools/tree/tree.factor
index 4487a9ed98..e55d4aef98 100644
--- a/extra/tools/tree/tree.factor
+++ b/extra/tools/tree/tree.factor
@@ -33,7 +33,7 @@ DEFER: write-tree
 
 :: write-tree ( path indents -- )
     path [
-        [ name>> ] sort-with [ ] [
+        [ name>> ] sort-by [ ] [
             unclip-last [
                 f indents push
                 [ indents write-entry ] each
diff --git a/extra/units/units.factor b/extra/units/units.factor
index f98483d5e5..d9bfb840fe 100644
--- a/extra/units/units.factor
+++ b/extra/units/units.factor
@@ -20,7 +20,7 @@ M: dimensions-not-equal summary drop "Dimensions do not match" ;
 
 : <dimensioned> ( n top bot -- obj )
     symbolic-reduce
-    [ natural-sort ] bi@
+    [ sort ] bi@
     dimensioned boa ;
 
 : >dimensioned< ( d -- n top bot )
diff --git a/extra/webapps/blogs/blogs.factor b/extra/webapps/blogs/blogs.factor
index 332283667b..a60dbea3ab 100644
--- a/extra/webapps/blogs/blogs.factor
+++ b/extra/webapps/blogs/blogs.factor
@@ -83,7 +83,7 @@ M: comment entity-url
     >>comments ;
 
 : reverse-chronological-order ( seq -- sorted )
-    [ date>> ] inv-sort-with ;
+    [ date>> ] inv-sort-by ;
 
 : validate-author ( -- )
     { { "author" [ v-username ] } } validate-params ;
diff --git a/extra/webapps/mason/dashboard/dashboard.factor b/extra/webapps/mason/dashboard/dashboard.factor
index 0e6c3c2b5c..b0249421e0 100644
--- a/extra/webapps/mason/dashboard/dashboard.factor
+++ b/extra/webapps/mason/dashboard/dashboard.factor
@@ -19,7 +19,7 @@ CONSTANT: BROKEN
     } cond ;
 
 : builder-list ( seq -- xml )
-    [ os/cpu ] sort-with
+    [ os/cpu ] sort-by
     [
         [ report-url ] [ os/cpu ] [ builder-status ] tri
         [XML <li><a href=<->><-></a> <-></li> XML]
diff --git a/extra/webapps/pastebin/pastebin.factor b/extra/webapps/pastebin/pastebin.factor
index 597ab89de1..5b151e3250 100644
--- a/extra/webapps/pastebin/pastebin.factor
+++ b/extra/webapps/pastebin/pastebin.factor
@@ -51,7 +51,7 @@ TUPLE: paste-state < entity annotations ;
 
 : pastes ( -- pastes )
     f <paste-state> select-tuples
-    [ date>> ] sort-with
+    [ date>> ] sort-by
     reverse ;
 
 TUPLE: annotation < entity parent ;
diff --git a/extra/webapps/planet/planet.factor b/extra/webapps/planet/planet.factor
index 9e05af3140..ebbcdba281 100644
--- a/extra/webapps/planet/planet.factor
+++ b/extra/webapps/planet/planet.factor
@@ -47,11 +47,11 @@ posting "POSTINGS"
 
 : blogroll ( -- seq )
     f <blog> select-tuples
-    [ name>> ] sort-with ;
+    [ name>> ] sort-by ;
 
 : postings ( -- seq )
     posting new select-tuples
-    [ date>> ] inv-sort-with ;
+    [ date>> ] inv-sort-by ;
 
 : <edit-blogroll-action> ( -- action )
     <page-action>
@@ -90,7 +90,7 @@ posting "POSTINGS"
     [ '[ _ <posting> ] map ] 2map concat ;
 
 : sort-entries ( entries -- entries' )
-    [ date>> ] inv-sort-with ;
+    [ date>> ] inv-sort-by ;
 
 : update-cached-postings ( -- )
     blogroll fetch-blogroll sort-entries 8 index-or-length head [
diff --git a/extra/webapps/wiki/wiki.factor b/extra/webapps/wiki/wiki.factor
index 020148c58d..404c77a817 100644
--- a/extra/webapps/wiki/wiki.factor
+++ b/extra/webapps/wiki/wiki.factor
@@ -57,7 +57,7 @@ M: revision feed-entry-date date>> ;
 M: revision feed-entry-url id>> revision-url ;
 
 : reverse-chronological-order ( seq -- sorted )
-    [ date>> ] inv-sort-with ;
+    [ date>> ] inv-sort-by ;
 
 : <revision> ( id -- revision )
     revision new swap >>id ;
@@ -300,7 +300,7 @@ M: revision feed-entry-url id>> revision-url ;
 
         [
             f <article> select-tuples
-            [ title>> ] sort-with
+            [ title>> ] sort-by
             "articles" set-value
         ] >>init
 
@@ -322,7 +322,7 @@ M: revision feed-entry-url id>> revision-url ;
 
             [ f ] [
                 f <article> select-tuples
-                [ title>> ] sort-with
+                [ title>> ] sort-by
                 [ revision>> <revision> select-tuple ] map
                 swap '[ content>> _ [ first-match ] with all? ] filter
             ] if-empty
diff --git a/extra/wordlet/wordlet.factor b/extra/wordlet/wordlet.factor
index 6875425ea5..a14a9a343d 100644
--- a/extra/wordlet/wordlet.factor
+++ b/extra/wordlet/wordlet.factor
@@ -50,7 +50,7 @@ TUPLE: wordlet-game secret-word chances guesses ;
     ] with map concat members
     [ background of ] assoc-map
     [ drop ] collect-value-by
-    [ [ color>n ] zip-with sort-values reverse first first ] assoc-map
+    [ [ color>n ] zip-with sort-values <reversed> first first ] assoc-map
     CHAR: a CHAR: z [a..b] [ 1string COLOR: white ] { } map>assoc [ or ] assoc-merge ;
 
 : print-remaining-chars ( game -- )
diff --git a/extra/wordtimer/wordtimer.factor b/extra/wordtimer/wordtimer.factor
index 60e0a5d706..2353337686 100644
--- a/extra/wordtimer/wordtimer.factor
+++ b/extra/wordtimer/wordtimer.factor
@@ -64,7 +64,7 @@ SYMBOL: *calling*
     *wordtimes* [ (correct-for-timing-overhead) ] change-global ;
 
 : print-word-timings ( -- )
-    *wordtimes* get-global [ swap suffix ] { } assoc>map natural-sort reverse pprint ;
+    *wordtimes* get-global [ swap suffix ] { } assoc>map inv-sort pprint ;
 
 : wordtimer-call ( quot -- )
     reset-word-timer
diff --git a/extra/zoneinfo/zoneinfo.factor b/extra/zoneinfo/zoneinfo.factor
index 78f5a6b31e..d75b2f27ba 100644
--- a/extra/zoneinfo/zoneinfo.factor
+++ b/extra/zoneinfo/zoneinfo.factor
@@ -148,7 +148,7 @@ MEMO: zoneinfo-assoc ( -- assoc )
 : zoneinfo-zones ( -- seq )
     raw-zone-map keys
     [ "/" subseq-of? ] partition
-    [ natural-sort ] bi@ append ;
+    [ sort ] bi@ append ;
 
 GENERIC: zone-matches? ( string rule -- ? )
 
diff --git a/misc/vim/syntax/factor/generated.vim b/misc/vim/syntax/factor/generated.vim
index ffb9929047..46e5d744fd 100644
--- a/misc/vim/syntax/factor/generated.vim
+++ b/misc/vim/syntax/factor/generated.vim
@@ -1,7 +1,7 @@
 " Vim syntax file
 " Language: Factor
 " Maintainer: Alex Chapman <chapman.alex@gmail.com>
-" Last Change: 2022 Aug 06
+" Last Change: 2023 Feb 08
 " Minimum Version: 600
 " To regenerate: USE: editors.vim.generate-syntax generate-vim-syntax
 
@@ -19,7 +19,7 @@ command -nargs=+ -bar SynKeywordFactorWord
 
 SynKeywordFactorWord factorWord_alien | syn keyword factorWord_alien contained <alien> <bad-alien> <callback> <displaced-alien> >c-ptr abi abi? alien alien-address alien-assembly alien-callback alien-indirect alien-invoke alien? binary-object byte-length c-ptr c-ptr? callee-cleanup? callsite-not-compiled callsite-not-compiled? cdecl cdecl? dll dll? element-size expired? fastcall fastcall? free-callback initialize-alien mingw mingw? pinned-alien pinned-alien? pinned-c-ptr pinned-c-ptr? stdcall stdcall? thiscall thiscall? unregister-and-free-callback with-callback
 SynKeywordFactorWord factorWord_arrays | syn keyword factorWord_arrays contained 1array 2array 3array 4array <array> >array array array? pair pair? resize-array
-SynKeywordFactorWord factorWord_assocs | syn keyword factorWord_assocs contained 2cache <enumerated> >alist ?at ?change-at ?delete-at ?of ?value-at assoc assoc-all? assoc-any? assoc-clone-like assoc-diff assoc-diff! assoc-differ assoc-each assoc-empty? assoc-filter assoc-filter! assoc-filter-as assoc-find assoc-hashcode assoc-intersect assoc-intersect-all assoc-like assoc-map assoc-map-as assoc-partition assoc-reject assoc-reject! assoc-reject-as assoc-size assoc-stack assoc-subset? assoc-union assoc-union! assoc-union-all assoc-union-as assoc= assoc>map assoc? at at* at+ cache change-at clear-assoc collect-by delete-at delete-at* enumerated enumerated? extract-keys harvest-keys harvest-values inc-at key? keys map>alist map>assoc maybe-set-at new-assoc of push-at rename-at set-at sift-keys sift-values substitute unzip value-at value-at* value? values zip zip-as zip-index zip-index-as zip-with zip-with-as
+SynKeywordFactorWord factorWord_assocs | syn keyword factorWord_assocs contained 2cache <enumerated> >alist ?at ?change-at ?delete-at ?of ?value-at assoc assoc-all? assoc-any? assoc-clone-like assoc-diff assoc-diff! assoc-differ assoc-each assoc-empty? assoc-filter assoc-filter! assoc-filter-as assoc-find assoc-hashcode assoc-intersect assoc-intersect-all assoc-like assoc-map assoc-map-as assoc-partition assoc-reject assoc-reject! assoc-reject-as assoc-size assoc-stack assoc-subset? assoc-union assoc-union! assoc-union-all assoc-union-as assoc= assoc>map assoc? at at* at+ cache change-at clear-assoc collect-by collect-by! delete-at delete-at* enumerated enumerated? extract-keys harvest-keys harvest-values inc-at key? keys map>alist map>assoc maybe-set-at new-assoc of push-at rename-at set-at sift-keys sift-values substitute unzip value-at value-at* value? values zip zip-as zip-index zip-index-as zip-with zip-with-as
 SynKeywordFactorWord factorWord_byte__arrays | syn keyword factorWord_byte__arrays contained (byte-array) 1byte-array 2byte-array 3byte-array 4byte-array <byte-array> >byte-array byte-array byte-array? byte-sequence byte-sequence? resize-byte-array
 SynKeywordFactorWord factorWord_classes | syn keyword factorWord_classes contained all-contained-classes bad-inheritance bad-inheritance? check-instance class class-members class-of class-participants class-usage class-usages class-uses class? classes classoid classoid? contained-classes create-predicate-word define-predicate defining-class defining-class? forget-class implementors instance? not-an-instance not-an-instance? predicate predicate-def predicate-word predicate? subclass-of? superclass-of superclass-of? superclasses-of
 SynKeywordFactorWord factorWord_classes_maybe | syn keyword factorWord_classes_maybe contained <maybe> maybe maybe-class-or maybe?
@@ -34,16 +34,16 @@ SynKeywordFactorWord factorWord_io_encodings | syn keyword factorWord_io_encodin
 SynKeywordFactorWord factorWord_io_encodings_binary | syn keyword factorWord_io_encodings_binary contained binary binary?
 SynKeywordFactorWord factorWord_io_encodings_utf8 | syn keyword factorWord_io_encodings_utf8 contained >utf8-index code-point-length code-point-offsets utf8 utf8-index> utf8?
 SynKeywordFactorWord factorWord_io_files | syn keyword factorWord_io_files contained (file-appender) (file-reader) (file-writer) +input+ +output+ +retry+ <file-appender> <file-reader> <file-writer> change-file-contents change-file-lines drain file-contents file-exists? file-lines file-reader file-reader? file-writer file-writer? init-resource-path refill set-file-contents set-file-lines wait-for-fd with-file-appender with-file-reader with-file-writer
-SynKeywordFactorWord factorWord_kernel | syn keyword factorWord_kernel contained (clone) -roll -rot -rotd 2bi 2bi* 2bi@ 2curry 2dip 2drop 2dup 2keep 2keepd 2nip 2nipd 2over 2tri 2tri* 2tri@ 2with 3bi 3curry 3dip 3drop 3dup 3keep 3nip 3nipd 3tri 4dip 4drop 4dup 4keep 4nip 5drop 5nip <wrapper> = >boolean ? ?if and assert assert= assert? bi bi* bi-curry bi-curry* bi-curry@ bi@ boa boolean boolean? both? build call callstack callstack>array callstack? clear clone compose composed composed? curried curried? curry die dip do drop dup dupd either? eq? equal? execute get-callstack get-datastack get-retainstack hashcode hashcode* identity-hashcode identity-tuple identity-tuple? if if* keep keepd keepdd loop most negate new nip nipd not null object or over overd pick pickd prepose reach recursive-hashcode roll rot rotd same? spin swap swapd throw tri tri* tri-curry tri-curry* tri-curry@ tri@ tuck tuple tuple? unless unless* until when when* while while* with withd wrapper wrapper? xor
+SynKeywordFactorWord factorWord_kernel | syn keyword factorWord_kernel contained (clone) -roll -rot -rotd 2bi 2bi* 2bi@ 2curry 2dip 2drop 2dup 2keep 2keepd 2nip 2nipd 2over 2tri 2tri* 2tri@ 2with 3bi 3curry 3dip 3drop 3dup 3keep 3nip 3nipd 3tri 4dip 4drop 4dup 4keep 4nip 5drop 5nip <wrapper> = >boolean ? ?if and assert assert= assert? bi bi* bi-curry bi-curry* bi-curry@ bi@ boa boolean boolean? both? build call callstack callstack>array callstack? clear clone compose composed composed? curried curried? curry die dip do drop dup dupd either? eq? equal? execute get-callstack get-datastack get-retainstack hashcode hashcode* identity-hashcode identity-tuple identity-tuple? if if* keep keepd keepdd loop most negate new nip nipd not null object or over overd pick pickd prepose reach roll rot rotd same? spin swap swapd throw tri tri* tri-curry tri-curry* tri-curry@ tri@ tuck tuple tuple? unless unless* until when when* while while* with withd wrapper wrapper? xor
 SynKeywordFactorWord factorWord_layouts | syn keyword factorWord_layouts contained (first-bignum) (fixnum-bits) (max-array-capacity) 32-bit? 64-bit? bootstrap-cell bootstrap-cell-bits bootstrap-cells bootstrap-first-bignum bootstrap-fixnum-bits bootstrap-max-array-capacity bootstrap-most-negative-fixnum bootstrap-most-positive-fixnum cell cell-bits cells data-alignment first-bignum fixnum-bits hashcode-shift header-bits immediate immediate? leaf-stack-frame-size max-array-capacity mega-cache-size most-negative-fixnum most-positive-fixnum num-types tag-bits tag-fixnum tag-header tag-mask type-number type-numbers untag-fixnum
 SynKeywordFactorWord factorWord_make | syn keyword factorWord_make contained % %% , ,+ ,, building make
-SynKeywordFactorWord factorWord_math | syn keyword factorWord_math contained * + - / /f /i /mod 2/ 2^ < <= <fp-nan> > >= >bignum >fixnum >float >fraction >integer >rect ?1+ abs align all-integers-from? all-integers? bignum bignum? bit? bitand bitnot bitor bits>double bits>float bitxor complex complex? denominator double>bits each-integer each-integer-from even? find-integer find-integer-from find-last-integer fixnum fixnum? float float>bits float? fp-bitwise= fp-infinity? fp-nan-payload fp-nan? fp-qnan? fp-sign fp-snan? fp-special? gcd if-zero imaginary-part integer integer>fixnum integer>fixnum-strict integer? log2 log2-expects-positive log2-expects-positive? mod neg neg? next-float next-power-of-2 number number= number? numerator odd? power-of-2? prev-float ratio ratio? rational rational? real real-part real? recip rect> rem sgn shift simple-gcd sq times u< u<= u> u>= unless-zero unordered? until-zero when-zero zero?
+SynKeywordFactorWord factorWord_math | syn keyword factorWord_math contained * + - / /f /i /mod 2/ 2^ < <= <fp-nan> > >= >bignum >fixnum >float >fraction >integer >rect ?1+ abs align all-integers-from? all-integers? bignum bignum? bit? bitand bitnot bitor bits>double bits>float bitxor complex complex? denominator double>bits each-integer each-integer-from even? find-integer find-integer-from find-last-integer fixnum fixnum? float float>bits float? fp-bitwise= fp-infinity? fp-nan-payload fp-nan? fp-qnan? fp-sign fp-snan? fp-special? gcd if-zero imaginary-part integer integer>fixnum integer>fixnum-strict integer? log2 log2-expects-positive log2-expects-positive? mod neg neg? next-float next-power-of-2 number number= number? numerator odd? power-of-2? prev-float ratio ratio? rational rational? real real-part real? recip rect> recursive-hashcode rem sgn shift simple-gcd sq times u< u<= u> u>= unless-zero unordered? until-zero when-zero zero?
 SynKeywordFactorWord factorWord_math_order | syn keyword factorWord_math_order contained +eq+ +gt+ +lt+ <=> >=< [-] after=? after? before=? before? between? clamp compare invert-comparison max min
 SynKeywordFactorWord factorWord_memory | syn keyword factorWord_memory contained all-instances compact-gc gc instances minor-gc save save-image save-image-and-exit saving-path size
 SynKeywordFactorWord factorWord_namespaces | syn keyword factorWord_namespaces contained +@ change change-global counter dec get get-global get-namestack global inc init-namestack initialize namespace off on set set-global set-namestack toggle with-global with-scope with-variable with-variables
-SynKeywordFactorWord factorWord_sequences | syn keyword factorWord_sequences contained 1sequence 1surround 1surround-as 2all? 2any? 2each 2each-from 2map 2map-as 2map-reduce 2reduce 2selector 2sequence 3append 3append-as 3each 3map 3map-as 3sequence 4sequence <iota> <repetition> <reversed> <slice> >slice< ?first ?last ?nth ?second ?set-nth accumulate accumulate! accumulate* accumulate*! accumulate*-as accumulate-as all? any? append append! append-as assert-sequence assert-sequence= assert-sequence? binary-reduce bounds-check bounds-check? bounds-error bounds-error? but-last but-last-slice cartesian-each cartesian-find cartesian-map cartesian-product cartesian-product-as change-nth check-slice clone-like collapse-slice collector collector-as collector-for collector-for-as concat concat-as copy count cut cut* cut-slice cut-slice* delete-all delete-slice drop-prefix each each-from each-index empty? exchange filter filter! filter-as find find-from find-index find-index-from find-last find-last-from first first2 first3 first4 flip follow fourth from-tail glue glue-as halves harvest head head* head-slice head-slice* head-to-index head? if-empty immutable immutable-sequence immutable-sequence? immutable? index index-from index-of-last index-or-length index-to-tail indices infimum infimum-by insert-nth interleave iota iota? join join-as last last-index last-index-from length lengthen like longer longer? longest map map! map-as map-find map-find-last map-index map-index-as map-integers map-integers-as map-reduce map-sum max-length member-eq? member? midpoint@ min-length mismatch move new-like new-resizable new-sequence non-negative-integer-expected non-negative-integer-expected? none? nth nths pad-head pad-tail partition pop pop* prefix prepend prepend-as produce produce-as product push push-all push-either push-if reduce reduce-index reject reject! reject-as remove remove! remove-eq remove-eq! remove-nth remove-nth! repetition repetition? replace-slice replicate replicate-as rest rest-slice reverse reverse! reversed reversed? second selector selector-as sequence sequence-hashcode sequence= sequence? set-first set-fourth set-last set-length set-nth set-second set-third shorten shorter shorter? shortest sift slice slice-error slice-error? slice? snip snip-slice subseq subseq-as subseq-index subseq-index-from subseq-of? subseq-start subseq-start-from subseq-starts-at? subseq? suffix suffix! sum sum-lengths supremum supremum-by surround surround-as tail tail* tail-slice tail-slice* tail? third trim trim-head trim-head-slice trim-slice trim-tail trim-tail-slice unclip unclip-last unclip-last-slice unclip-slice unless-empty virtual-exemplar virtual-sequence virtual-sequence? virtual@ when-empty
+SynKeywordFactorWord factorWord_sequences | syn keyword factorWord_sequences contained 1sequence 1surround 1surround-as 2all? 2any? 2each 2each-from 2map 2map-as 2map-reduce 2reduce 2selector 2sequence 3append 3append-as 3each 3map 3map-as 3sequence 4sequence <iota> <repetition> <reversed> <slice> >slice< ?first ?last ?nth ?second ?set-nth accumulate accumulate! accumulate* accumulate*! accumulate*-as accumulate-as all? any? append append! append-as assert-sequence assert-sequence= assert-sequence? binary-reduce bounds-check bounds-check? bounds-error bounds-error? but-last but-last-slice cartesian-each cartesian-find cartesian-map cartesian-product cartesian-product-as change-nth check-slice clone-like collapse-slice collector collector-as collector-for collector-for-as concat concat-as copy count cut cut* cut-slice cut-slice* delete-all delete-slice drop-prefix each each-from each-index empty? exchange filter filter! filter-as find find-from find-index find-index-from find-last find-last-from first first2 first3 first4 flip follow fourth from-tail glue glue-as halves harvest head head* head-slice head-slice* head-to-index head? if-empty immutable immutable-sequence immutable-sequence? immutable? index index-from index-of-last index-or-length index-to-tail indices infimum infimum-by insert-nth interleave iota iota? join join-as last last-index last-index-from length lengthen like longer longer? longest map map! map-as map-find map-find-last map-index map-index-as map-integers map-integers-as map-integers-from-as map-reduce map-sum max-length member-eq? member? midpoint@ min-length mismatch move new-like new-resizable new-sequence non-negative-integer-expected non-negative-integer-expected? none? nth nths pad-head pad-tail partition pop pop* prefix prepend prepend-as produce produce-as product push push-all push-either push-if reduce reduce-index reject reject! reject-as remove remove! remove-eq remove-eq! remove-nth remove-nth! repetition repetition? replace-slice replicate replicate-as rest rest-slice reverse reverse! reversed reversed? second selector selector-as sequence sequence-hashcode sequence= sequence? set-first set-fourth set-last set-length set-nth set-second set-third shorten shorter shorter? shortest sift slice slice-error slice-error? slice? snip snip-slice subseq subseq-as subseq-index subseq-index-from subseq-of? subseq-start subseq-start-from subseq-starts-at? subseq? suffix suffix! sum sum-lengths supremum supremum-by surround surround-as tail tail* tail-slice tail-slice* tail? third trim trim-head trim-head-slice trim-slice trim-tail trim-tail-slice unclip unclip-last unclip-last-slice unclip-slice unless-empty virtual-exemplar virtual-sequence virtual-sequence? virtual@ when-empty
 SynKeywordFactorWord factorWord_sets | syn keyword factorWord_sets contained ?adjoin ?delete adjoin adjoin-all adjoin-at all-unique? cardinality clear-set delete diff diff! duplicates fast-set gather in? intersect intersect! intersect-all intersects? members null? set set-like set= set? subset? union union! union-all within without
-SynKeywordFactorWord factorWord_sorting | syn keyword factorWord_sorting contained compare-with inv-sort-with natural-sort sort sort-keys sort-pair sort-values sort-with
+SynKeywordFactorWord factorWord_sorting | syn keyword factorWord_sorting contained inv-sort inv-sort-by inv-sort-keys inv-sort-values inv-sort-with sort sort-by sort-keys sort-pair sort-values sort-with
 SynKeywordFactorWord factorWord_splitting | syn keyword factorWord_splitting contained ?head ?head-slice ?snip ?snip-slice ?tail ?tail-slice join-lines join-lines-as join-words join-words-as replace split split-indices split-lines split-slice split-subseq split-when split-when-slice split-words split1 split1-last split1-last-slice split1-slice split1-when split1-when-slice string-lines subseq-range
 SynKeywordFactorWord factorWord_strings | syn keyword factorWord_strings contained 1string <string> >string resize-string string string?
 SynKeywordFactorWord factorWord_strings_parser | syn keyword factorWord_strings_parser contained bad-escape bad-escape? escape name>char-hook parse-string unescape-string