Merge branch 'pr/99' into forloop-with-iasyncenumerable-with-task-and-async

Author: abelbraaksma

src/FSharp.Control.TaskSeq.Test/TaskSeq.Extensions.Tests.fs

@@ -13,16 +13,20 @@ open FSharp.Control
 //
 
 
-// module TaskBuilder =
-//     open TaskSeq.Tests
-
-//     [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
-//     let ``TaskSeq-existsAsync happy path last item of seq`` variant =
-//         task {
-//             let values =  Gen.getSeqImmutable variant
-//             let mutable sum = 0
-//             for x in values do
-//                 sum <- sum + x
-//         }
-        // |> TaskSeq.existsAsync (fun x -> task { return x = 10 })
-        // |> Task.map (should be True)
+module TaskBuilder =
+    open TaskSeq.Tests
+
+    [<Theory; ClassData(typeof<TestImmTaskSeq>)>]
+    let ``TaskSeq-existsAsync happy path last item of seq`` variant =
+        task {
+            let values = Gen.getSeqImmutable variant
+
+            let mutable sum = 0
+            for x in values do
+                sum <- sum + x
+
+            // let! expected =
+            //     (0, values)
+            //     ||> TaskSeq.fold((+))
+            Assert.Equal(55, sum)
+        }

src/FSharp.Control.TaskSeq/TaskSeq.fs

@@ -374,6 +374,8 @@ module AsyncSeqExtensions =
 
             false
     open Microsoft.FSharp.Core.CompilerServices
+    open Microsoft.FSharp.Core.CompilerServices.StateMachineHelpers
+    open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators
 
     // Add asynchronous for loop to the 'async' computation builder
     type Microsoft.FSharp.Control.AsyncBuilder with
@@ -387,27 +389,72 @@ module AsyncSeqExtensions =
     type Microsoft.FSharp.Control.TaskBuilder with
 
 
-        member inline this.While(condition : unit -> ValueTask<bool>,  body  : TaskCode<'TOverall,unit>) =
-            TaskCode<_,_>(fun sm ->
-                WhileDynamic(&sm, condition, body)
+        member inline _.WhileAsync
+            (
+                [<InlineIfLambda>] condition: unit -> ValueTask<bool>,
+                body: TaskCode<_,unit>
+            ) : TaskCode<_,_> =
+            let mutable condition_res = true
+
+            ResumableCode.While(
+                (fun () -> condition_res),
+                TaskCode<_, _>(fun sm ->
+                    let mutable __stack_condition_fin = true
+                    let __stack_vtask = condition ()
+
+                    let mutable awaiter = __stack_vtask.GetAwaiter()
+                    if awaiter.IsCompleted then
+                        // logInfo "at WhileAsync: returning completed task"
+
+                        __stack_condition_fin <- true
+                        condition_res <- awaiter.GetResult()
+                    else
+                        // logInfo "at WhileAsync: awaiting non-completed task"
 
-            )
+                        // 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()
 
 
+                    if __stack_condition_fin then
+                        if condition_res then body.Invoke(&sm) else true
+                    else
+                        sm.Data.MethodBuilder.AwaitUnsafeOnCompleted(&awaiter, &sm)
+                        false)
+            )
+
         member inline this.For
             (
                 tasksq: IAsyncEnumerable<'T>,
-                body: 'T -> TaskCode<'TOverall, unit>
-            ) : TaskCode<'TOverall, unit> =
+                body: 'T -> TaskCode<_, unit>
+            ) : TaskCode<_, unit> =
+            // tasksq
+            // |> TaskSeq.iterAsync (body >> task.Run)
+            // |> task.ReturnFrom
+
+            // task.ReturnFrom <|
+            //     task {
+            //         let mutable continueWhile = true
+            //         use e = tasksq.GetAsyncEnumerator()
+            //         while continueWhile do
+            //             let! next = e.MoveNextAsync()
+            //             if next then
+            //                 do! task.Run(body e.Current)
+            //             else
+            //                 continueWhile <- false
+            //     }
+
             TaskCode<'TOverall, unit>(fun sm ->
 
                 this
                     .Using(
                         tasksq.GetAsyncEnumerator(CancellationToken()),
                         (fun e ->
-                            let next () = e.MoveNextAsync()
-                            this.While(next, (fun sm -> (body e.Current).Invoke(&sm))))
+                            this.WhileAsync(e.MoveNextAsync, (fun sm -> (body e.Current).Invoke(&sm))))
                     )
                     .Invoke(&sm))
 

src/FSharp.Control.TaskSeq/TaskSeq.fsi

@@ -594,11 +594,10 @@ module AsyncSeqExtensions =
 
     type TaskBuilder with
 
-        member inline While:
+        member inline WhileAsync:
             condition: (unit -> System.Threading.Tasks.ValueTask<bool>) * body: TaskCode<'TOverall, unit> ->
-                TaskCode<'TOverall, 'a>
+                TaskCode<'TOverall, unit>
 
         member inline For:
             tasksq: System.Collections.Generic.IAsyncEnumerable<'T> * body: ('T -> TaskCode<'TOverall, unit>) ->
                 TaskCode<'TOverall, unit>
-