Fantomas format

Author: gfix

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

@@ -27,19 +27,29 @@ module EmptySeq =
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-chunkBySize(1) has no effect on empty input`` variant =
         // no `task` block needed
-        Gen.getEmptyVariant variant |> TaskSeq.chunkBySize 1 |> verifyEmpty
+        Gen.getEmptyVariant variant
+        |> TaskSeq.chunkBySize 1
+        |> verifyEmpty
 
     [<Theory; ClassData(typeof<TestEmptyVariants>)>]
     let ``TaskSeq-chunkBySize(99) has no effect on empty input`` variant =
         // no `task` block needed
-        Gen.getEmptyVariant variant |> TaskSeq.chunkBySize 99 |> verifyEmpty
+        Gen.getEmptyVariant variant
+        |> TaskSeq.chunkBySize 99
+        |> verifyEmpty
 
     [<Fact>]
     let ``TaskSeq-chunkBySize(-1) should throw ArgumentException on any input`` () =
-        fun () -> TaskSeq.empty<int> |> TaskSeq.chunkBySize -1 |> consumeTaskSeq
+        fun () ->
+            TaskSeq.empty<int>
+            |> TaskSeq.chunkBySize -1
+            |> consumeTaskSeq
         |> should throwAsyncExact typeof<ArgumentException>
 
-        fun () -> TaskSeq.init 10 id |> TaskSeq.chunkBySize -1 |> consumeTaskSeq
+        fun () ->
+            TaskSeq.init 10 id
+            |> TaskSeq.chunkBySize -1
+            |> consumeTaskSeq
         |> should throwAsyncExact typeof<ArgumentException>
 
     [<Fact>]
@@ -123,7 +133,7 @@ module SideEffects =
         Gen.getSeqWithSideEffect variant
         |> TaskSeq.chunkBySize 5
         |> TaskSeq.toArrayAsync
-        |> Task.map (shouldEqual [| [| 1 .. 5 |]; [| 6 .. 10 |] |])
+        |> Task.map (shouldEqual [| [| 1..5 |]; [| 6..10 |] |])
 
     [<Fact>]
     let ``TaskSeq-chunkBySize prove we execute empty-seq side-effects`` () = task {
@@ -173,13 +183,29 @@ module SideEffects =
         let ts = Gen.getSeqWithSideEffect variant
         let mutable sum = 0
 
-        do! TaskSeq.chunkBySize 1 ts |> TaskSeq.collect TaskSeq.ofArray |> TaskSeq.iter (fun item -> sum <- sum + item)
-        do! TaskSeq.chunkBySize 2 ts |> TaskSeq.collect TaskSeq.ofArray |> TaskSeq.iter (fun item -> sum <- sum + item)
-        do! TaskSeq.chunkBySize 3 ts |> TaskSeq.collect TaskSeq.ofArray |> TaskSeq.iter (fun item -> sum <- sum + item)
-        do! TaskSeq.chunkBySize 4 ts |> TaskSeq.collect TaskSeq.ofArray |> TaskSeq.iter (fun item -> sum <- sum + item)
+        do!
+            TaskSeq.chunkBySize 1 ts
+            |> TaskSeq.collect TaskSeq.ofArray
+            |> TaskSeq.iter (fun item -> sum <- sum + item)
+
+        do!
+            TaskSeq.chunkBySize 2 ts
+            |> TaskSeq.collect TaskSeq.ofArray
+            |> TaskSeq.iter (fun item -> sum <- sum + item)
+
+        do!
+            TaskSeq.chunkBySize 3 ts
+            |> TaskSeq.collect TaskSeq.ofArray
+            |> TaskSeq.iter (fun item -> sum <- sum + item)
+
+        do!
+            TaskSeq.chunkBySize 4 ts
+            |> TaskSeq.collect TaskSeq.ofArray
+            |> TaskSeq.iter (fun item -> sum <- sum + item)
 
         sum |> should equal 820 // side-effected tasks, so 'item' DOES CHANGE, each next iteration starts 10 higher
     }
+
     [<Fact>]
     let ``TaskSeq-chunkBySize prove that an exception from the taskSeq is thrown`` () =
         let items = taskSeq {

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -1098,8 +1098,10 @@ module internal TaskSeqInternal =
 
         }
 
-    let chunkBySize chunkSize (source: TaskSeq<'T>): TaskSeq<'T[]> =
-        if chunkSize < 1 then invalidArg (nameof chunkSize) $"The value must be positive, but was %i{chunkSize}."
+    let chunkBySize chunkSize (source: TaskSeq<'T>) : TaskSeq<'T[]> =
+        if chunkSize < 1 then
+            invalidArg (nameof chunkSize) $"The value must be positive, but was %i{chunkSize}."
+
         checkNonNull (nameof source) source
 
         taskSeq {
@@ -1110,14 +1112,17 @@ module internal TaskSeqInternal =
 
             if step then
                 let buffer = ResizeArray<_>()
+
                 while go do
                     buffer.Add e.Current
+
                     if buffer.Count = chunkSize then
                         yield buffer.ToArray()
                         buffer.Clear()
 
                     let! step = e.MoveNextAsync()
                     go <- step
+
                 if buffer.Count > 0 then
                     yield buffer.ToArray()
         }