[Old docs] Last few pages

Author: chenglou

layouts/ManualDocsLayout8_0_0.re

@@ -24,7 +24,7 @@ module Toc = DocsLayout.Toc;
 
 let overviewNavs = [|
   NavItem.{name: "Introduction", href: "/docs/manual/v8.0.0/introduction"},
-  {name: "Migrate from BuckleScript/Reason", href: "/docs/manual/v8.0.0/migrate-from-bucklescript-reason"},
+  {name: "Migrate to New Syntax", href: "/docs/manual/v8.0.0/migrate-to-new-syntax"},
   {name: "Installation", href: "/docs/manual/v8.0.0/installation"},
   {name: "Try", href: "/docs/manual/v8.0.0/try"},
   {name: "Editor Plugins", href: "/docs/manual/v8.0.0/editor-plugins"},

pages/docs/manual/v8.0.0/let-binding.mdx

@@ -5,9 +5,9 @@ A "let binding", in other languages, might be called a "variable declaration". `
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-let greeting = "hello!"
-let score = 10
-let newScore = 10 + score
+let greeting = "hello!";
+let score = 10;
+let newScore = 10 + score;
 ```
 ```js
 var greeting = "hello!";
@@ -25,10 +25,10 @@ Bindings can be scoped through `{}`.
 
 ```re
 let message = {
-  let part1 = "hello"
-  let part2 = "world"
-  part1 ++ " " ++ part2
-}
+  let part1 = "hello";
+  let part2 = "world";
+  part1 ++ " " ++ part2;
+};
 // `part1` and `part2` not accessible here!
 ```
 ```js
