Apply review comments

Co-Authored-By: Abel Braaksma <abel.online@xs4all.nl>

Author: bartelink

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

@@ -22,15 +22,15 @@ let ``CE taskSeq: use 'do!' with a task<unit>`` () =
     |> Task.map (fun _ -> value |> should equal 1)
 
 [<Fact>]
-let ``CE taskSeq: use 'do!' with a valueTask<unit>`` () =
+let ``CE taskSeq: use 'do!' with a ValueTask<unit>`` () =
     let mutable value = 0
 
     taskSeq { do! ValueTask.ofTask (task { do value <- value + 1 }) }
     |> verifyEmpty
     |> Task.map (fun _ -> value |> should equal 1)
 
 [<Fact>]
-let ``CE taskSeq: use 'do!' with a non-generic valueTask`` () =
+let ``CE taskSeq: use 'do!' with a non-generic ValueTask`` () =
     let mutable value = 0
 
     taskSeq { do! ValueTask(task { do value <- value + 1 }) }
@@ -92,8 +92,8 @@ let ``CE taskSeq: use 'do!' with all kinds of overloads at once`` () =
         do! task { do value <- value + 1 } |> Task.ignore
         do! ValueTask <| task { do value <- value + 1 }
         do! ValueTask.ofTask (task { do value <- value + 1 })
-        do! ValueTask<_>(()) // unit valueTask that completes immediately
-        do! Task.fromResult () // unit Task that completes immediately
+        do! ValueTask<_>(()) // unit ValueTask that completes immediately
+        do! Task.fromResult (()) // unit Task that completes immediately
         do! Task.Delay 0
         do! Async.Sleep 0
         do! async { value <- value + 1 } // eq 4

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

@@ -40,7 +40,7 @@ let ``CE taskSeq: use 'let!' with a task<string>`` () =
     |> Task.map (should equal "test")
 
 [<Fact>]
-let ``CE taskSeq: use 'let!' with a valueTask<unit>`` () =
+let ``CE taskSeq: use 'let!' with a ValueTask<unit>`` () =
     let mutable value = 0
 
     taskSeq {
@@ -51,7 +51,7 @@ let ``CE taskSeq: use 'let!' with a valueTask<unit>`` () =
     |> Task.map (fun _ -> value |> should equal 1)
 
 [<Fact>]
-let ``CE taskSeq: use 'let!' with a valueTask<string>`` () =
+let ``CE taskSeq: use 'let!' with a ValueTask<string>`` () =
     taskSeq {
         let! test = ValueTask.ofTask (task { return "test" })
         yield test
@@ -60,7 +60,7 @@ let ``CE taskSeq: use 'let!' with a valueTask<string>`` () =
     |> Task.map (should equal "test")
 
 [<Fact>]
-let ``CE taskSeq: use 'let!' with a non-generic valueTask`` () =
+let ``CE taskSeq: use 'let!' with a non-generic ValueTask`` () =
     let mutable value = 0
 
     taskSeq {
@@ -135,7 +135,7 @@ let ``CE taskSeq: use 'let!' with all kinds of overloads at once`` () =
             }
             |> ValueTask<int>
 
-        let! c = ValueTask<_>(4) // valueTask that completes immediately
+        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 99 // normal Task that completes immediately
         let! _ = Async.Sleep 0 // unit Async

src/FSharp.Control.TaskSeq.Test/TaskSeq.StateTransitionBug.Tests.CE.fs

@@ -32,16 +32,16 @@ let ``CE empty taskSeq with MoveNextAsync -- typed`` variant = task {
 [<Theory; ClassData(typeof<TestEmptyVariants>)>]
 let ``CE  empty taskSeq, GetAsyncEnumerator multiple times`` variant = task {
     let tskSeq = Gen.getEmptyVariant variant
-    use _e = tskSeq.GetAsyncEnumerator()
-    use _e = tskSeq.GetAsyncEnumerator()
-    use _e = tskSeq.GetAsyncEnumerator()
+    use _ = tskSeq.GetAsyncEnumerator()
+    use _ = tskSeq.GetAsyncEnumerator()
+    use _ = tskSeq.GetAsyncEnumerator()
     ()
 }
 
 [<Theory; ClassData(typeof<TestEmptyVariants>)>]
 let ``CE  empty taskSeq, GetAsyncEnumerator multiple times and then MoveNextAsync`` variant = task {
     let tskSeq = Gen.getEmptyVariant variant
-    use _enumerator = tskSeq.GetAsyncEnumerator()
+    use _ = tskSeq.GetAsyncEnumerator()
     use enumerator = tskSeq.GetAsyncEnumerator()
     do! Assert.moveNextAndCheck false enumerator
 }