Merge branch 'main' into repo-assist/improve-isempty-tryhead-except-2471744-646c6897389cdfcb

Author: dsyme

RELEASE_NOTES.md

@@ -1,8 +1,16 @@
 ### 4.6.0
 
+<<<<<<< repo-assist/improve-isempty-tryhead-except-2471744-646c6897389cdfcb
 * Added `AsyncSeq.isEmpty` — returns `true` if the sequence contains no elements; short-circuits after the first element, mirroring `Seq.isEmpty`.
 * Added `AsyncSeq.tryHead` — returns the first element as `option`, or `None` if the sequence is empty, mirroring `Seq.tryHead` (equivalent to the existing `AsyncSeq.tryFirst`).
 * Added `AsyncSeq.except` — returns a new sequence excluding all elements present in a given collection, mirroring `Seq.except`.
+=======
+* 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`.
+>>>>>>> main
 
 ### 4.5.0
 

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1216,6 +1216,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
 
@@ -1896,6 +1936,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

@@ -351,6 +351,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>
 
@@ -614,6 +630,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

@@ -3329,4 +3329,86 @@ let ``AsyncSeq.except with all excluded returns empty sequence`` () =
 [<Test>]
 let ``AsyncSeq.except on empty source returns empty`` () =
   let result = AsyncSeq.except [1; 2] AsyncSeq.empty<int> |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+
+// ===== 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)