IAsyncEnumerable support (#37)

* Remove altcover

It can't cover inline code which this library is all inline code

* Add IAsyncEnumerable to TaskBaseBuilders

* Add IAsyncEnumerable to CancellableTaskBaseBuilders

* AsyncEx IAsyncEnumerable support

* Docs

Author: TheAngryByrd

README.md

@@ -119,6 +119,24 @@ AsyncEx is similar to Async except in the following ways:
     }
     ```
 
+4. Use [IAsyncEnumerable](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.iasyncenumerable-1?view=net-8.0) with `for` keyword. This example uses [TaskSeq](https://github.com/fsprojects/FSharp.Control.TaskSeq) but you can use any `IAsyncEnumerable<T>`.
+
+
+    ```fsharp
+    open IcedTasks
+    open FSharp.Control
+    let myAsyncEx = asyncEx {
+        let items = taskSeq {  // IAsyncEnumerable<T>
+            yield 42
+            do! Task.Delay(100)
+            yield 1701
+        }
+        let mutable sum = 0
+        for i in items do
+            sum <- sum + i
+        return sum
+    }
+    ```
 
 ### For [ValueTasks](https://devblogs.microsoft.com/dotnet/understanding-the-whys-whats-and-whens-of-valuetask/)
 

docsSrc/index.md

@@ -90,6 +90,24 @@ AsyncEx is similar to Async except in the following ways:
     }
     ```
 
