Merge pull request #297 from fsprojects/repo-assist/findback-2026-04-03-8769885a31ab339d

[Repo Assist] Add AsyncSeq.tryFindBack, findBack, tryFindBackAsync, findBackAsync

Author: dsyme

RELEASE_NOTES.md

@@ -1,5 +1,9 @@
 ### 4.12.0
 
+* Added `AsyncSeq.tryFindBack` — returns the last element for which the predicate returns true, or `None` if no match. Mirrors `Array.tryFindBack` / `List.tryFindBack`.
+* Added `AsyncSeq.tryFindBackAsync` — async-predicate variant of `tryFindBack`.
+* Added `AsyncSeq.findBack` — returns the last element for which the predicate returns true; raises `KeyNotFoundException` if no match. Mirrors `Array.findBack` / `List.findBack`.
+* Added `AsyncSeq.findBackAsync` — async-predicate variant of `findBack`.
 * Added `AsyncSeq.sortAsync` — asynchronous variant of `sort` returning `Async<'T[]>`, avoiding `Async.RunSynchronously` in async workflows.
 * Added `AsyncSeq.sortByAsync` — asynchronous variant of `sortBy` returning `Async<'T[]>`.
 * Added `AsyncSeq.sortDescendingAsync` — asynchronous variant of `sortDescending` returning `Async<'T[]>`.

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -1333,6 +1333,41 @@ 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 tryFindBack f (source : AsyncSeq<'T>) = async {
+      use ie = source.GetEnumerator()
+      let! v = ie.MoveNext()
+      let mutable b = v
+      let mutable res = None
+      while b.IsSome do
+          if f b.Value then res <- b
+          let! next = ie.MoveNext()
+          b <- next
+      return res }
+
+  let tryFindBackAsync f (source : AsyncSeq<'T>) = async {
+      use ie = source.GetEnumerator()
+      let! v = ie.MoveNext()
+      let mutable b = v
+      let mutable res = None
+      while b.IsSome do
+          let! matches = f b.Value
+          if matches then res <- b
+          let! next = ie.MoveNext()
+          b <- next
+      return res }
+
+  let findBack f (source : AsyncSeq<'T>) = async {
+      let! result = tryFindBack f source
+      match result with
+      | None -> return raise (System.Collections.Generic.KeyNotFoundException("An element satisfying the predicate was not found in the collection."))
+      | Some v -> return v }
+
+  let findBackAsync f (source : AsyncSeq<'T>) = async {
+      let! result = tryFindBackAsync f source
+      match result with
+      | None -> return raise (System.Collections.Generic.KeyNotFoundException("An element satisfying the predicate was not found in the collection."))
+      | Some v -> return v }
+
   let tryFindIndex f (source : AsyncSeq<'T>) = async {
     use ie = source.GetEnumerator()
     let! first = ie.MoveNext()

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -377,6 +377,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 last value in a sequence for which the predicate returns true.
+    /// Returns None if no matching element is found.
+    val tryFindBack : predicate:('T -> bool) -> source:AsyncSeq<'T> -> Async<'T option>
+
+    /// Asynchronously find the last value in a sequence for which the async predicate returns true.
+    /// Returns None if no matching element is found.
+    val tryFindBackAsync : predicate:('T -> Async<bool>) -> source:AsyncSeq<'T> -> Async<'T option>
+
+    /// Asynchronously find the last value in a sequence for which the predicate returns true.
+    /// Raises KeyNotFoundException if no matching element is found.
+    val findBack : predicate:('T -> bool) -> source:AsyncSeq<'T> -> Async<'T>
+
+    /// Asynchronously find the last value in a sequence for which the async predicate returns true.
+    /// Raises KeyNotFoundException if no matching element is found.
+    val findBackAsync : 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>

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

@@ -3437,6 +3437,86 @@ let ``AsyncSeq.tryFindIndexAsync returns None when not found`` () =
     |> Async.RunSynchronously
   Assert.AreEqual(None, result)
 
+// ===== tryFindBack / findBack / tryFindBackAsync / findBackAsync =====
+
+[<Test>]
+let ``AsyncSeq.tryFindBack returns last matching element`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3; 4; 5 ]
+    |> AsyncSeq.tryFindBack (fun x -> x % 2 = 0)
+    |> Async.RunSynchronously
+  Assert.AreEqual(Some 4, result)
+
+[<Test>]
+let ``AsyncSeq.tryFindBack returns None when no match`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 3; 5 ]
+    |> AsyncSeq.tryFindBack (fun x -> x % 2 = 0)
+    |> Async.RunSynchronously
+  Assert.AreEqual(None, result)
+
+[<Test>]
+let ``AsyncSeq.tryFindBack returns None on empty sequence`` () =
+  let result =
+    AsyncSeq.empty<int>
+    |> AsyncSeq.tryFindBack (fun _ -> true)
+    |> Async.RunSynchronously
+  Assert.AreEqual(None, result)
+
+[<Test>]
+let ``AsyncSeq.tryFindBack returns only element when singleton matches`` () =
+  let result =
+    AsyncSeq.singleton 42
+    |> AsyncSeq.tryFindBack (fun x -> x = 42)
+    |> Async.RunSynchronously
+  Assert.AreEqual(Some 42, result)
+
+[<Test>]
+let ``AsyncSeq.findBack returns last matching element`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3; 4; 5 ]
+    |> AsyncSeq.findBack (fun x -> x < 4)
+    |> Async.RunSynchronously
+  Assert.AreEqual(3, result)
+
+[<Test>]
+let ``AsyncSeq.findBack raises KeyNotFoundException when no match`` () =
+  Assert.Throws<System.Collections.Generic.KeyNotFoundException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ] |> AsyncSeq.findBack (fun x -> x = 99) |> Async.RunSynchronously |> ignore)
+  |> ignore
+
+[<Test>]
+let ``AsyncSeq.tryFindBackAsync returns last matching element`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 2; 3; 4; 5 ]
+    |> AsyncSeq.tryFindBackAsync (fun x -> async { return x % 2 = 0 })
+    |> Async.RunSynchronously
+  Assert.AreEqual(Some 4, result)
+
+[<Test>]
+let ``AsyncSeq.tryFindBackAsync returns None when no match`` () =
+  let result =
+    AsyncSeq.ofSeq [ 1; 3; 5 ]
+    |> AsyncSeq.tryFindBackAsync (fun x -> async { return x % 2 = 0 })
+    |> Async.RunSynchronously
+  Assert.AreEqual(None, result)
+
+[<Test>]
+let ``AsyncSeq.findBackAsync returns last matching element`` () =
+  let result =
+    AsyncSeq.ofSeq [ 10; 20; 30; 40 ]
+    |> AsyncSeq.findBackAsync (fun x -> async { return x < 35 })
+    |> Async.RunSynchronously
+  Assert.AreEqual(30, result)
+
+[<Test>]
+let ``AsyncSeq.findBackAsync raises KeyNotFoundException when no match`` () =
+  Assert.Throws<System.Collections.Generic.KeyNotFoundException>(fun () ->
+    AsyncSeq.ofSeq [ 1; 2; 3 ]
+    |> AsyncSeq.findBackAsync (fun x -> async { return x = 99 })
+    |> Async.RunSynchronously |> ignore)
+  |> ignore
+
 // ===== sortWith =====
 
 [<Test>]

version.props

@@ -1,5 +1,5 @@
 <Project>
   <PropertyGroup>
-    <Version>4.11.0</Version>
+    <Version>4.12.0</Version>
   </PropertyGroup>
 </Project>