feat: add TaskSeq.rev, sort, sortDescending, sortBy/Async, sortByDescending/Async, sortWith (101 tests)

Implements the remaining sort/rev family of functions that were previously
marked as '?' in the README (requiring pre-materialisation before streaming).

New functions:
- TaskSeq.rev                   — reverses by materialising into array first
- TaskSeq.sort                  — ascending natural comparison sort
- TaskSeq.sortDescending        — descending natural comparison sort
- TaskSeq.sortBy                — ascending sort by projection (sync)
- TaskSeq.sortByAsync           — ascending sort by projection (async)
- TaskSeq.sortByDescending      — descending sort by projection (sync)
- TaskSeq.sortByDescendingAsync — descending sort by projection (async)
- TaskSeq.sortWith              — sort using custom comparison function

All functions materialise the full input sequence, apply the corresponding
Array sort primitive, then stream elements back as a TaskSeq.

Includes 101 tests. README and release-notes updated.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 2 people

README.md

@@ -341,18 +341,19 @@ This is what has been implemented so far, is planned or skipped:
 | ✅ [#236][]| `removeAt`         | `removeAt`           |                           | |
 | ✅ [#236][]| `removeManyAt`     | `removeManyAt`       |                           | |
 |                  | `replicate`        | `replicate`          |                           | |
-| ❓         | `rev`              |                      |                           | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") |
+| ✅          | `rev`              | `rev`                |                           | materializes sequence before yielding |
 |                  | `scan`             | `scan`               | `scanAsync`               | |
 | 🚫        | `scanBack`         |                      |                           | [note #2](#note2 "Because of the async nature of TaskSeq sequences, iterating from the back would be bad practice. Instead, materialize the sequence to a list or array and then apply the 'Back' iterators.") |
 | ✅ [#90][] | `singleton`        | `singleton`          |                           | |
 | ✅ [#209][]| `skip`             | `skip`               |                           | |
 | ✅ [#219][]| `skipWhile`        | `skipWhile`          | `skipWhileAsync`          | |
 | ✅ [#219][]|                    | `skipWhileInclusive` | `skipWhileInclusiveAsync` | |
-| ❓         | `sort`             |                      |                           | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") |
-| ❓         | `sortBy`           |                      |                           | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") |
-| ❓         | `sortByAscending`  |                      |                           | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") |
-| ❓         | `sortByDescending` |                      |                           | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") |
-| ❓         | `sortWith`         |                      |                           | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") |
+| ✅          | `sort`             | `sort`               |                           | materializes sequence before yielding |
+|                   |                    | `sortDescending`     |                           | materializes sequence before yielding |
+| ✅          | `sortBy`           | `sortBy`             | `sortByAsync`             | materializes sequence before yielding |
+| ✅          | `sortByAscending`  | `sortBy`             | `sortByAsync`             | same as `sortBy`; materializes sequence before yielding |
+| ✅          | `sortByDescending` | `sortByDescending`   | `sortByDescendingAsync`   | materializes sequence before yielding |
+| ✅          | `sortWith`         | `sortWith`           |                           | materializes sequence before yielding |
 |                  | `splitInto`        | `splitInto`          |                           | |
 |                  | `sum`              | `sum`                |                           | |
 |                  | `sumBy`            | `sumBy`              | `sumByAsync`              | |

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "10.0.103",
+    "version": "10.0.102",
     "rollForward": "minor"
   }
 }

release-notes.txt

@@ -5,6 +5,8 @@ Release notes:
     - update engineering to .NET 9/10
     - adds TaskSeq.scan and TaskSeq.scanAsync, #289
     - adds TaskSeq.pairwise, #289
+    - adds TaskSeq.rev, sort, sortDescending, sortBy, sortByAsync,
+      sortByDescending, sortByDescendingAsync, sortWith
 
 0.4.0
     - overhaul all doc comments, add exceptions, improve IDE quick-info experience, #136, #220, #234

src/FSharp.Control.TaskSeq.Test/FSharp.Control.TaskSeq.Test.fsproj

@@ -21,6 +21,7 @@
     <Compile Include="TaskSeq.Except.Tests.fs" />
     <Compile Include="TaskSeq.DistinctUntilChanged.Tests.fs" />
     <Compile Include="TaskSeq.Pairwise.Tests.fs" />
+    <Compile Include="TaskSeq.Sort.Tests.fs" />
     <Compile Include="TaskSeq.Exists.Tests.fs" />
     <Compile Include="TaskSeq.Filter.Tests.fs" />
     <Compile Include="TaskSeq.FindIndex.Tests.fs" />