remove deprecated ref cells

Author: TheAngryByrd

tests/FsToolkit.ErrorHandling.JobResult.Tests/JobResult.fs

@@ -500,31 +500,28 @@ let teeTests =
     testList "JobResult.tee Tests" [
         testCase "tee executes the function for ok"
         <| fun _ ->
-            let foo = ref "foo"
-            let input = ref 0
+            let mutable foo = "foo"
+            let mutable input = 0
 
             let bar x =
-                input := x
+                input <- x
 
-                foo
-                := "bar"
+                foo <- "bar"
 
             let result = JobResult.tee bar (toJob (Ok 42))
             Expect.hasJobOkValueSync 42 result
-            Expect.equal !foo "bar" ""
-            Expect.equal !input 42 ""
+            Expect.equal foo "bar" ""
+            Expect.equal input 42 ""
 
         testCase "tee ignores the function for Error"
         <| fun _ ->
-            let foo = ref "foo"
+            let mutable foo = "foo"
 
-            let bar _ =
-                foo
-                := "bar"
+            let bar _ = foo <- "bar"
 
             let result = JobResult.tee bar (toJob (Error err))
             Expect.hasJobErrorValueSync err result
-            Expect.equal !foo "foo" ""
+            Expect.equal foo "foo" ""
     ]
 
 let returnTrue _ = true
@@ -535,54 +532,48 @@ let teeIfTests =
     testList "JobResult.teeIf Tests" [
         testCase "teeIf executes the function for ok and true predicate "
         <| fun _ ->
-            let foo = ref "foo"
-            let input = ref 0
-            let pInput = ref 0
+            let mutable foo = "foo"
+            let mutable input = 0
+            let mutable pInput = 0
 
             let returnTrue x =
-                pInput
-                := x
+                pInput <- x
 
                 true
 
             let bar x =
-                input := x
+                input <- x
 
-                foo
-                := "bar"
+                foo <- "bar"
 
             let result = JobResult.teeIf returnTrue bar (toJob (Ok 42))
 
             Expect.hasJobOkValueSync 42 result
-            Expect.equal !foo "bar" ""
-            Expect.equal !input 42 ""
-            Expect.equal !pInput 42 ""
+            Expect.equal foo "bar" ""
+            Expect.equal input 42 ""
+            Expect.equal pInput 42 ""
 
         testCase "teeIf ignores the function for Ok and false predicate"
         <| fun _ ->
-            let foo = ref "foo"
+            let mutable foo = "foo"
 
-            let bar _ =
-                foo
-                := "bar"
+            let bar _ = foo <- "bar"
 
             let result = JobResult.teeIf returnFalse bar (toJob (Ok 42))
 
             Expect.hasJobOkValueSync 42 result
-            Expect.equal !foo "foo" ""
+            Expect.equal foo "foo" ""
 
         testCase "teeIf ignores the function for Error"
         <| fun _ ->
-            let foo = ref "foo"
+            let mutable foo = "foo"
 
-            let bar _ =
-                foo
-                := "bar"
+            let bar _ = foo <- "bar"
 
             let result = JobResult.teeIf returnTrue bar (toJob (Error err))
 
             Expect.hasJobErrorValueSync err result
-            Expect.equal !foo "foo" ""
+            Expect.equal foo "foo" ""
     ]
 
 [<Tests>]
@@ -591,32 +582,29 @@ let teeErrorTests =
     testList "JobResult.teeError Tests" [
         testCase "teeError executes the function for Error"
         <| fun _ ->
-            let foo = ref "foo"
-            let input = ref ""
+            let mutable foo = "foo"
+            let mutable input = ""
 
             let bar x =
-                input := x
+                input <- x
 
-                foo
-                := "bar"
+                foo <- "bar"
 
             let result = JobResult.teeError bar (toJob (Error err))
 
             Expect.hasJobErrorValueSync err result
-            Expect.equal !foo "bar" ""
-            Expect.equal !input err ""
+            Expect.equal foo "bar" ""
+            Expect.equal input err ""
 
         testCase "teeError ignores the function for Ok"
         <| fun _ ->
-            let foo = ref "foo"
+            let mutable foo = "foo"
 
-            let bar _ =
-                foo
-                := "bar"
+            let bar _ = foo <- "bar"
 
             let result = JobResult.teeError bar (toJob (Ok 42))
             Expect.hasJobOkValueSync 42 result
-            Expect.equal !foo "foo" ""
+            Expect.equal foo "foo" ""
     ]
 
 
@@ -625,54 +613,48 @@ let teeErrorIfTests =
     testList "JobResult.teeErrorIf Tests" [
         testCase "teeErrorIf executes the function for Error and true predicate "
         <| fun _ ->
-            let foo = ref "foo"
-            let input = ref ""
-            let pInput = ref ""
+            let mutable foo = "foo"
+            let mutable input = ""
+            let mutable pInput = ""
 
             let returnTrue x =
-                pInput
-                := x
+                pInput <- x
 
                 true
 
             let bar x =
-                input := x
+                input <- x
 
-                foo
-                := "bar"
+                foo <- "bar"
 
             let result = JobResult.teeErrorIf returnTrue bar (toJob (Error err))
 
             Expect.hasJobErrorValueSync err result
-            Expect.equal !foo "bar" ""
-            Expect.equal !input err ""
-            Expect.equal !pInput err ""
+            Expect.equal foo "bar" ""
+            Expect.equal input err ""
+            Expect.equal pInput err ""
 
         testCase "teeErrorIf ignores the function for Error and false predicate"
         <| fun _ ->
-            let foo = ref "foo"
+            let mutable foo = "foo"
 
-            let bar _ =
-                foo
-                := "bar"
+            let bar _ = foo <- "bar"
 
             let result = JobResult.teeErrorIf returnFalse bar (toJob (Error err))
 
             Expect.hasJobErrorValueSync err result
-            Expect.equal !foo "foo" ""
+            Expect.equal foo "foo" ""
 
         testCase "teeErrorIf ignores the function for Ok"
         <| fun _ ->
-            let foo = ref "foo"
+            let mutable foo = "foo"
 
-            let bar _ =
-                foo
-                := "bar"
+            let bar _ = foo <- "bar"
 
             let result = JobResult.teeErrorIf returnTrue bar (toJob (Ok 42))
 
             Expect.hasJobOkValueSync 42 result
-            Expect.equal !foo "foo" ""
+            Expect.equal foo "foo" ""
     ]
 
 [<Tests>]

tests/FsToolkit.ErrorHandling.TaskResult.Tests/Expecto.fs

@@ -36,8 +36,8 @@ let ftestCaseTask name test =
 module Expect =
     open Expecto
 
-    [<RequiresExplicitTypeArguments>]
     /// Expects the passed function to throw `'texn`.
+    [<RequiresExplicitTypeArguments>]
     let throwsTAsync<'a, 'texn when 'texn :> exn> (f: Async<'a>) message = async {
         let! thrown = async {
             try