Merge branch 'master' into 800

Author: ryyppy

pages/docs/manual/latest/bind-to-js-function.mdx

@@ -26,7 +26,7 @@ ReScript has [labeled arguments](function.md#labeled-arguments) (that can also b
 // MyGame.js
 
 function draw(x, y, border) {
-   // suppose `border`` is optional and defaults to false
+   // suppose `border` is optional and defaults to false
 }
 draw(10, 20)
 draw(20, 20, true)
@@ -259,7 +259,7 @@ external on: (
 let register = rl =>
   rl
   ->on(#close(event => ()))
-  ->on(#line(line => print_endline(line)))
+  ->on(#line(line => Js.log(line)));
 ```
 ```js
 function register(rl) {
@@ -287,13 +287,13 @@ external processOnExit: (
   @bs.as("exit") _,
   int => unit
 ) => unit = "process.on"
-let () = processOnExit(exit_code =>
-  Js.log("error code: " ++ string_of_int(exit_code))
+let () = processOnExit(exitCode =>
+  Js.log("error code: " ++ Js.Int.toString(exitCode))
 );
 ```
 ```js
-process.on("exit", function (exit_code) {
-  console.log("error code: " + String(exit_code));
+process.on("exit", function (exitCode) {
+  console.log("error code: " + exitCode.toString());
 });
 ```
 
@@ -308,9 +308,9 @@ Curry is a delicious Indian dish. More importantly, in the context of ReScript (
 See the `addFive` intermediate function? `add` takes in 3 arguments but received only 1. It's interpreted as "currying" the argument `5` and waiting for the next 2 arguments to be applied later on. Type signatures:
 
 ```resi
-let add: (int, int, int) => int;
-let addFive: (int, int) => int;
-let twelve: int;
+let add: (int, int, int) => int
+let addFive: (int, int) => int
+let twelve: int
 ```
 
 (In a dynamic language such as JS, currying would be dangerous, since accidentally forgetting to pass an argument doesn't error at compile time).

pages/docs/manual/latest/bind-to-js-object.mdx

@@ -51,7 +51,7 @@ type person = {
   "name": string,
   "friends": array<string>,
   "age": int,
-};
+}
 
 @bs.module("MySchool") external john: person = "john"
 
@@ -77,9 +77,6 @@ type textarea
 @bs.get external getName: textarea => string = "name"
 ```
 ```js
-type textarea
-@bs.set external setName: (textarea, string) => unit = "name"
-@bs.get external getName: textarea => string = "name"
 ```
 
 </CodeTab>
@@ -125,7 +122,7 @@ Use `bs.new` to emulate e.g. `new Date()`:
 type t
 @bs.new external createDate: unit => t = "Date"
 
-let date = createDate();
+let date = createDate()
 ```
 ```js
 var date = new Date();

pages/docs/manual/latest/build-performance.mdx

@@ -63,7 +63,7 @@ In short, thanks to our bsc compiler and bsb build system's architecture, we're
 
 ## Speed Up Incremental Build
 
-ReScript uses the concept of interface files (`.resi`) (or, equivalently, [module signatures](/docs/manual/latest/module#signatures)). Exposing only what you need naturally speeds up incremental builds. E.g. if you change a `.res` file whose corresponding `.resi` file doesn't expose the changed part, then you've reduced the amount of dependent files you have to rebuild.
+ReScript uses the concept of interface files (`.resi`) (or, equivalently, [module signatures](module.md#signatures)). Exposing only what you need naturally speeds up incremental builds. E.g. if you change a `.res` file whose corresponding `.resi` file doesn't expose the changed part, then you've reduced the amount of dependent files you have to rebuild.
 
 <!-- TODO: validate this -->
 

pages/docs/manual/latest/converting-from-js.mdx

@@ -59,7 +59,7 @@ let queryResult = (usePayload, payload) =>
 
 You might still occasionally get syntax errors, but not as drastic as the previous step's.
 
-- Change `foo.bar` to `foo["bar"]`. This escape-hatch [ReScript feature](/docs/reason-compiler/latest/object) will be your medium-term friend.
+- Change `foo.bar` to `foo["bar"]`. This escape-hatch [ReScript feature](object.md) will be your medium-term friend.
 - To communicate with external JS files, use `external`. They're our [foreign function interface](external.md).
   - Inline externals. No need to create clean, well-separated files for externals for now. We'll come back to these.
   - If it's too cumbersome to correctly type an `external`'s input/output, use some placeholder polymorphic types, e.g. `external getStudentById: 'whatever => 'whateverElse = ...`.
@@ -75,7 +75,7 @@ let defaultId = 10
 
 let queryResult = (usePayload, payload) =>
   if usePayload {
-    payload["student"] // this will be inferred as `Js.t 'a`
+    payload["student"] // this will be inferred as `Js.t<'a>`
   } else {
     getStudentById(defaultId)
   };

pages/docs/manual/latest/exception.mdx

@@ -7,7 +7,7 @@ Exceptions are just a special kind of variant, thrown in **exceptional** cases (
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res
-let getItem = (theList) =>
+let getItem = (items) =>
   if callSomeFunctionThatThrows() {
     // return the found item here
     1
@@ -23,7 +23,7 @@ let result =
   }
 ```
 ```js
-function getItem(theList) {
+function getItem(items) {
   if (callSomeFunctionThatThrows()) {
     return 1;
   }
@@ -153,7 +153,7 @@ The `obj` here is of type `Js.Exn.t`, intentionally opaque to disallow illegal o
 
 ## Raise a JS Exception
 
-`raise MyException` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Js.Exn.raiseError`:
+`raise(MyException)` raises a ReScript exception. To raise a JavaScript exception (whatever your purpose is), use `Js.Exn.raiseError`:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 

pages/docs/manual/latest/faq.mdx

@@ -20,6 +20,10 @@ Reason is a syntax layer for OCaml that BuckleScript also adopted. The current R
 
 Please see our [blog post](https://reasonml.org/blog/a-note-on-bucklescripts-future-commitments) on this matter.
 
+**Where can I see the docs in old Reason syntax?**
+
+Switch the doc version to `v8.0.0` in the sidebar on the left!
+
 **Will ReScript support native compilation eventually?**
 
 Our focus is a solid JS story right now. In the future, if there’s strong demand, we might consider it.

pages/docs/manual/latest/function.mdx

@@ -458,8 +458,8 @@ let add = (~first: int=1, ~second: int=2) : int => first + second
 // optional
 let add = (~first as x: option<int>=?, ~second as y: option<int>=?) : int => switch x {...}
 // with punning sugar
-// note that the caller would pass an `int`, not `option int`
-// Inside the function, `first` and `second` are `option int`.
+// note that the caller would pass an `int`, not `option<int>`
+// Inside the function, `first` and `second` are `option<int>`.
 let add = (~first: option<int>=?, ~second: option<int>=?) : int => switch first {...}
 ```
 

pages/docs/manual/latest/import-from-export-to-js.mdx

@@ -94,7 +94,7 @@ Technically, since a ReScript file maps to a module, there's no such thing as "d
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res
-/* FavoriteStudent.ml */
+/* FavoriteStudent.res */
 let default = "Bob"
 ```
 ```js

pages/docs/manual/latest/interop-cheatsheet.mdx

@@ -69,11 +69,11 @@ Handling a value that can be `undefined` and `null`, by ditching the `option` ty
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res
-let jsNull = Js.Nullable.null;
-let jsUndefined = Js.Nullable.undefined;
-let result1: Js.Nullable.t<string> = Js.Nullable.return("hello");
-let result2: Js.Nullable.t<int> = Js.Nullable.fromOption(Some(10));
-let result3: option<int> = Js.Nullable.toOption(Js.Nullable.return(10));
+let jsNull = Js.Nullable.null
+let jsUndefined = Js.Nullable.undefined
+let result1: Js.Nullable.t<string> = Js.Nullable.return("hello")
+let result2: Js.Nullable.t<int> = Js.Nullable.fromOption(Some(10))
+let result3: option<int> = Js.Nullable.toOption(Js.Nullable.return(10))
 ```
 ```js
 var Caml_option = require("./stdlib/caml_option.js");
@@ -196,16 +196,19 @@ var gpa = 2.1 + 10;
 
 ## List of `@bs` Decorators
 
-- `@bs.val`
-- `@bs.scope`
+- `@bs.as`
 - `@bs.get`
-- `@bs.set`
+- `@bs.inline`
+- `@bs.int`
+- `@bs.meth`
+- `@bs.new`
+- `@bs.return`
+- `@bs.scope`
 - `@bs.send`
+- `@bs.set`
 - `@bs.string`
-- `@bs.int`
+- `@bs.this`
+- `@bs.uncurry`
 - `@bs.unwrap`
-- `@bs.new`
-- `@bs.as`
+- `@bs.val`
 - `@bs.variadic`
-- `@bs.inline`
-- `@bs.meth`

pages/docs/manual/latest/lazy-values.mdx

@@ -109,7 +109,7 @@ var lazyDoesFileExist = {
 
 </CodeTab>
 
-Whenever we want to wrap a function `unit => 'a`, we use `Lazy.from_fun`, otherwise we use the `lazy([expr])` keyword to wrap an expression or a function with 1 or more arguments.
+Whenever we want to wrap a function `unit => 'a`, we use `Lazy.from_fun`, otherwise we use the `lazy(expr)` keyword to wrap an expression or a function with 1 or more arguments.
 
 ## Force a lazy computation