Format the world

TheAngryByrd · TheAngryByrd · commit 1998b988e912 · 2025-02-15T18:08:22.000-05:00
diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
@@ -17,7 +17,7 @@
       "rollForward": false
     },
     "fantomas": {
-      "version": "6.3.16",
+      "version": "7.0.0",
       "commands": [
         "fantomas"
       ],
diff --git a/.fantomasignore b/.fantomasignore
@@ -1,5 +1,3 @@
 AssemblyInfo.fs
-src/FsToolkit.ErrorHandling/Nullness.fs
 tests/FsToolkit.ErrorHandling.AsyncSeq.Tests/Main.fs
-tests/FsToolkit.ErrorHandling.Tests/Main.fs
-tests/FsToolkit.ErrorHandling.Tests/TestHelpers.fs
+tests/FsToolkit.ErrorHandling.Tests/Main.fs
diff --git a/build/build.fs b/build/build.fs
@@ -146,7 +146,7 @@ let formatCode _ =
         Trace.traceErrorfn "Errors while formatting all files: %A" result.Messages
 
 let analyze _ =
-    let analyzerPaths = !! "packages/analyzers/**/analyzers/dotnet/fs"
+    let analyzerPaths = !!"packages/analyzers/**/analyzers/dotnet/fs"
 
     let createArgsForProject (project: string) analyzerPaths =
         let projectName = Path.GetFileNameWithoutExtension project
@@ -162,7 +162,7 @@ let analyze _ =
         ]
         |> String.concat " "
 
