Add tests for do and do! and cleanup some helper functions

Author: abelbraaksma

src/FSharp.Control.TaskSeq.Test/FSharp.Control.TaskSeq.Test.fsproj

@@ -48,6 +48,7 @@
     <Compile Include="TaskSeq.Realworld.fs" />
     <Compile Include="TaskSeq.AsyncExtensions.Tests.fs" />
     <Compile Include="TaskSeq.TaskExtensions.Tests.fs" />
+    <Compile Include="TaskSeq.Do.Tests.fs" />
     <Compile Include="TaskSeq.Using.Tests.fs" />
     <Compile Include="Program.fs" />
   </ItemGroup>

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

@@ -0,0 +1,48 @@
+module TaskSeq.Tests.Do
+
+open System
+open System.Threading.Tasks
+open FsUnit
+open Xunit
+
+open FSharp.Control
+
+[<Fact>]
+let ``CE taskSeq: use 'do'`` () =
+    let mutable value = 0
+
+    taskSeq { do value <- value + 1 }
+
+    |> verifyEmpty
+
+[<Fact>]
+let ``CE taskSeq: use 'do!' with a task<unit>`` () =
+    let mutable value = 0
+
+    taskSeq { do! task { do value <- value + 1 } }
+
+    |> verifyEmpty
+
+//[<Fact>]
+//let ``CE taskSeq: use 'do!' with a valuetask<unit>`` () =
+//    let mutable value = 0
+
+//    taskSeq { do! ValueTask.ofIValueTaskSource (task { do value <- value + 1 }) }
+
+//    |> verifyEmpty
+
+//[<Fact>]
+//let ``CE taskSeq: use 'do!' with a non-generic valuetask`` () =
+//    let mutable value = 0
+
+//    taskSeq { do! ValueTask(task { do value <- value + 1 }) }
+
+//    |> verifyEmpty
+
+//[<Fact>]
+//let ``CE taskSeq: use 'do!' with a non-generic task`` () =
+//    let mutable value = 0
+
+//    taskSeq { do! (task { do value <- value + 1 }) |> Task.ignore }
+
+//    |> verifyEmpty

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

@@ -1,4 +1,4 @@
-module FSharp.Control.TaskSeq.Test
+module TaskSeq.Test.Using
 
 open System
 open System.Threading.Tasks
@@ -34,7 +34,7 @@ type private MultiDispose(disposed: int ref) =
 let private check = TaskSeq.length >> Task.map (should equal 1)
 
 [<Fact>]
-let ``CE task: Using when type implements IDisposable`` () =
+let ``CE taskSeq: Using when type implements IDisposable`` () =
     let disposed = ref false
 
     let ts = taskSeq {
@@ -46,7 +46,7 @@ let ``CE task: Using when type implements IDisposable`` () =
     |> Task.map (fun _ -> disposed.Value |> should be True)
 
 [<Fact>]
-let ``CE task: Using when type implements IAsyncDisposable`` () =
+let ``CE taskSeq: Using when type implements IAsyncDisposable`` () =
     let disposed = ref false
 
     let ts = taskSeq {
@@ -58,7 +58,7 @@ let ``CE task: Using when type implements IAsyncDisposable`` () =
     |> Task.map (fun _ -> disposed.Value |> should be True)
 
 [<Fact>]
-let ``CE task: Using when type implements IDisposable and IAsyncDisposable`` () =
+let ``CE taskSeq: Using when type implements IDisposable and IAsyncDisposable`` () =
     let disposed = ref 0
 
     let ts = taskSeq {
@@ -70,7 +70,7 @@ let ``CE task: Using when type implements IDisposable and IAsyncDisposable`` ()
     |> Task.map (fun _ -> disposed.Value |> should equal -1) // should prefer IAsyncDisposable, which returns -1
 
 [<Fact>]
-let ``CE task: Using! when type implements IDisposable`` () =
+let ``CE taskSeq: Using! when type implements IDisposable`` () =
     let disposed = ref false
 
     let ts = taskSeq {
@@ -82,7 +82,7 @@ let ``CE task: Using! when type implements IDisposable`` () =
     |> Task.map (fun _ -> disposed.Value |> should be True)
 
 [<Fact>]
-let ``CE task: Using! when type implements IAsyncDisposable`` () =
+let ``CE taskSeq: Using! when type implements IAsyncDisposable`` () =
     let disposed = ref false
 
     let ts = taskSeq {
@@ -94,7 +94,7 @@ let ``CE task: Using! when type implements IAsyncDisposable`` () =
     |> Task.map (fun _ -> disposed.Value |> should be True)
 
 [<Fact>]
-let ``CE task: Using! when type implements IDisposable and IAsyncDisposable`` () =
+let ``CE taskSeq: Using! when type implements IDisposable and IAsyncDisposable`` () =
     let disposed = ref 0
 
     let ts = taskSeq {

src/FSharp.Control.TaskSeq.Test/TestUtils.fs

@@ -136,11 +136,13 @@ type DummyTaskFactory(µsecMin: int64<µs>, µsecMax: int64<µs>) =
 
 [<AutoOpen>]
 module TestUtils =
+    /// Verifies that a task sequence is empty by converting to an array and checking emptiness.
     let verifyEmpty ts =
         ts
         |> TaskSeq.toArrayAsync
         |> Task.map (Array.isEmpty >> should be True)
 
+    /// Verifies that a task sequence contains integers 1-10, by converting to an array and comparing.
     let verify1To10 ts =
         ts
         |> TaskSeq.toArrayAsync

src/FSharp.Control.TaskSeq/Utils.fs

@@ -28,6 +28,16 @@ module ValueTask =
     /// Creates a ValueTask with an IValueTaskSource representing the operation
     let inline ofIValueTaskSource taskSource version = ValueTask<bool>(taskSource, version)
 
+    /// Creates a ValueTask form a Task<'T>
+    let inline ofTask (task: Task<'T>) = ValueTask<'T>(task)
+
+    /// Ignore a ValueTask<'T>, returns a non-generic ValueTask.
+    let inline ignore (vtask: ValueTask<'T>) =
+        if vtask.IsCompleted then
+            ValueTask()
+        else
+            ValueTask(vtask.AsTask())
+
 module Task =
     /// Convert an Async<'T> into a Task<'T>
     let inline ofAsync (async: Async<'T>) = task { return! async }
@@ -41,22 +51,16 @@ module Task =
     /// Convert a Task<'T> into an Async<'T>
     let inline toAsync (task: Task<'T>) = Async.AwaitTask task
 
-    /// Convert a Task<unit> into a Task
-    let inline toTask (task: Task<unit>) = task :> Task
-
     /// Convert a Task<'T> into a ValueTask<'T>
     let inline toValueTask (task: Task<'T>) = ValueTask<'T> task
 
-    /// Convert a Task<unit> into a non-generic ValueTask
-    let inline toIgnoreValueTask (task: Task<unit>) = ValueTask(task :> Task)
-
     /// <summary>
     /// Convert a ValueTask&lt;'T> to a Task&lt;'T>. To use a non-generic ValueTask,
     /// consider using: <paramref name="myValueTask |> Task.ofValueTask |> Task.ofTask" />.
     /// </summary>
     let inline ofValueTask (valueTask: ValueTask<'T>) = task { return! valueTask }
 
-    /// Convert a Task<'T> into a Task, ignoring the result
+    /// Convert a Task<'T> into a non-generic Task, ignoring the result
     let inline ignore (task: Task<'T>) =
         TaskBuilder.task {
             let! _ = task