Fix formatting and usage of raise in F# exceptions

Follow-up to #43 from @codeconscious

Author: bartelink

docs/fsharp-cheatsheet.md

@@ -689,7 +689,7 @@ See  [Pattern Matching (MS Learn)](https://learn.microsoft.com/en-us/dotnet/fsha
 
 ## Try..With
 
-An illustrative example with: custom F# exception creation, all exception aliases, `raise()` usage, and an exhaustive demonstration of the exception handler patterns:
+An illustrative example with: custom F# exception creation, all exception aliases, `raise` usage, and an exhaustive demonstration of the exception handler patterns:
 
 ```fsharp
 open System
@@ -702,26 +702,26 @@ try
     invalidArg "ArgumentName" "Message" // throws a System.ArgumentException
     invalidOp  "Message"                // throws a System.InvalidOperation
 
-    raise(NotImplementedException("Message")) // throws a .NET exception (2)
-    raise(MyException(0, "Message"))          // throws an F# exception (2)
+    raise (NotImplementedException("Message")) // throws a .NET exception (2)
+    raise (MyException(0, "Message"))          // throws an F# exception (2)
 
     true // (3)
 with
 | :? ArgumentNullException                      -> printfn "NullException"; false // (3)
 | :? ArgumentException as ex                    -> printfn $"{ex.Message}"; false // (4)
-| :? InvalidOperationException as ex when guard -> printfn $"{ex.Message}"; reraise() // (5,6)
+| :? InvalidOperationException as ex when guard -> printfn $"{ex.Message}"; reraise () // (5,6)
 | MyException(num, str) when guard              -> printfn $"{num}, {str}"; false // (5)
-| MyException(num, str)                         -> printfn $"{num}, {str}"; reraise() // (6)
+| MyException(num, str)                         -> printfn $"{num}, {str}"; reraise () // (6)
 | ex when guard                                 -> printfn $"{ex.Message}"; false
 | ex                                            -> printfn $"{ex.Message}"; false
 ```
 
 1. define your own F# exception types with `exception`, a new type that will inherit from `System.Exception`;
-2. use `raise()` to throw an F# or .NET exception;
+2. use `raise` to throw (an F# or .NET) exception;
 3. the entire `try..with` expression must evaluate to the same type, in this example: bool;
 4. `ArgumentNullException` inherits from `ArgumentException`, so `ArgumentException` must follow after;
 5. support for `when` guards;
-6. use `reraise()` to re-throw an exception; works with both .NET and F# exceptions
+6. use `reraise ()` to re-throw the exception being handled (retaining the original throw site in the stack trace); works with both .NET and F# exceptions
 
 The difference between F# and .NET exceptions is how they are created and how they can be handled.