Reformat all source files

Author: abelbraaksma

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

@@ -127,7 +127,7 @@ let ``CE taskSeq: use 'let!' with all kinds of overloads at once`` () =
             return value
         }
 
-        let! b =  // eq 2
+        let! b = // eq 2
             task {
                 do! Task.Delay 50
                 do value <- value + 1

src/FSharp.Control.TaskSeq/TaskSeqBuilder.fs

@@ -80,6 +80,7 @@ type TaskSeqStateMachineData<'T>() =
     member data.PushDispose(disposer: unit -> Task) =
         if isNull data.disposalStack then
             data.disposalStack <- ResizeArray()
+
         data.disposalStack.Add disposer
 
     member data.PopDispose() =

src/FSharp.Control.TaskSeq/TaskSeqBuilder.fsi

@@ -134,8 +134,10 @@ type TaskSeqBuilder =
     member inline TryFinally: body: ResumableTSC<'T> * compensationAction: (unit -> unit) -> ResumableTSC<'T>
     member inline TryFinallyAsync: body: ResumableTSC<'T> * compensationAction: (unit -> Task) -> ResumableTSC<'T>
     member inline TryWith: body: ResumableTSC<'T> * catch: (exn -> ResumableTSC<'T>) -> ResumableTSC<'T>
+
     member inline Using:
         disp: 'Disp * body: ('Disp -> ResumableTSC<'T>) -> ResumableTSC<'T> when 'Disp :> IAsyncDisposable
+
     member inline While: condition: (unit -> bool) * body: ResumableTSC<'T> -> ResumableTSC<'T>
     /// Used by `For`. F# currently doesn't support `while!`, so this cannot be called directly from the CE
     member inline WhileAsync: condition: (unit -> ValueTask<bool>) * body: ResumableTSC<'T> -> ResumableTSC<'T>
@@ -179,6 +181,7 @@ module MediumPriority =
         // NOTE: syntax with '#Disposable' won't work properly in FSI
         member inline Using:
             dispensation: 'Disp * body: ('Disp -> ResumableTSC<'T>) -> ResumableTSC<'T> when 'Disp :> IDisposable
+
         member inline For: sequence: seq<'TElement> * body: ('TElement -> ResumableTSC<'T>) -> ResumableTSC<'T>
         member inline YieldFrom: source: seq<'T> -> ResumableTSC<'T>
         member inline For: source: #taskSeq<'TElement> * body: ('TElement -> ResumableTSC<'T>) -> ResumableTSC<'T>

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -120,15 +120,15 @@ module internal TaskSeqInternal =
                     i <- i + 1 // update before moving: we are counting, not indexing
                     go <- step
 
-            | Some (Predicate predicate) ->
+            | Some(Predicate predicate) ->
                 while go do
                     if predicate e.Current then
                         i <- i + 1
 
                     let! step = e.MoveNextAsync()
                     go <- step
 
-            | Some (PredicateAsync predicate) ->
+            | Some(PredicateAsync predicate) ->
                 while go do
                     match! predicate e.Current with
                     | true -> i <- i + 1
@@ -197,7 +197,7 @@ module internal TaskSeqInternal =
                 // multiple threads access the same item through the same enumerator (which is
                 // bad practice, but hey, who're we to judge).
                 if isNull value then
-                    value <- Lazy<_>.Create (fun () -> init i)
+                    value <- Lazy<_>.Create(fun () -> init i)
 
                 yield value.Force()
                 value <- Unchecked.defaultof<_>

src/FSharp.Control.TaskSeq/Utils.fs

@@ -74,18 +74,16 @@ module Task =
         :> Task
 
     /// Map a Task<'T>
-    let inline map mapper (task: Task<'T>) : Task<'U> =
-        TaskBuilder.task {
-            let! result = task
-            return mapper result
-        }
+    let inline map mapper (task: Task<'T>) : Task<'U> = TaskBuilder.task {
+        let! result = task
+        return mapper result
+    }
 
     /// Bind a Task<'T>
-    let inline bind binder (task: Task<'T>) : Task<'U> =
-        TaskBuilder.task {
-            let! t = task
-            return! binder t
-        }
+    let inline bind binder (task: Task<'T>) : Task<'U> = TaskBuilder.task {
+        let! t = task
+        return! binder t
+    }
 
     /// Create a task from a value
     let inline fromResult (value: 'U) : Task<'U> = TaskBuilder.task { return value }
@@ -107,11 +105,10 @@ module Async =
     }
 
     /// Map an Async<'T>
-    let inline map mapper (async: Async<'T>) : Async<'U> =
-        ExtraTopLevelOperators.async {
-            let! result = async
-            return mapper result
-        }
+    let inline map mapper (async: Async<'T>) : Async<'U> = ExtraTopLevelOperators.async {
+        let! result = async
+        return mapper result
+    }
 
     /// Bind an Async<'T>
     let inline bind binder (task: Async<'T>) : Async<'U> = ExtraTopLevelOperators.async { return! binder task }