+4. Use [IAsyncEnumerable](https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.iasyncenumerable-1?view=net-8.0) with `for` keyword. This example uses [TaskSeq](https://github.com/fsprojects/FSharp.Control.TaskSeq) but you can use any `IAsyncEnumerable<T>`.
+
+
+    ```fsharp
+    open IcedTasks
+    open FSharp.Control
+    let myAsyncEx = asyncEx {
+        let items = taskSeq {  // IAsyncEnumerable<T>
+            yield 42
+            do! Task.Delay(100)
+            yield 1701
+        }
+        let mutable sum = 0
+        for i in items do
+            sum <- sum + i
+        return sum
+    }
+    ```
 
 ### For [ValueTasks](https://devblogs.microsoft.com/dotnet/understanding-the-whys-whats-and-whens-of-valuetask/)
 
@@ -110,6 +128,7 @@ let myValueTask = task {
 - You want to be able to re-run these executable tasks
 - You don't want to pollute your methods/functions with extra CancellationToken parameters
 - You want the computation to handle checking cancellation before every bind.
+- You want to use the `for` keyword with `IAsyncEnumerable<T>`.
 
 
 ### ColdTask

paket.dependencies

@@ -18,6 +18,7 @@ group Test
   nuget YoloDev.Expecto.TestSdk >= 0.14.2
   nuget Microsoft.NET.Test.Sdk >= 17.7.2
   nuget altcover >= 8.6.68
+  nuget FSharp.Control.TaskSeq
 
 // [ FAKE GROUP ]
 group Build

paket.lock

@@ -365,10 +365,12 @@ NUGET
     Expecto (10.1)
       FSharp.Core (>= 7.0.200) - restriction: >= net6.0
       Mono.Cecil (>= 0.11.4 < 1.0) - restriction: >= net6.0
-    FSharp.Core (7.0.401) - restriction: >= net6.0
+    FSharp.Control.TaskSeq (0.3)
+      FSharp.Core (>= 6.0.2) - restriction: >= netstandard2.1
+    FSharp.Core (7.0.401) - restriction: >= netstandard2.1
     Microsoft.Bcl.AsyncInterfaces (7.0) - restriction: || (&& (>= net462) (>= net6.0)) (&& (>= net462) (>= netstandard2.0)) (&& (>= net6.0) (< net8.0)) (&& (< net6.0) (>= netstandard2.0))
       System.Threading.Tasks.Extensions (>= 4.5.4) - restriction: || (>= net462) (&& (>= netstandard2.0) (< netstandard2.1))
-    Microsoft.Bcl.TimeProvider (8.0.0-rc.2.23479.6) - restriction: || (&& (>= net6.0) (< net8.0)) (&& (< net6.0) (>= netstandard2.0))
+    Microsoft.Bcl.TimeProvider (8.0) - restriction: || (&& (>= net6.0) (< net8.0)) (&& (< net6.0) (>= netstandard2.0))
       Microsoft.Bcl.AsyncInterfaces (>= 6.0) - restriction: || (>= net462) (&& (< net8.0) (>= netstandard2.0))
       System.ValueTuple (>= 4.5) - restriction: >= net462
     Microsoft.CodeCoverage (17.7.2) - restriction: || (>= net462) (>= netcoreapp3.1)
@@ -397,8 +399,8 @@ NUGET
     System.Threading.Tasks.Extensions (4.5.4) - restriction: || (&& (>= net462) (>= net6.0)) (&& (>= net462) (>= netstandard2.0)) (&& (>= net6.0) (< netstandard2.1)) (&& (>= netstandard2.0) (< netstandard2.1))
       System.Runtime.CompilerServices.Unsafe (>= 4.5.3) - restriction: || (&& (< monoandroid) (< monotouch) (< net45) (>= netstandard1.0) (< netstandard2.0) (< win8) (< wpa81) (< xamarintvos) (< xamarinwatchos)) (&& (< monoandroid) (< netstandard1.0) (>= portable-net45+win8+wp8+wpa81) (< win8)) (&& (>= net45) (< netstandard2.0)) (&& (< net45) (< netcoreapp2.1) (>= netstandard2.0) (< xamarinios) (< xamarinmac) (< xamarintvos) (< xamarinwatchos)) (>= net461) (&& (< netstandard1.0) (>= win8)) (&& (< netstandard2.0) (>= wpa81)) (>= wp8)
     System.ValueTuple (4.5) - restriction: || (&& (>= net462) (>= net6.0)) (&& (>= net462) (>= netstandard2.0))
-    TimeProviderExtensions (1.0.0-rc.2)
-      Microsoft.Bcl.TimeProvider (>= 8.0.0-rc.1.23419.4) - restriction: || (&& (>= net6.0) (< net8.0)) (&& (< net6.0) (>= netstandard2.0))
+    TimeProviderExtensions (1.0)
+      Microsoft.Bcl.TimeProvider (>= 8.0) - restriction: || (&& (>= net6.0) (< net8.0)) (&& (< net6.0) (>= netstandard2.0))
     YoloDev.Expecto.TestSdk (0.14.2)
       Expecto (>= 10.0 < 11.0) - restriction: >= net6.0
       FSharp.Core (>= 7.0.200) - restriction: >= net6.0

src/IcedTasks/AsyncEx.fs

@@ -4,6 +4,7 @@ open System
 open System.Threading
 open System.Threading.Tasks
 open System.Runtime.ExceptionServices
+open System.Collections.Generic
 
 type private Async =
     static member inline map f x =
@@ -303,13 +304,47 @@ type AsyncExBuilder() =
             )
         )
 
+
+    member inline internal _.WhileAsync(guard: Async<bool>, computation: Async<unit>) =
+        async {
+            let mutable keepGoing = true
+
+            while keepGoing do
+                let! guardResult = guard
+                if guardResult then do! computation else keepGoing <- false
+        }
+
+    member inline this.For
+        (
+            sequence: IAsyncEnumerable<'e>,
+            [<InlineIfLambda>] body: 'e -> Async<unit>
+        ) =
+        this.Bind(
+            Async.CancellationToken,
+            fun (ct: CancellationToken) ->
+                this.Using(
+                    sequence.GetAsyncEnumerator ct,
+                    (fun enumerator ->
+                        this.WhileAsync(
+                            (this.Delay(fun () ->
+                                enumerator.MoveNextAsync()
+                                |> AsyncEx.AwaitValueTask
+                            )),
+                            (body enumerator.Current)
+                        )
+
+                    )
+                )
+        )
+
 #endif
     member inline _.While([<InlineIfLambda>] guard: unit -> bool, computation: Async<unit>) =
         async.While(guard, computation)
 
     member inline _.For(sequence: seq<'e>, [<InlineIfLambda>] body: 'e -> Async<unit>) =
         async.For(sequence, body)
 
