[repo-assist] Tests: add coverage for zapp, zappAsync, and compareWithAsync

RELEASE_NOTES.md

@@ -1,3 +1,7 @@
+### 4.18.0
+
+* Tests: Added comprehensive tests for `AsyncSeq.zapp`, `AsyncSeq.zappAsync`, and `AsyncSeq.compareWithAsync`, which previously had no dedicated test coverage.
+
 ### 4.17.0
 
 * Added `AsyncSeq.exists2` — asynchronously tests whether any corresponding pair of elements in two async sequences satisfies the predicate. Evaluates pairwise up to the shorter sequence; short-circuits on first match. Mirrors `Seq.exists2`.

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

@@ -2094,7 +2094,7 @@
       let actual =
         ls
         |> AsyncSeq.ofSeq
         |> AsyncSeq.groupBy p
         |> AsyncSeq.mapAsyncParallel (snd >> AsyncSeq.toListAsync)
       Assert.AreEqual(expected, actual)
 
@@ -2103,7 +2103,7 @@
   let expected = asyncSeq { raise (exn("test")) }
   let actual =
     asyncSeq { raise (exn("test")) }
     |> AsyncSeq.groupBy (fun i -> i % 3)
     |> AsyncSeq.mapAsyncParallel (snd >> AsyncSeq.toListAsync)
   Assert.AreEqual(expected, actual)
 
@@ -4851,7 +4851,7 @@
 let ``AsyncSeq.groupByAsync groups elements by async projection`` () =
   let result =
     AsyncSeq.ofSeq [1..6]
     |> AsyncSeq.groupByAsync (fun x -> async { return x % 2 })
     |> AsyncSeq.mapAsyncParallel (fun (key, grp) -> async {
         let! items = AsyncSeq.toArrayAsync grp
         return key, Array.sort items })
@@ -4864,7 +4864,7 @@
 let ``AsyncSeq.groupByAsync on empty sequence returns empty`` () =
   let result =
     AsyncSeq.empty<int>
     |> AsyncSeq.groupByAsync (fun x -> async { return x % 2 })
     |> AsyncSeq.toArrayAsync
     |> Async.RunSynchronously
   Assert.AreEqual([||], result)
@@ -4873,7 +4873,7 @@
 let ``AsyncSeq.groupByAsync with all-same key produces single group`` () =
   let result =
     AsyncSeq.ofSeq [1; 2; 3]
     |> AsyncSeq.groupByAsync (fun _ -> async { return "same" })
     |> AsyncSeq.mapAsyncParallel (fun (key, grp) -> async {
         let! items = AsyncSeq.toArrayAsync grp
         return key, Array.sort items })
@@ -5087,3 +5087,102 @@
       (AsyncSeq.ofSeq [1;2;3])
     |> Async.RunSynchronously
   Assert.IsTrue(result)
+
+// ===== zapp / zappAsync =====
+
+[<Test>]
+let ``AsyncSeq.zapp applies functions to corresponding elements`` () =
+  let fs = asyncSeq { yield (fun x -> x + 10); yield (fun x -> x * 2); yield (fun x -> x - 1) }
+  let vs = asyncSeq { yield 1; yield 2; yield 3 }
+  let result = AsyncSeq.zapp fs vs |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 11; 4; 2 |], result)
+
+[<Test>]
+let ``AsyncSeq.zapp stops when functions run out`` () =
+  let fs = asyncSeq { yield (fun x -> x + 1); yield (fun x -> x + 2) }
+  let vs = asyncSeq { yield 10; yield 20; yield 30 }
+  let result = AsyncSeq.zapp fs vs |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 11; 22 |], result)
+
+[<Test>]
+let ``AsyncSeq.zapp stops when values run out`` () =
+  let fs = asyncSeq { yield (fun x -> x + 1); yield (fun x -> x + 2); yield (fun x -> x + 3) }
+  let vs = asyncSeq { yield 5 }
+  let result = AsyncSeq.zapp fs vs |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 6 |], result)
+
+[<Test>]
+let ``AsyncSeq.zapp on empty functions returns empty`` () =
+  let fs = AsyncSeq.empty<int -> int>
+  let vs = asyncSeq { yield 1; yield 2; yield 3 }
+  let result = AsyncSeq.zapp fs vs |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([||], result)
+
+[<Test>]
+let ``AsyncSeq.zappAsync applies async functions to corresponding elements`` () =
+  let fs = asyncSeq {
+    yield (fun x -> async { return x + 10 })
+    yield (fun x -> async { return x * 3 })
+  }
+  let vs = asyncSeq { yield 5; yield 4 }
+  let result = AsyncSeq.zappAsync fs vs |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 15; 12 |], result)
+
+[<Test>]
+let ``AsyncSeq.zappAsync on empty source returns empty`` () =
+  let fs = asyncSeq { yield (fun x -> async { return x + 1 }) }
+  let vs = AsyncSeq.empty<int>
+  let result = AsyncSeq.zappAsync fs vs |> AsyncSeq.toArrayAsync |> Async.RunSynchronously
+  Assert.AreEqual([||], result)
+
+// ===== compareWithAsync =====
+
+[<Test>]
+let ``AsyncSeq.compareWithAsync equal sequences returns 0`` () =
+  let result =
+    AsyncSeq.compareWithAsync
+      (fun a b -> async { return compare a b })
+      (AsyncSeq.ofSeq [1;2;3])
+      (AsyncSeq.ofSeq [1;2;3])
+    |> Async.RunSynchronously
+  Assert.AreEqual(0, result)
+
+[<Test>]
+let ``AsyncSeq.compareWithAsync shorter is less than longer`` () =
+  let result =
+    AsyncSeq.compareWithAsync
+      (fun a b -> async { return compare a b })
+      (AsyncSeq.ofSeq [1;2])
+      (AsyncSeq.ofSeq [1;2;3])
+    |> Async.RunSynchronously
+  Assert.IsTrue(result < 0)
+
+[<Test>]
+let ``AsyncSeq.compareWithAsync longer is greater than shorter`` () =
+  let result =
+    AsyncSeq.compareWithAsync
+      (fun a b -> async { return compare a b })
+      (AsyncSeq.ofSeq [1;2;3])
+      (AsyncSeq.ofSeq [1;2])
+    |> Async.RunSynchronously
+  Assert.IsTrue(result > 0)
+
+[<Test>]
+let ``AsyncSeq.compareWithAsync lexicographic difference`` () =
+  let result =
+    AsyncSeq.compareWithAsync
+      (fun a b -> async { return compare a b })
+      (AsyncSeq.ofSeq [1;3])
+      (AsyncSeq.ofSeq [1;2])
+    |> Async.RunSynchronously
+  Assert.IsTrue(result > 0)
+
+[<Test>]
+let ``AsyncSeq.compareWithAsync empty sequences returns 0`` () =
+  let result =
+    AsyncSeq.compareWithAsync
+      (fun a b -> async { return compare a b })
+      AsyncSeq.empty<int>
+      AsyncSeq.empty<int>
+    |> Async.RunSynchronously
+  Assert.AreEqual(0, result)