[Repo Assist] Add AsyncSeq.findIndex, tryFindIndex, findIndexAsync, tryFindIndexAsync, sortWith (#261)

* Add AsyncSeq.findIndex, tryFindIndex, findIndexAsync, tryFindIndexAsync, sortWith

Five new combinators mirroring standard F# module functions:
- findIndex: returns 0-based index of first matching element; raises KeyNotFoundException if not found (mirrors Seq.findIndex)
- tryFindIndex: returns Some index for first matching element, or None (mirrors Seq.tryFindIndex)
- findIndexAsync: async-predicate variant of findIndex; raises KeyNotFoundException if not found
- tryFindIndexAsync: async-predicate variant of tryFindIndex; returns option
- sortWith: sorts sequence using custom comparison function, returning array (mirrors Seq.sortWith)

12 new tests added; 279 total pass.

Co-authored-by: Copilot <[email protected]>

* ci: trigger CI checks

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <[email protected]>

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,3 +1,11 @@
+### 4.6.0
+
+* Added `AsyncSeq.findIndex` — returns the index of the first element satisfying a predicate; raises `KeyNotFoundException` if no match, mirroring `Seq.findIndex`.
+* Added `AsyncSeq.tryFindIndex` — returns the index of the first element satisfying a predicate as `option`, or `None` if not found, mirroring `Seq.tryFindIndex`.
+* Added `AsyncSeq.findIndexAsync` — async-predicate variant of `AsyncSeq.findIndex`; raises `KeyNotFoundException` if no match.
+* Added `AsyncSeq.tryFindIndexAsync` — async-predicate variant of `AsyncSeq.tryFindIndex`; returns `option`.
+* Added `AsyncSeq.sortWith` — sorts the sequence using a custom comparison function, returning an array, mirroring `Seq.sortWith`.
+
 ### 4.5.0
 
 * Added `AsyncSeq.last` — returns the last element of the sequence; raises `InvalidOperationException` if empty, mirroring `Seq.last`.

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1209,6 +1209,46 @@ module AsyncSeq =
   let findAsync f (source : AsyncSeq<'T>) =
     source |> pickAsync (fun v -> async { let! b = f v in return if b then Some v else None })
 
+  let tryFindIndex f (source : AsyncSeq<'T>) = async {
+    use ie = source.GetEnumerator()
+    let! first = ie.MoveNext()
+    let b = ref first
+    let i = ref 0
+    while b.Value.IsSome && not (f b.Value.Value) do
+        let! next = ie.MoveNext()
+        b := next
+        i := !i + 1
+    return if b.Value.IsSome then Some !i else None }
+
+  let tryFindIndexAsync f (source : AsyncSeq<'T>) = async {
+    use ie = source.GetEnumerator()
+    let! first = ie.MoveNext()
+    let b = ref first
+    let i = ref 0
+    let mutable keepGoing = b.Value.IsSome
+    while keepGoing do
+        let! matches = f b.Value.Value
+        if matches then
+            keepGoing <- false
+        else
+            let! next = ie.MoveNext()
+            b := next
+            if b.Value.IsSome then i := !i + 1
+            else keepGoing <- false
+    return if b.Value.IsSome then Some !i else None }
+
+  let findIndex f (source : AsyncSeq<'T>) = async {
+    let! result = tryFindIndex f source
+    match result with
+    | None -> return raise (System.Collections.Generic.KeyNotFoundException("An element satisfying the predicate was not found in the collection."))
+    | Some i -> return i }
+
+  let findIndexAsync f (source : AsyncSeq<'T>) = async {
+    let! result = tryFindIndexAsync f source
+    match result with
+    | None -> return raise (System.Collections.Generic.KeyNotFoundException("An element satisfying the predicate was not found in the collection."))
+    | Some i -> return i }
+
   let exists f (source : AsyncSeq<'T>) =
     source |> tryFind f |> Async.map Option.isSome
 
@@ -1885,6 +1925,9 @@ module AsyncSeq =
 
   let sortByDescending (projection:'T -> 'Key) (source:AsyncSeq<'T>) : array<'T> when 'Key : comparison =
     toSortedSeq (Array.sortByDescending projection) source
+
+  let sortWith (comparer:'T -> 'T -> int) (source:AsyncSeq<'T>) : array<'T> =
+    toSortedSeq (Array.sortWith comparer) source
   #endif
 
   #if !FABLE_COMPILER

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -343,6 +343,22 @@ module AsyncSeq =
     /// Raises KeyNotFoundException if no matching element is found.
     val findAsync : predicate:('T -> Async<bool>) -> source:AsyncSeq<'T> -> Async<'T>
 
+    /// Asynchronously find the index of the first value in a sequence for which the predicate returns true.
+    /// Returns None if no matching element is found.
+    val tryFindIndex : predicate:('T -> bool) -> source:AsyncSeq<'T> -> Async<int option>
+
+    /// Asynchronously find the index of the first value in a sequence for which the async predicate returns true.
+    /// Returns None if no matching element is found.
+    val tryFindIndexAsync : predicate:('T -> Async<bool>) -> source:AsyncSeq<'T> -> Async<int option>
+
+    /// Asynchronously find the index of the first value in a sequence for which the predicate returns true.
+    /// Raises KeyNotFoundException if no matching element is found.
+    val findIndex : predicate:('T -> bool) -> source:AsyncSeq<'T> -> Async<int>
+
+    /// Asynchronously find the index of the first value in a sequence for which the async predicate returns true.
+    /// Raises KeyNotFoundException if no matching element is found.
+    val findIndexAsync : predicate:('T -> Async<bool>) -> source:AsyncSeq<'T> -> Async<int>
+
     /// Asynchronously determine if there is a value in the sequence for which the predicate returns true
     val exists : predicate:('T -> bool) -> source:AsyncSeq<'T> -> Async<bool>
 
@@ -602,6 +618,12 @@ module AsyncSeq =
     /// that sequence is iterated. As a result this function should not be used with
     /// large or infinite sequences.
     val sortByDescending : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> array<'T> when 'Key : comparison
+
+    /// Sorts the given async sequence using the given comparison function and returns an array.
+    /// This function returns an array that digests the whole initial sequence as soon as
+    /// that sequence is iterated. As a result this function should not be used with
+    /// large or infinite sequences.
+    val sortWith : comparer:('T -> 'T -> int) -> source:AsyncSeq<'T> -> array<'T>
     #endif
 
     /// Interleaves two async sequences of the same type into a resulting sequence. The provided

tests/FSharp.Control.AsyncSeq.Tests/AsyncSeqTests.fs

@@ -3274,3 +3274,86 @@ let ``AsyncSeq.tryItem returns None for negative index`` () =
 let ``AsyncSeq.tryItem returns None on empty sequence`` () =
   let result = AsyncSeq.tryItem 0 AsyncSeq.empty<int> |> Async.RunSynchronously
   Assert.AreEqual(None, result)
+
+// ===== findIndex / tryFindIndex / findIndexAsync / tryFindIndexAsync =====
+
+[<Test>]
+let ``AsyncSeq.findIndex returns index of first matching element`` () =
+  for i in 0 .. 9 do
+    let ls = [ 1 .. 10 ]
+    let result = AsyncSeq.ofSeq ls |> AsyncSeq.findIndex (fun x -> x = i + 1) |> Async.RunSynchronously
+    Assert.AreEqual(i, result)
+
+[<Test>]
+let ``AsyncSeq.findIndex raises KeyNotFoundException when no match`` () =
+  Assert.Throws<System.Collections.Generic.KeyNotFoundException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ] |> AsyncSeq.findIndex (fun x -> x = 99) |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+[<Test>]
+let ``AsyncSeq.tryFindIndex returns Some index when found`` () =
+  let ls = [ 10; 20; 30; 40 ]
+  let result = AsyncSeq.ofSeq ls |> AsyncSeq.tryFindIndex (fun x -> x = 30) |> Async.RunSynchronously
+  Assert.AreEqual(Some 2, result)
+
+[<Test>]
+let ``AsyncSeq.tryFindIndex returns None when not found`` () =
+  let result = AsyncSeq.ofSeq [ 1; 2; 3 ] |> AsyncSeq.tryFindIndex (fun x -> x = 99) |> Async.RunSynchronously
+  Assert.AreEqual(None, result)
+
+[<Test>]
+let ``AsyncSeq.tryFindIndex returns Some 0 for first element`` () =
+  let result = AsyncSeq.ofSeq [ 5; 6; 7 ] |> AsyncSeq.tryFindIndex (fun x -> x = 5) |> Async.RunSynchronously
+  Assert.AreEqual(Some 0, result)
+
+[<Test>]
+let ``AsyncSeq.findIndexAsync returns index of first matching element`` () =
+  let ls = [ 1; 2; 3; 4; 5 ]
+  let result =
+    AsyncSeq.ofSeq ls
+    |> AsyncSeq.findIndexAsync (fun x -> async { return x = 3 })
+    |> Async.RunSynchronously
+  Assert.AreEqual(2, result)
+
+[<Test>]
+let ``AsyncSeq.findIndexAsync raises KeyNotFoundException when no match`` () =
+  Assert.Throws<System.Collections.Generic.KeyNotFoundException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.findIndexAsync (fun x -> async { return x = 99 })
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+[<Test>]
+let ``AsyncSeq.tryFindIndexAsync returns Some index when found`` () =
+  let result =
+    AsyncSeq.ofSeq [ 10; 20; 30 ]
+    |> AsyncSeq.tryFindIndexAsync (fun x -> async { return x = 20 })
+    |> Async.RunSynchronously
+  Assert.AreEqual(Some 1, result)
+
+[<Test>]
+let ``AsyncSeq.tryFindIndexAsync returns None when not found`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.tryFindIndexAsync (fun x -> async { return x = 99 })
+    |> Async.RunSynchronously
+  Assert.AreEqual(None, result)
+
+// ===== sortWith =====
+
+[<Test>]
+let ``AsyncSeq.sortWith sorts using custom comparer`` () =
+  let source = asyncSeq { yield 3; yield 1; yield 4; yield 1; yield 5 }
+  let result = AsyncSeq.sortWith compare source
+  Assert.AreEqual([| 1; 1; 3; 4; 5 |], result)
+
+[<Test>]
+let ``AsyncSeq.sortWith sorts descending with negated comparer`` () =
+  let source = asyncSeq { yield 3; yield 1; yield 4; yield 1; yield 5 }
+  let result = AsyncSeq.sortWith (fun a b -> compare b a) source
+  Assert.AreEqual([| 5; 4; 3; 1; 1 |], result)
+
+[<Test>]
+let ``AsyncSeq.sortWith returns empty array for empty sequence`` () =
+  let result = AsyncSeq.sortWith compare AsyncSeq.empty<int>
+  Assert.AreEqual([||], result)