Merge branch 'master' of github.com:rescript-lang/rescript-lang.org into vlk/add-prettier

Author: jderochervlk

.vscode/extensions.json

@@ -1,6 +1,3 @@
 {
-    "recommendations": [
-      "esbenp.prettier-vscode",
-      "chenglou92.rescript-vscode"
-    ]
-}
+  "recommendations": ["esbenp.prettier-vscode", "chenglou92.rescript-vscode"]
+}

_blogposts/2023-09-18-uncurried-mode.mdx

@@ -32,6 +32,7 @@ This comes at a price though. Here are some examples to show the drawbacks of cu
 
 - Errors because of changed function signatures have their impact at the use site. Consider this example, where the signature of the onChange function is extended with
   a labeled argument
+
   ```diff
     @react.component
   -  let make = (~onChange: string => option<unit => unit>) => {
@@ -45,6 +46,7 @@ This comes at a price though. Here are some examples to show the drawbacks of cu
       })
     }
   ```
+
 - If you wanted explicitly uncurry a function, you needed to annotate it with the uncurried dot.
   ```rescript
   (. param) => ()
@@ -53,25 +55,29 @@ This comes at a price though. Here are some examples to show the drawbacks of cu
 - In the standard library (`Belt`), there are both curried and uncurried versions of the same function so you were required to think for yourself when to use the uncurried version and when only the curried one will work.
 - In combination with `ignore` / `let _ = ...`, curried can lead to unexpected behavior at runtime after adding a parameter to a function, because you are accidentally ignoring the result of a partial evaluation so that the function is not called at all.
   1. Have a look at this simple function. It is assigned to `_` because we ignore the resulting `string` value.
+
   ```res
   let myCurriedFn = (~first) => first
   let _ = myCurriedFn(~first="Hello!")
   //  ^ string
   ```
 
   2. Now the function got a second parameter `~second`. Here, the resulting value is a function, which means it is not fully applied and thus never executed.
+
   ```res
   let myCurriedFn = (~first, ~second) => first ++ " " ++ second
   let _ = myCurriedFn(~first="Hello!")
   //  ^ (~second: string) => string
   ```
 
   3. One way to prevent such errors is to annotate the underscore with the function's return type:
+
   ```res
   let _: string = myCurriedFn(~first="Hello!")
   ```
 
   4. However, the same issue arises when using the built-in ignore function, which cannot be annotated:
+
   ```res
   myCurriedFn(~first="Hello!")->ignore
   ```