@@ -46,9 +46,9 @@ ReScript's `if`, `while` and functions all use the same block scoping mecanism.
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-if displayGreeting {
-  let message = "Enjoying the docs so far?"
-  Js.log(message)
+if (displayGreeting) {
+  let message = "Enjoying the docs so far?";
+  Js.log(message);
 };
 // `message` not accessible here!
 ```
@@ -89,9 +89,9 @@ In ReScript, this obviously works too:
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-let result1 = 0
-let result2 = calculate(result1)
-let result3 = calculateSomeMore(result2)
+let result1 = 0;
+let result2 = calculate(result1);
+let result3 = calculateSomeMore(result2);
 ```
 ```js
 var result1 = 0;
@@ -106,9 +106,9 @@ Additionally, reusing the same let binding name overshadows the previous binding
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-let result = 0
-let result = calculate(result)
-let result = calculateSomeMore(result)
+let result = 0;
+let result = calculate(result);
+let result = calculateSomeMore(result);
 ```
 ```js
 var result = calculate(0);
@@ -124,10 +124,10 @@ As a matter of fact, even this is valid code:
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-let result = "hello"
-Js.log(result) // prints "hello"
-let result = 1
-Js.log(result) // prints 1
+let result = "hello";
+Js.log(result); // prints "hello"
+let result = 1;
+Js.log(result); // prints 1
 ```
 ```js
 var result = 1;

pages/docs/manual/v8.0.0/migrate-from-bucklescript-reason.mdx

@@ -0,0 +1,16 @@
+# Migrate to New Syntax
+
+Starting from `v8.2.0`, BuckleScript and the JS part of Reason are now fused into the new ReScript. We've also introduced a new syntax similar to the old Reason syntax, but [tremendously improved](https://reasonml.org/blog/bucklescript-8-1-new-syntax).
+
+The old ML and Reason syntax are still supported (see our support commitment [here](https://reasonml.org/blog/a-note-on-bucklescripts-future-commitments)). The gist is: this is mostly just a rebranding and shouldn't affect your existing code much.
+
+## Upgrade Your Codebase
+
+There are lots of exciting improvements in the new syntax (features, speed, error messages, etc.). The upgrade is trivial, backward-compatible and can be done on a per-file basis:
+
+- Upgrade your project to `bs-platform 8.2.0`.
+- `node_modules/.bin/bsc -format MyFile.re > MyFile.res`
+
+**That's it**! `MyFile.re` could be any `.re`, `.rei`, `.ml` and `.mli` file.
+
+Enjoy the improved experience!

pages/docs/manual/v8.0.0/migrate-to-new-syntax.mdx

@@ -33,7 +33,7 @@ To create a `person` record (declared above):
 let me = {
   age: 5,
   name: "Big ReScript"
-}
+};
 ```
 ```js
 var me = {
@@ -51,8 +51,8 @@ The type is found by looking above the `me` value. **Note**: if the type instead
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-// School.res
-type person = {age: int, name: string}
+// School.re
+type person = {age: int, name: string};
 ```
 ```js
 // Empty output
@@ -63,11 +63,11 @@ type person = {age: int, name: string}
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-// Example.res
+// Example.re
 
-let me: School.person = {age: 20, name: "Big ReScript"}
+let me: School.person = {age: 20, name: "Big ReScript"};
 /* or */
-let me2 = {School.age: 20, name: "Big ReScript"}
+let me2 = {School.age: 20, name: "Big ReScript"};
 ```
 ```js
 var me = {
@@ -91,7 +91,7 @@ Use the familiar dot notation:
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-let name = me.name
+let name = me.name;
 ```
 ```js
 var name = "Big ReScript";
@@ -106,7 +106,7 @@ New records can be created from old records with the `...` spread operator. The
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-let meNextYear = {...me, age: me.age + 1}
+let meNextYear = {...me, age: me.age + 1};
 ```
 ```js
 var meNextYear = {
@@ -129,10 +129,10 @@ Record fields can optionally be mutable. This allows you to efficiently update t
 type person = {
   name: string,
   mutable age: int
-}
+};
 
-let baby = {name: "Baby ReScript", age: 5}
-baby.age = baby.age + 1 // `baby.age` is now 6. Happy birthday!
+let baby = {name: "Baby ReScript", age: 5};
+baby.age = baby.age + 1; // `baby.age` is now 6. Happy birthday!
 ```
 ```js
 var baby = {
@@ -152,10 +152,10 @@ baby.age = baby.age + 1 | 0;
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```re
-type person = {age: int, name: string}
-type monster = {age: int, hasTentacles: bool}
+type person = {age: int, name: string};
+type monster = {age: int, hasTentacles: bool};
 
-let getAge = (entity) => entity.age
+let getAge = (entity) => entity.age;
 ```
 ```js
 function getAge(entity) {
@@ -168,11 +168,11 @@ function getAge(entity) {
 Instead, `getAge` will infer that the parameter `entity` must be of type `monster`, the closest record type with the field `age`. The following code's last line fails:
 
 ```re
-let kraken = {age: 9999, hasTentacles: true}
-let me = {age: 5, name: "Baby ReScript"}
+let kraken = {age: 9999, hasTentacles: true};
+let me = {age: 5, name: "Baby ReScript"};
 
-getAge(kraken)
-getAge(me) // type error!
+getAge(kraken);
+getAge(me); // type error!
 ```
 
 The type system will complain that `me` is a `person`, and that `getAge` only works on `monster`. If you need such capability, use ReScript objects, described [here](object.md).

pages/docs/manual/v8.0.0/record.mdx

@@ -5,7 +5,7 @@ ReScript's built-in values of type `string`, `float`, `array` and a few others h
 This means that if you receive e.g. a string from the JS side, you can use it **without conversion** on the ReScript side, and vice-versa.
 
 **Shared, bidirectionally usable types**:
-- String. Backtick strings like `` `hello 👋 ${personName}` `` support unicode and interpolation. Normal `"hello"` strings don't.
+- String. Backtick strings like `` `hello ${personName}` `` support interpolation. Normal `"hello"` strings don't.
 - Float. ReScript floats are JS numbers, vice-versa.
 - Array. In addition to the [JS Array API](/apis/latest/js/array), we provide our own [Belt.Array](/apis/latest/belt/array#set) API too.
 - Tuple. Compiles to a JS array. You can treat a fixed-sized, heterogenous JS array as ReScript tuple too.