Apply review comments

Co-Authored-By: Abel Braaksma <[email protected]>

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

@@ -41,7 +41,7 @@ let ``CE  empty taskSeq, GetAsyncEnumerator multiple times`` variant = task {
 [<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
 }

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

@@ -95,20 +95,20 @@ type DummyTaskFactory(µsecMin: int64<µs>, µsecMax: int64<µs>) =
     /// <summary>
     /// Creates dummy tasks with a randomized delay and a mutable state,
     /// to ensure we properly test whether processing is done ordered or not.
-    /// Uses the defaults for <paramref name="minMs" /> and <paramref name="maxMs" />
+    /// Uses the defaults for <paramref name="µsecMin" /> and <paramref name="µsecMax" />
     /// with 10,000µs and 30,000µs respectively (or 10ms and 30ms).
     /// </summary>
     new() = DummyTaskFactory(10_000L<µs>, 30_000L<µs>)
 
     /// <summary>
     /// Creates dummy tasks with a randomized delay and a mutable state,
     /// to ensure we properly test whether processing is done ordered or not.
-    /// Values <paramref name="minMs" /> and <paramref name="maxMs" /> can be
+    /// Values <paramref name="msecMin" /> and <paramref name="msecMax" /> can be
     /// given in milliseconds.
     /// </summary>
     /// <param name="minMs">Minimum delay</param>
     /// <param name="maxMs">Maximum delay</param>
-    new(minMs: int<ms>, maxMs: int<ms>) = DummyTaskFactory(int64 minMs * 1000L<µs>, int64 maxMs * 1000L<µs>)
+    new(msecMin: int<ms>, msecMax: int<ms>) = DummyTaskFactory(int64 msecMin * 1000L<µs>, int64 msecMax * 1000L<µs>)
 
 
     /// Bunch of delayed tasks that randomly have a yielding delay of 10-30ms, therefore having overlapping execution times.
@@ -318,10 +318,10 @@ module TestUtils =
         let getEmptyVariant variant : IAsyncEnumerable<int> =
             match variant with
             | EmptyVariant.CallEmpty -> TaskSeq.empty
-            | EmptyVariant.Do -> taskSeq { do () }
+            | EmptyVariant.Do -> taskSeq { do ignore () }
             | EmptyVariant.DoBang -> taskSeq { do! task { return () } }
             | EmptyVariant.YieldBang -> taskSeq { yield! Seq.empty<int> }
-            | EmptyVariant.YieldBangNested -> taskSeq { yield! taskSeq { do () } }
+            | EmptyVariant.YieldBangNested -> taskSeq { yield! taskSeq { do ignore () } }
             | EmptyVariant.DelayDoBang -> taskSeq {
                 do! microDelay ()
                 do! microDelay ()