-    !! "src/**/*.fsproj"
+    !!"src/**/*.fsproj"
     |> Seq.iter (fun fsproj ->
         let result =
             createArgsForProject fsproj analyzerPaths
@@ -187,7 +187,7 @@ let checkFormatCode _ =
 
 
 let clean _ =
-    !! "bin"
+    !!"bin"
     ++ "benchmarks/**/bin"
     ++ "src/**/bin"
     ++ "tests/**/bin"
diff --git a/src/FsToolkit.ErrorHandling.IcedTasks/CancellableTaskValidationCE.fs b/src/FsToolkit.ErrorHandling.IcedTasks/CancellableTaskValidationCE.fs
@@ -236,10 +236,8 @@ module AsyncExtensions =
             this.ReturnFrom(Async.AwaitCancellableTask t)
 
         member inline this.Bind
-            ([<InlineIfLambda>] t: CancellableTask, [<InlineIfLambda>] binder: (unit -> Async<'U>)) : Async<
-                                                                                                          'U
-                                                                                                       >
-            =
+            ([<InlineIfLambda>] t: CancellableTask, [<InlineIfLambda>] binder: (unit -> Async<'U>))
+            : Async<'U> =
             this.Bind(Async.AwaitCancellableTask t, binder)
 
         member inline this.ReturnFrom([<InlineIfLambda>] t: CancellableTask) : Async<unit> =
diff --git a/src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs b/src/FsToolkit.ErrorHandling.JobResult/JobResultCE.fs
@@ -58,13 +58,8 @@ module JobResultCE =
             Job.tryWithDelay computation handler
 
         member inline _.TryFinally
-            (computation: Job<Result<'T, 'TError>>, [<InlineIfLambda>] compensation: unit -> unit) : Job<
-                                                                                                         Result<
-                                                                                                             'T,
-                                                                                                             'TError
-                                                                                                          >
-                                                                                                      >
-            =
+            (computation: Job<Result<'T, 'TError>>, [<InlineIfLambda>] compensation: unit -> unit)
+            : Job<Result<'T, 'TError>> =
             Job.tryFinallyFun computation compensation
 
         member inline _.TryFinally
diff --git a/src/FsToolkit.ErrorHandling/AsyncOptionCE.fs b/src/FsToolkit.ErrorHandling/AsyncOptionCE.fs
@@ -43,10 +43,8 @@ module AsyncOptionCE =
             async.TryFinally(computation, compensation)
 #if !FABLE_COMPILER
         member inline _.TryFinallyAsync
-            (computation: Async<'value option>, [<InlineIfLambda>] compensation: unit -> ValueTask) : Async<
-                                                                                                          'value option
-                                                                                                       >
-            =
+            (computation: Async<'value option>, [<InlineIfLambda>] compensation: unit -> ValueTask)
+            : Async<'value option> =
             let compensation =
                 async {
                     let vTask = compensation ()
diff --git a/src/FsToolkit.ErrorHandling/AsyncResultCE.fs b/src/FsToolkit.ErrorHandling/AsyncResultCE.fs
@@ -46,13 +46,8 @@ module AsyncResultCE =
             async.TryWith(computation, handler)
 
         member inline _.TryFinally
-            (computation: Async<Result<'ok, 'error>>, [<InlineIfLambda>] compensation: unit -> unit) : Async<
-                                                                                                           Result<
-                                                                                                               'ok,
-                                                                                                               'error
-                                                                                                            >
-                                                                                                        >
-            =
+            (computation: Async<Result<'ok, 'error>>, [<InlineIfLambda>] compensation: unit -> unit)
+            : Async<Result<'ok, 'error>> =
             async.TryFinally(computation, compensation)
 #if !FABLE_COMPILER
         member inline _.TryFinallyAsync
diff --git a/src/FsToolkit.ErrorHandling/AsyncResultOptionCE.fs b/src/FsToolkit.ErrorHandling/AsyncResultOptionCE.fs
@@ -80,11 +80,8 @@ module AsyncResultOptionCE =
 #endif
 
         member inline this.While
-            ([<InlineIfLambda>] guard: unit -> bool, computation: AsyncResultOption<unit, 'error>) : AsyncResultOption<
-                                                                                                         unit,
-                                                                                                         'error
-                                                                                                      >
-            =
+            ([<InlineIfLambda>] guard: unit -> bool, computation: AsyncResultOption<unit, 'error>)
+            : AsyncResultOption<unit, 'error> =
             if guard () then
                 let mutable whileAsync = Unchecked.defaultof<_>
 
@@ -152,11 +149,8 @@ module AsyncResultOptionCEExtensions =
 
 
         member inline this.For
-            (sequence: #seq<'ok>, [<InlineIfLambda>] binder: 'ok -> AsyncResultOption<unit, 'error>) : AsyncResultOption<
-                                                                                                           unit,
-                                                                                                           'error
-                                                                                                        >
-            =
+            (sequence: #seq<'ok>, [<InlineIfLambda>] binder: 'ok -> AsyncResultOption<unit, 'error>)
+            : AsyncResultOption<unit, 'error> =
             this.Using(
                 sequence.GetEnumerator(),
                 fun enum ->
diff --git a/src/FsToolkit.ErrorHandling/AsyncValidationCE.fs b/src/FsToolkit.ErrorHandling/AsyncValidationCE.fs
@@ -28,11 +28,8 @@ module AsyncValidationCE =
             async.Delay generator
 
         member inline this.Combine
-            (validation1: AsyncValidation<unit, 'error>, validation2: AsyncValidation<'ok, 'error>) : AsyncValidation<
-                                                                                                          'ok,
-                                                                                                          'error
-                                                                                                       >
-            =
+            (validation1: AsyncValidation<unit, 'error>, validation2: AsyncValidation<'ok, 'error>)
+            : AsyncValidation<'ok, 'error> =
             this.Bind(validation1, (fun () -> validation2))
 
         member inline _.TryWith
@@ -71,11 +68,8 @@ module AsyncValidationCE =
 
 
         member inline this.For
-            (sequence: #seq<'ok>, [<InlineIfLambda>] binder: 'ok -> AsyncValidation<unit, 'error>) : AsyncValidation<
-                                                                                                         unit,
-                                                                                                         'error
-                                                                                                      >
-            =
+            (sequence: #seq<'ok>, [<InlineIfLambda>] binder: 'ok -> AsyncValidation<unit, 'error>)
+            : AsyncValidation<unit, 'error> =
             this.Using(
                 sequence.GetEnumerator(),
                 fun enum -> this.While(enum.MoveNext, this.Delay(fun () -> binder enum.Current))
diff --git a/src/FsToolkit.ErrorHandling/Nullness.fs b/src/FsToolkit.ErrorHandling/Nullness.fs
@@ -1,23 +1,24 @@
 namespace FsToolkit.ErrorHandling
+
 open System
 
 type ExceptionNull =
-    #if NET9_0_OR_GREATER && !FABLE_COMPILER
-        Exception | null
-    #else
-        Exception
-    #endif
+#if NET9_0_OR_GREATER && !FABLE_COMPILER
+    Exception | null
+#else
+    Exception
+#endif
 
 type IDisposableNull =
-    #if NET9_0_OR_GREATER && !FABLE_COMPILER
-        IDisposable | null
-    #else
-        IDisposable
-    #endif
+#if NET9_0_OR_GREATER && !FABLE_COMPILER
+    IDisposable | null
+#else
+    IDisposable
+#endif
 
 type IAsyncDisposableNull =
-    #if NET9_0_OR_GREATER && !FABLE_COMPILER
-        IAsyncDisposable | null
-    #else
-        IAsyncDisposable
-    #endif
+#if NET9_0_OR_GREATER && !FABLE_COMPILER
+    IAsyncDisposable | null
+#else
+    IAsyncDisposable
+#endif
diff --git a/src/FsToolkit.ErrorHandling/ResultCE.fs b/src/FsToolkit.ErrorHandling/ResultCE.fs
@@ -30,11 +30,8 @@ module ResultCE =
             generator ()
 
         member inline this.Combine
-            (result: Result<unit, 'error>, [<InlineIfLambda>] binder: unit -> Result<'ok, 'error>) : Result<
-                                                                                                         'ok,
-                                                                                                         'error
-                                                                                                      >
-            =
+            (result: Result<unit, 'error>, [<InlineIfLambda>] binder: unit -> Result<'ok, 'error>)
+            : Result<'ok, 'error> =
             this.Bind(result, binder)
 
         member inline this.TryWith
@@ -58,11 +55,8 @@ module ResultCE =
                 compensation ()
 
         member inline this.Using
-            (resource: 'disposable :> IDisposableNull, binder: 'disposable -> Result<'ok, 'error>) : Result<
-                                                                                                         'ok,
-                                                                                                         'error
-                                                                                                      >
-            =
+            (resource: 'disposable :> IDisposableNull, binder: 'disposable -> Result<'ok, 'error>)
+            : Result<'ok, 'error> =
             this.TryFinally(
                 (fun () -> binder resource),
                 (fun () ->
diff --git a/src/FsToolkit.ErrorHandling/TaskResultCE.fs b/src/FsToolkit.ErrorHandling/TaskResultCE.fs
@@ -84,12 +84,8 @@ type TaskResultBuilderBase() =
 
     /// Builds a step that executes the body while the condition predicate is true.
     member inline _.While
-        ([<InlineIfLambda>] condition: unit -> bool, body: TaskResultCode<'TOverall, 'Error, unit>) : TaskResultCode<
-                                                                                                          'TOverall,
-                                                                                                          'Error,
-                                                                                                          unit
-                                                                                                       >
-        =
+        ([<InlineIfLambda>] condition: unit -> bool, body: TaskResultCode<'TOverall, 'Error, unit>)
+        : TaskResultCode<'TOverall, 'Error, unit> =
         let mutable keepGoing = true
 
         ResumableCode.While(
@@ -121,12 +117,8 @@ type TaskResultBuilderBase() =
     /// Wraps a step in a try/finally. This catches exceptions both in the evaluation of the function
     /// to retrieve the step, and in the continuation of the step (if any).
     member inline _.TryFinally
-        (body: TaskResultCode<'TOverall, 'Error, 'T>, [<InlineIfLambda>] compensation: unit -> unit) : TaskResultCode<
-                                                                                                           'TOverall,
-                                                                                                           'Error,
-                                                                                                           'T
-                                                                                                        >
-        =
+        (body: TaskResultCode<'TOverall, 'Error, 'T>, [<InlineIfLambda>] compensation: unit -> unit)
+        : TaskResultCode<'TOverall, 'Error, 'T> =
 
         // printfn "TryFinally Called --> "
 
diff --git a/src/FsToolkit.ErrorHandling/ValidationCE.fs b/src/FsToolkit.ErrorHandling/ValidationCE.fs
@@ -96,11 +96,8 @@ module ValidationCE =
             )
 
         member inline _.BindReturn
-            (input: Validation<'okInput, 'error>, [<InlineIfLambda>] mapper: 'okInput -> 'okOutput) : Validation<
-                                                                                                          'okOutput,
-                                                                                                          'error
-                                                                                                       >
-            =
+            (input: Validation<'okInput, 'error>, [<InlineIfLambda>] mapper: 'okInput -> 'okOutput)
+            : Validation<'okOutput, 'error> =
             Validation.map mapper input
 
         member inline _.MergeSources
diff --git a/tests/FsToolkit.ErrorHandling.Tests/OptionCE.fs b/tests/FsToolkit.ErrorHandling.Tests/OptionCE.fs
@@ -20,7 +20,6 @@ let makeDisposable () =
     }
 
 
-
 // type 'a option = | Some of 'a | None
 
 let ceTests =
@@ -207,7 +206,7 @@ let ceTests =
             let data = 42
 
             let actual =
-                option { 
+                option {
                     for i in [ 1..10 ] do
                         ()
 
@@ -322,7 +321,10 @@ type CustomClass(x: int) =
 
 #if NET9_0_OR_GREATER && !FABLE_COMPILER
 
-type AB = A | B
+type AB =
+    | A
+    | B
+
 type AbNull = AB | null
 
 #endif
@@ -337,18 +339,19 @@ let ``OptionCE inference checks`` =
             f (Some())
             |> ignore
 #if NET9_0_OR_GREATER && !FABLE_COMPILER
-        testCase "Nullable argument should be inferred" <| fun () ->
+        testCase "Nullable argument should be inferred"
+        <| fun () ->
             // Compilation is real success
-            let y (p : AbNull) =
+            let y (p: AbNull) =
                 option {
                     let! p = p
                     let isa = p.IsA
                     return isa
                 }
-            
+
             Expect.equal (y A) (Some true) ""
 #endif
-    ] 
+    ]
 
 let allTests =
     testList "Option CE tests" [
diff --git a/tests/FsToolkit.ErrorHandling.Tests/TestHelpers.fs b/tests/FsToolkit.ErrorHandling.Tests/TestHelpers.fs
@@ -13,15 +13,15 @@ module TestHelpers =
         }
 
 type MemoryStreamNull =
-    #if NET9_0_OR_GREATER && !FABLE_COMPILER
-        System.IO.MemoryStream | null
-    #else
-        System.IO.MemoryStream
-    #endif
+#if NET9_0_OR_GREATER && !FABLE_COMPILER
+    System.IO.MemoryStream | null
+#else
+    System.IO.MemoryStream
+#endif
 
 type UriNull =
-    #if NET9_0_OR_GREATER && !FABLE_COMPILER
-        System.Uri | null
-    #else
-        System.Uri
-    #endif
+#if NET9_0_OR_GREATER && !FABLE_COMPILER
+    System.Uri | null
+#else
+    System.Uri
+#endif
diff --git a/tests/FsToolkit.ErrorHandling.Tests/ValueOptionCE.fs b/tests/FsToolkit.ErrorHandling.Tests/ValueOptionCE.fs
@@ -327,7 +327,10 @@ type CustomClass(x: int) =
 
 #if NET9_0_OR_GREATER && !FABLE_COMPILER
 
-type AB = A | B
+type AB =
+    | A
+    | B
+
 type AbNull = AB | null
 
 #endif
