Add a few let! tests and overload tests for async

Author: abelbraaksma

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

@@ -80,3 +80,68 @@ let ``CE taskSeq: use 'let!' with a non-generic task`` () =
     }
     |> verifyEmpty
     |> Task.map (fun _ -> value |> should equal 1)
+
+[<Fact>]
+let ``CE taskSeq: use 'let!' with Async`` () =
+    let mutable value = 0
+
+    taskSeq {
+        do value <- value + 1
+        let! _ = Async.Sleep 50
+        do value <- value + 1
+    }
+    |> verifyEmpty
+    |> Task.map (fun _ -> value |> should equal 2)
+
+[<Fact>]
+let ``CE taskSeq: use 'let!' with Async - mutables`` () =
+    let mutable value = 0
+
+    taskSeq {
+        do! async { value <- value + 1 }
+        let! x = async { return value + 1 }
+        do! Async.Sleep 50
+        do! async { value <- value + 1 }
+        let! ret = async { return value + 1 }
+        yield x + ret // eq 6
+    }
+    |> TaskSeq.exactlyOne
+    |> Task.map (fun _ -> value |> should equal 6)
+
+[<Fact>]
+let ``CE taskSeq: use 'let!' with all kinds of overloads at once`` () =
+    let mutable value = 0
+
+    // this test should be expanded in case any new overload is added
+    // that is supported by `let!`, to ensure the high/low priority
+    // overloads still work properly
+    taskSeq {
+        let! a = task { // eq 1
+            do! Task.Delay 10
+            do value <- value + 1
+            return value
+        }
+
+        let! b =  // eq 2
+            task {
+                do! Task.Delay 50
+                do value <- value + 1
+                return value
+            }
+            |> ValueTask<int>
+
+        let! c = ValueTask<_>(4) // valuetask that completes immediately
+        let! _ = Task.Factory.StartNew(fun () -> value <- value + 1) // non-generic Task with side effect
+        let! d = Task.fromResult (4) // normal Task that completes immediately
+        let! _ = Async.Sleep 0 // unit Async
+
+        let! e = async {
+            do! Async.Sleep 40
+            do value <- value + 1
+            return value
+        }
+
+        yield! [ a; b; c; d; e ]
+    }
+    |> TaskSeq.toListAsync
+    |> Task.map (fun x -> should equal [ 1; 2; 4; 4; 3 ])