Add AsyncSeq.existsAsync, forallAsync, findAsync

Three new async-predicate combinators completing the symmetry with their
sync-predicate counterparts (exists, forall, find):

- existsAsync: async predicate variant of AsyncSeq.exists
- forallAsync: async predicate variant of AsyncSeq.forall
- findAsync:   async predicate variant of AsyncSeq.find (raises KeyNotFoundException)

8 new tests added; 256 total pass.

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

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,3 +1,9 @@
+### 4.4.0
+
+* Added `AsyncSeq.findAsync` — async-predicate variant of `AsyncSeq.find`; raises `KeyNotFoundException` if no match, mirroring `Seq.find`.
+* Added `AsyncSeq.existsAsync` — async-predicate variant of `AsyncSeq.exists`, mirroring `Seq.exists`.
+* Added `AsyncSeq.forallAsync` — async-predicate variant of `AsyncSeq.forall`, mirroring `Seq.forall`.
+
 ### 4.3.0
 
 * Added `AsyncSeq.head` — returns the first element of the sequence; raises `InvalidOperationException` if empty, mirroring `Seq.head`.

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1180,12 +1180,21 @@ module AsyncSeq =
   let find f (source : AsyncSeq<'T>) =
     source |> pick (fun v -> if f v then Some v else None)
 
+  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 exists f (source : AsyncSeq<'T>) =
     source |> tryFind f |> Async.map Option.isSome
 
+  let existsAsync f (source : AsyncSeq<'T>) =
+    source |> tryFindAsync f |> Async.map Option.isSome
+
   let forall f (source : AsyncSeq<'T>) =
     source |> exists (f >> not) |> Async.map not
 
+  let forallAsync f (source : AsyncSeq<'T>) =
+    source |> existsAsync (fun v -> async { let! b = f v in return not b }) |> Async.map not
+
   let foldAsync f (state:'State) (source : AsyncSeq<'T>) =
     match source with
     | :? AsyncSeqOp<'T> as source -> source.FoldAsync f state

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -327,12 +327,22 @@ module AsyncSeq =
     /// Raises KeyNotFoundException if no matching element is found.
     val find : predicate:('T -> bool) -> source:AsyncSeq<'T> -> Async<'T>
 
+    /// Asynchronously find the first value in a sequence for which the async predicate returns true.
+    /// Raises KeyNotFoundException if no matching element is found.
+    val findAsync : predicate:('T -> Async<bool>) -> source:AsyncSeq<'T> -> Async<'T>
+
     /// 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>
 
+    /// Asynchronously determine if there is a value in the sequence for which the async predicate returns true
+    val existsAsync : predicate:('T -> Async<bool>) -> source:AsyncSeq<'T> -> Async<bool>
+
     /// Asynchronously determine if the predicate returns true for all values in the sequence
     val forall : predicate:('T -> bool) -> source:AsyncSeq<'T> -> Async<bool>
 
+    /// Asynchronously determine if the async predicate returns true for all values in the sequence
+    val forallAsync : predicate:('T -> Async<bool>) -> source:AsyncSeq<'T> -> Async<bool>
+
     /// Return an asynchronous sequence which, when iterated, includes an integer indicating the index of each element in the sequence.
     val indexed : source:AsyncSeq<'T> -> AsyncSeq<int64 * 'T>
 

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

@@ -3141,3 +3141,71 @@ let ``AsyncSeq.tail on empty returns empty`` () =
     |> AsyncSeq.toListAsync
     |> Async.RunSynchronously
   Assert.AreEqual([], result)
+
+// ===== findAsync / existsAsync / forallAsync =====
+
+[<Test>]
+let ``AsyncSeq.findAsync returns matching element`` () =
+  for i in 0 .. 10 do
+    let ls = [ 1 .. i + 1 ]
+    let result =
+      AsyncSeq.ofSeq ls
+      |> AsyncSeq.findAsync (fun x -> async { return x = i + 1 })
+      |> Async.RunSynchronously
+    Assert.AreEqual(i + 1, result)
+
+[<Test>]
+let ``AsyncSeq.findAsync raises KeyNotFoundException when no match`` () =
+  Assert.Throws<System.Collections.Generic.KeyNotFoundException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.findAsync (fun x -> async { return x = 99 })
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+[<Test>]
+let ``AsyncSeq.existsAsync returns true when element found`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.existsAsync (fun x -> async { return x = 2 })
+    |> Async.RunSynchronously
+  Assert.IsTrue(result)
+
+[<Test>]
+let ``AsyncSeq.existsAsync returns false on empty sequence`` () =
+  let result =
+    AsyncSeq.empty<int>
+    |> AsyncSeq.existsAsync (fun _ -> async { return true })
+    |> Async.RunSynchronously
+  Assert.IsFalse(result)
+
+[<Test>]
+let ``AsyncSeq.existsAsync returns false when no match`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.existsAsync (fun x -> async { return x = 99 })
+    |> Async.RunSynchronously
+  Assert.IsFalse(result)
+
+[<Test>]
+let ``AsyncSeq.forallAsync returns true when all match`` () =
+  let result =
+    AsyncSeq.ofSeq [ 2; 4; 6 ]
+    |> AsyncSeq.forallAsync (fun x -> async { return x % 2 = 0 })
+    |> Async.RunSynchronously
+  Assert.IsTrue(result)
+
+[<Test>]
+let ``AsyncSeq.forallAsync returns false when some do not match`` () =
+  let result =
+    AsyncSeq.ofSeq [ 2; 3; 6 ]
+    |> AsyncSeq.forallAsync (fun x -> async { return x % 2 = 0 })
+    |> Async.RunSynchronously
+  Assert.IsFalse(result)
+
+[<Test>]
+let ``AsyncSeq.forallAsync returns true on empty sequence`` () =
+  let result =
+    AsyncSeq.empty<int>
+    |> AsyncSeq.forallAsync (fun _ -> async { return false })
+    |> Async.RunSynchronously
+  Assert.IsTrue(result)