+
     member inline _.Combine(computation1, computation2) =
         async.Combine(computation1, computation2)
 
@@ -335,6 +370,8 @@ module AsyncExExtensionsLowPriority =
 
     type AsyncExBuilder with
 
+        member inline _.Source(seq: #seq<_>) = seq
+
         member inline _.Using(resource: #IDisposable, [<InlineIfLambda>] binder) =
             async.Using(resource, binder)
 
@@ -361,6 +398,7 @@ module AsyncExExtensionsLowPriority =
     /// <item><description>Allows <c>use</c> on <see cref="T:System.IAsyncDisposable">System.IAsyncDisposable</see></description></item>
     /// <item><description>Allows <c>let!</c> for Tasks, ValueTasks, and any Awaitable Type</description></item>
     /// <item><description>When Tasks throw exceptions they will use the behavior described in <see href="https://github.com/fsharp/fslang-suggestions/issues/840">Async.Await overload (esp. AwaitTask without throwing AggregateException)</see></description></item>
+    /// <item><description>Allow <c>for</c> on <see cref="T:System.Collections.Generic.IAsyncEnumerable`1">System.Collections.Generic.IAsyncDisposable</see></description></item>
     /// </list>
     ///
     /// </remarks>
@@ -372,8 +410,9 @@ module AsyncExExtensionsHighPriority =
 
     type AsyncExBuilder with
 
-        member inline _.Source(seq: #seq<_>) = seq
-
+#if NETSTANDARD2_1 || NET6_0_OR_GREATER
+        member inline _.Source(seq: #IAsyncEnumerable<_>) = seq
+#endif
         // Required because SRTP can't determine the type of the awaiter
         //     Candidates:
         //  - Task.GetAwaiter() : Runtime.CompilerServices.TaskAwaiter
@@ -403,6 +442,7 @@ module PolyfillBuilders =
     /// <item><description>Allows <c>use</c> on <see cref="T:System.IAsyncDisposable">System.IAsyncDisposable</see></description></item>
     /// <item><description>Allows <c>let!</c> for Tasks, ValueTasks, and any Awaitable Type</description></item>
     /// <item><description>When Tasks throw exceptions they will use the behavior described in <see href="https://github.com/fsharp/fslang-suggestions/issues/840">Async.Await overload (esp. AwaitTask without throwing AggregateException)</see></description></item>
+    /// <item><description>Allow <c>for</c> on <see cref="T:System.Collections.Generic.IAsyncEnumerable`1">System.Collections.Generic.IAsyncDisposable</see></description></item>
     /// </list>
     ///
     /// </remarks>

src/IcedTasks/CancellableTaskBuilderBase.fs

@@ -12,6 +12,7 @@ module CancellableTaskBase =
     open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers
     open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators
     open Microsoft.FSharp.Collections
+    open System.Collections.Generic
 
     /// The extra data stored in ResumableStateMachine for tasks
     [<Struct; NoComparison; NoEquality>]
@@ -291,6 +292,93 @@ module CancellableTaskBase =
                         |> Awaitable.GetAwaiter
                 )
             )
+
+
+        member inline internal _.WhileAsync
+            (
+                [<InlineIfLambda>] condition,
+                body: CancellableTaskBaseCode<_, unit, 'Builder>
+            ) : CancellableTaskBaseCode<_, unit, 'Builder> =
+            let mutable condition_res = true
+
+            ResumableCode.While(
+                (fun () -> condition_res),
+                CancellableTaskBaseCode<_, unit, 'Builder>(fun sm ->
+                    if __useResumableCode then
+
+                        let mutable __stack_condition_fin = true
+                        let mutable awaiter = condition ()
+
+                        if Awaiter.IsCompleted awaiter then
+
+                            __stack_condition_fin <- true
+
+                            condition_res <- Awaiter.GetResult awaiter
+                        else
+
+                            // This will yield with __stack_fin = false
+                            // This will resume with __stack_fin = true
+                            let __stack_yield_fin = ResumableCode.Yield().Invoke(&sm)
+                            __stack_condition_fin <- __stack_yield_fin
+
+                            if __stack_condition_fin then
+                                condition_res <- Awaiter.GetResult awaiter
+
+
+                        if __stack_condition_fin then
+
+                            if condition_res then body.Invoke(&sm) else true
+                        else
+                            let mutable awaiter = awaiter :> ICriticalNotifyCompletion
+
+                            MethodBuilder.AwaitUnsafeOnCompleted(
+                                &sm.Data.MethodBuilder,
+                                &awaiter,
+                                &sm
+                            )
+
+                            false
+                    else
+
+                        let mutable awaiter = condition ()
+
+                        let cont =
+                            CancellableTaskBaseResumptionFunc<'TOverall, 'Builder>(fun sm ->
+                                condition_res <- Awaiter.GetResult awaiter
+                                if condition_res then body.Invoke(&sm) else true
+                            )
+
+                        if Awaiter.IsCompleted awaiter then
+                            cont.Invoke(&sm)
+                        else
+                            sm.ResumptionDynamicInfo.ResumptionData <-
+                                (awaiter :> ICriticalNotifyCompletion)
+
+                            sm.ResumptionDynamicInfo.ResumptionFunc <- cont
+                            false
+                )
+            )
+
+        member inline this.For
+            (
+                source: #IAsyncEnumerable<'T>,
+                body: 'T -> CancellableTaskBaseCode<_, unit, 'Builder>
+            ) : CancellableTaskBaseCode<_, _, 'Builder> =
+
+            CancellableTaskBaseCode<_, _, 'Builder>(fun sm ->
+                this
+                    .Using(
+                        source.GetAsyncEnumerator sm.Data.CancellationToken,
+                        (fun (e: IAsyncEnumerator<'T>) ->
+                            this.WhileAsync(
+                                (fun () -> Awaitable.GetAwaiter(e.MoveNextAsync())),
+                                (fun sm -> (body e.Current).Invoke(&sm))
+                            )
+                        )
+
+                    )
+                    .Invoke(&sm)
+            )
 #endif
 
 
@@ -595,6 +683,15 @@ module CancellableTaskBase =
                 ) =
                 ResumableCode.Using(resource, binder)
 
+
+            /// <summary>Allows the computation expression to turn other types into other types</summary>
+            ///
+            /// <remarks>This is the identify function for For binds.</remarks>
+            ///
+            /// <returns>IEnumerable</returns>
+            member inline _.Source(s: #seq<_>) : #seq<_> = s
+
+
     /// <exclude/>
     [<AutoOpen>]
     module HighPriority =
@@ -667,13 +764,14 @@ module CancellableTaskBase =
         // High priority extensions
         type CancellableTaskBuilderBase with
 
-
+#if NETSTANDARD2_1 || NET6_0_OR_GREATER
             /// <summary>Allows the computation expression to turn other types into other types</summary>
             ///
             /// <remarks>This is the identify function for For binds.</remarks>
             ///
             /// <returns>IEnumerable</returns>
-            member inline _.Source(s: #seq<_>) : #seq<_> = s
+            member inline _.Source(s: #IAsyncEnumerable<_>) = s
+#endif
 
             /// <summary>Allows the computation expression to turn other types into CancellationToken -> 'Awaiter</summary>
             ///