Merge branch 'main' into feature/additional-coverage-utils-edge-cases

Author: dsyme

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -38,14 +38,6 @@ and private AsyncSeqSrcNode<'a> =
 [<AutoOpen>]
 module internal Utils =
 
-    [<RequireQualifiedAccess>]
-    module Choice =
-
-      /// Maps over the left result type.
-      let mapl (f:'T -> 'U) = function
-        | Choice1Of2 a -> f a |> Choice1Of2
-        | Choice2Of2 e -> Choice2Of2 e
-
     module Disposable =
 
       let empty : IDisposable =
@@ -295,10 +287,6 @@ type AsyncSeqOp<'T> () =
   abstract member FoldAsync : ('S -> 'T -> Async<'S>) -> 'S -> Async<'S>
   abstract member MapAsync : ('T -> Async<'U>) -> AsyncSeq<'U>
   abstract member IterAsync : ('T -> Async<unit>) -> Async<unit>
-  default x.MapAsync (f:'T -> Async<'U>) : AsyncSeq<'U> =
-    x.ChooseAsync (f >> Async.map Some)
-  default x.IterAsync (f:'T -> Async<unit>) : Async<unit> =
-    x.FoldAsync (fun () t -> f t) ()
 
 [<AutoOpen>]
 module AsyncSeqOp =

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

@@ -1882,6 +1882,86 @@ let ``Seq.ofAsyncSeq with exception`` () =
     Seq.ofAsyncSeq asyncSeqWithError |> Seq.toList |> ignore
   ) |> ignore
 
+[<Test>]
+let ``AsyncSeq.intervalMs should generate sequence with timestamps``() = 
+  let result = 
+    AsyncSeq.intervalMs 50
+    |> AsyncSeq.take 3
+    |> AsyncSeq.toListAsync
+    |> AsyncOps.timeoutMs 1000
+    |> Async.RunSynchronously
+  
+  Assert.AreEqual(3, result.Length)
+  // Verify timestamps are increasing
+  Assert.IsTrue(result.[1] > result.[0])
+  Assert.IsTrue(result.[2] > result.[1])
+
+[<Test>]
+let ``AsyncSeq.intervalMs with zero period should work``() = 
+  let result = 
+    AsyncSeq.intervalMs 0
+    |> AsyncSeq.take 2
+    |> AsyncSeq.toListAsync
+    |> AsyncOps.timeoutMs 500
+    |> Async.RunSynchronously
+  
+  Assert.AreEqual(2, result.Length)
+
+[<Test>]
+let ``AsyncSeq.take with negative count should throw ArgumentException``() = 
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [1;2;3]
+    |> AsyncSeq.take -1
+    |> AsyncSeq.toListAsync
+    |> Async.RunSynchronously
+    |> ignore
+  ) |> ignore
+
+[<Test>]
+let ``AsyncSeq.skip with negative count should throw ArgumentException``() = 
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.ofSeq [1;2;3]
+    |> AsyncSeq.skip -1
+    |> AsyncSeq.toListAsync
+    |> Async.RunSynchronously
+    |> ignore
+  ) |> ignore
+
+[<Test>]
+let ``AsyncSeq.take zero should return empty sequence``() = 
+  let expected = []
+  let actual = 
+    AsyncSeq.ofSeq [1;2;3]
+    |> AsyncSeq.take 0
+    |> AsyncSeq.toListAsync
+    |> Async.RunSynchronously
+  
+  Assert.AreEqual(expected, actual)
+
+[<Test>]  
+let ``AsyncSeq.skip zero should return original sequence``() = 
+  let expected = [1;2;3]
+  let actual = 
+    AsyncSeq.ofSeq [1;2;3]
+    |> AsyncSeq.skip 0
+    |> AsyncSeq.toListAsync
+    |> Async.RunSynchronously
+  
+  Assert.AreEqual(expected, actual)
+
+[<Test>]
+let ``AsyncSeq.replicateInfinite with exception should propagate exception``() =
+  let exceptionMsg = "test exception"
+  let expected = System.ArgumentException(exceptionMsg)
+  
+  Assert.Throws<System.ArgumentException>(fun () ->
+    AsyncSeq.replicateInfinite (raise expected)
+    |> AsyncSeq.take 2
+    |> AsyncSeq.toListAsync
+    |> Async.RunSynchronously
+    |> ignore
+  ) |> ignore
+
 #if (NETSTANDARD2_1 || NETCOREAPP3_0)
 [<Test>]
 let ``AsyncSeq.ofAsyncEnum should roundtrip successfully``() =