Merge branch 'master' of https://github.com/rescript-lang/rescript-lang.org into vlk-remove-faq-page

Author: jderochervlk

misc_docs/syntax/language_dict.mdx

@@ -0,0 +1,51 @@
+---
+id: "dict"
+keywords: ["dict"]
+name: "dict"
+summary: "This is the `dict{}` syntax"
+category: "languageconstructs"
+---
+
+> Available in v12+
+
+The `dict{}` syntax is used to represent [dictionaries](dict.md). It's used both when creating dicts, and when pattern matching on dicts.
+
+### Example
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+// Create a dict
+let d = dict{"A": 5, "B": 6, "C": 7}
+
+// Pattern match on the full dict
+let b = switch d {
+| dict{"B": b} => Some(b)
+| _ => None
+}
+
+// Destructure the dict
+let dict{"C": ?c} = d
+```
+
+```js
+let d = {
+  A: 5,
+  B: 6,
+  C: 7
+};
+
+let b = d.B;
+
+let b$1 = b !== undefined ? b : undefined;
+
+let c = d.C;
+```
+
+</CodeTab>
+
+### References
+
+* [Dictionaries](/docs/manual/latest/dict)
+
+

misc_docs/syntax/language_for.mdx

@@ -0,0 +1,45 @@
+---
+id: "for"
+keywords: ["for", "loop"]
+name: "for loop"
+summary: "This is the `for` loop."
+category: "languageconstructs"
+---
+
+ReScript supports `for` loops. 
+
+For loops can iterate from a starting value up to (and including) the ending value via the `to` keyword, or in the opposite direction via the `downto` keyword.
+
+### Example
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+// Using `to`
+for x in 1 to 3 {
+  Console.log(x)
+}
+
+// Using `downto`
+for y in 3 downto 1 {
+  Console.log(y)
+}
+```
+
+```js
+for(var x = 1; x <= 3; ++x){
+  console.log(x);
+}
+
+for(var y = 3; y >= 1; --y){
+  console.log(y);
+}
+```
+
+</CodeTab>
+
+
+### References
+
+* [For Loops](control-flow.md#for-loops)
+

misc_docs/syntax/language_while.mdx

@@ -0,0 +1,50 @@
+---
+id: "while"
+keywords: ["while", "loop"]
+name: "while loop"
+summary: "This is the `while` loop."
+category: "languageconstructs"
+---
+
+ReScript supports `while` loops. While loops execute its body code block while its condition is true. 
+
+ReScript does not have the `break` keyword, but you can easily break out of a while loop by using a mutable binding.
+
+### Example
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res
+let break = ref(false)
+
+while !break.contents {
+  if Math.random() > 0.3 {
+    break := true
+  } else {
+    Console.log("Still running")
+  }
+}
+
+```
+
+```js
+let $$break = {
+  contents: false
+};
+
+while (!$$break.contents) {
+  if (Math.random() > 0.3) {
+    $$break.contents = true;
+  } else {
+    console.log("Still running");
+  }
+};
+```
+
+</CodeTab>
+
+
+### References
+
+* [While Loops](control-flow.md#while-loops)
+

pages/docs/manual/v12.0.0/dict.mdx

@@ -0,0 +1,161 @@
+---
+title: "Dictionary"
+description: "Dictionary data structure in ReScript"
+canonical: "/docs/manual/v12.0.0/dict"
+---
+
+# Dictionary
+
+ReScript has first class support for dictionaries. Dictionaries are mutable objects with string keys, where all values must have the same type. Dicts compile to regular JavaScript objects at runtime.
+
+## Create
+
+You can create a new dictionary in a few different ways, depending on your use case.
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res prelude
+// Using the first class dict syntax
+let d = dict{"A": 5, "B": 6}
+
+// Programatically via the standard library
+let d2 = Dict.fromArray([("A", 5), ("B", 6)])
+```
+
+```js
+let d = {
+  A: 5,
+  B: 6
+};
+
+let d2 = Object.fromEntries([
+  [
+    "A",
+    5
+  ],
+  [
+    "B",
+    6
+  ]
+]);
+
+```
+
+</CodeTab>
+
+A few things to note here:
+
+* Using the first class `dict{}` syntax compiles cleanly to a JavaScript object directly
+* Using `Dict.fromArray` is useful when you need to create a dictionary programatically
+
+## Access
+
+You can access values from a Dictionary either via the the standard library `Dict` module functions, or using pattern matching.
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res prelude
+let d = dict{"A": 5, "B": 6, "C": 7}
+
+// Using `Dict.get`
+let a = d->Dict.get("A")
+
+// Switching on the full dict
+let b = switch d {
+| dict{"B": b} => Some(b)
+| _ => None
+}
+
+// Destructuring
+let dict{"C": ?c} = d
+```
+
+```js
+let d = {
+  A: 5,
+  B: 6,
+  C: 7
+};
+
+let a = d["A"];
+
+let b = d.B;
+
+let b$1 = b !== undefined ? b : undefined;
+
+let c = d.C;
+```
+</CodeTab>
+
+> In the Destructuring example, we're using the `?` optional pattern match syntax to pull out the `C` key value as an optional, regardless of if the dict has it or not.
+
+## Pattern matching
+Dictionaries have first class support for pattern matching. Read more in the [dedicated guide on pattern matching and destructring in ReScript](pattern-matching-destructuring.md#match-on-dictionaries).
+
+## Updating and setting values
+
+You can set and update new values on your dictionary using the `Dict.set` function. All updates are mutable.
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res prelude
+let d = dict{"A": 5, "B": 6}
+
+d->Dict.set("C", 7)
+```
+
+```js
+let d = {
+  A: 5,
+  B: 6
+};
+
+d["C"] = 7;
+```
+
+</CodeTab>
+
+## Advanced example: Pattern matching on JSON
+
+JSON objects are represented as dictionaries (`dict<JSON.t>`). You can leverage that fact to decode JSON in a nice way, using only language features:
+
+<CodeTab labels={["ReScript", "JS Output"]}>
+
+```res prelude
+type user = {
+  name: string,
+  email: string,
+}
+
+/** Decode JSON to a `user`. */
+let decodeUser = (json: JSON.t) => {
+  switch json {
+  | Object(dict{"name": JSON.String(name), "email": JSON.String(email)}) =>
+    Some({name, email})
+  | _ => None
+  }
+}
+
+```
+
+```js
+function decodeUser(json) {
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    return;
+  }
+  let name = json.name;
+  if (typeof name !== "string") {
+    return;
+  }
+  let email = json.email;
+  if (typeof email === "string") {
+    return {
+      name: name,
+      email: email
+    };
+  }
+  
+}
+```
+
+</CodeTab>