links to api/core changed to api/stdlib

Author: jderochervlk

markdown-pages/blogposts/2024-01-11-release-11-0-0.mdx

@@ -52,7 +52,7 @@ This release is also introducing uncurried mode, which is a new default mode tha
 
 [ReScript Core](https://github.com/rescript-lang/rescript-core) is ReScript's new standard library. It replaces the complete `Js` module as well as some of the more frequently used modules from `Belt` and is recommended to use with uncurried mode.
 
-The latest docs on [rescript-lang.org](/) already use it for the examples. Have a look at the new [RescriptCore API docs](/docs/manual/api/core).
+The latest docs on [rescript-lang.org](/) already use it for the examples. Have a look at the new [RescriptCore API docs](/docs/manual/api/stdlib).
 
 ## More Features
 

markdown-pages/docs/manual/array-and-list.mdx

@@ -52,9 +52,9 @@ var tenthItem = myArray[10];
 
 </CodeTab>
 
-The behavior of returning an `option` is new to V11 when you have [Core](api/core) open.
+The behavior of returning an `option` is new to V11 when you have [Core](api/stdlib) open.
 It provides a safer way to access array items, which is especially useful when you're not sure if the index is out of bounds.
-If you would like to not use an `option`, you can use [`Array.getUnsafe`](api/core/array#value-getUnsafe).
+If you would like to not use an `option`, you can use [`Array.getUnsafe`](api/stdlib/array#value-getUnsafe).
 
 #### Update
 
@@ -153,7 +153,7 @@ You'd use list for its resizability, its fast prepend (adding at the head), and
 
 Do **not** use list if you need to randomly access an item or insert at non-head position. Your code would end up obtuse and/or slow.
 
-The standard lib provides a [List module](api/core/list).
+The standard lib provides a [List module](api/stdlib/list).
 
 #### Immutable Prepend
 

markdown-pages/docs/manual/bind-to-global-js-values.mdx

@@ -8,7 +8,7 @@ order: 8
 
 # Bind to Global JS Values
 
-**First**, make sure the value you'd like to model doesn't already exist in our [provided API](api/core).
+**First**, make sure the value you'd like to model doesn't already exist in our [provided API](api/stdlib).
 
 Some JS values, like `setTimeout`, live in the global scope. You can bind to them like so:
 
@@ -25,7 +25,7 @@ Some JS values, like `setTimeout`, live in the global scope. You can bind to the
 
 </CodeTab>
 
-(We already provide `setTimeout`, `clearTimeout` and others in the [Core API](api/core) module).
+(We already provide `setTimeout`, `clearTimeout` and others in the [Core API](api/stdlib) module).
 
 This binds to the JavaScript [`setTimeout`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrworkerGlobalScope/setTimeout) methods and the corresponding `clearTimeout`. The `external`'s type annotation specifies that `setTimeout`:
 

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

@@ -164,7 +164,7 @@ If your JavaScript object:
 - might or might not add/remove keys
 - contains only values that are of the same type
 
-Then it's not really an object, it's a hash map. Use [Dict](api/core/dict), which contains operations like `get`, `set`, etc. and cleanly compiles to a JavaScript object still.
+Then it's not really an object, it's a hash map. Use [Dict](api/stdlib/dict), which contains operations like `get`, `set`, etc. and cleanly compiles to a JavaScript object still.
 
 ## Bind to a JS Object That's a Class
 

markdown-pages/docs/manual/exception.mdx

@@ -8,7 +8,7 @@ order: 19
 
 # Exception
 
-Exceptions are just a special kind of variant, thrown in **exceptional** cases (don't abuse them!). Consider using the [`option`](null-undefined-option) or [`result`](api/core/result) type for recoverable errors.
+Exceptions are just a special kind of variant, thrown in **exceptional** cases (don't abuse them!). Consider using the [`option`](null-undefined-option) or [`result`](api/stdlib/result) type for recoverable errors.
 
 You can create your own exceptions like you'd make a variant (exceptions need to be capitalized too).
 
@@ -381,8 +381,8 @@ try {
 }
 ```
 
-The payload `exn` here is of type `unknown` since in JS you can throw anything. To operate on `exn`, do like the code above by using the standard library's [`JsExn`](api/core/jsexn) module's helpers
-or use [`Type.Classify.classify`](api/core/type/classify#value-classify) to get more information about the runtime type of `exn`.
+The payload `exn` here is of type `unknown` since in JS you can throw anything. To operate on `exn`, do like the code above by using the standard library's [`JsExn`](api/stdlib/jsexn) module's helpers
+or use [`Type.Classify.classify`](api/stdlib/type/classify#value-classify) to get more information about the runtime type of `exn`.
 
 ## Throw a JS Exception
 

markdown-pages/docs/manual/json.mdx

@@ -37,7 +37,7 @@ Where `data` can be any type you assume the JSON is. As you can see, this compil
 
 ## Stringify
 
-Use [`JSON.stringify`](api/core/json#value-stringify) if your data is of type `JSON.t` or [`JSON.stringifyAny`](api/core/json#value-stringifyAny) if it is not.
+Use [`JSON.stringify`](api/stdlib/json#value-stringify) if your data is of type `JSON.t` or [`JSON.stringifyAny`](api/stdlib/json#value-stringifyAny) if it is not.
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 

markdown-pages/docs/manual/libraries.mdx

@@ -25,5 +25,5 @@ Search `rescript`-related packages on NPM, or use our [Package Index](/packages)
 If you can't find what you're looking for, remember that **you don't need a wrapper** to use a JS library:
 
 - Most JS data types, such as array and objects, [map over cleanly to ReScript and vice-versa](shared-data-types).
-- You also have access to the familiar [Core API](api/core).
+- You also have access to the familiar [Core API](api/stdlib).
 - You can use a JavaScript library without needing to install dedicated binding libraries. Check the [`external`](external) page.

markdown-pages/docs/manual/migrate-to-v11.mdx

@@ -68,11 +68,11 @@ One major change to be aware of is that array access now returns an `option`.
 let firstItem = myArray[0] // Some("hello")
 ```
 
-If you would like to not use an `option`, you can use [`Array.getUnsafe`](api/core/array#value-getUnsafe).
+If you would like to not use an `option`, you can use [`Array.getUnsafe`](api/stdlib/array#value-getUnsafe).
 
 For a detailed explanation on migration to ReScript Core, please refer to its [migration guide](https://github.com/rescript-association/rescript-core#migration). A semi-automated script is available as well.
 
-See ReScript Core API docs [here](api/core).
+See ReScript Core API docs [here](api/stdlib).
 
 ### Removed bindings
 

markdown-pages/docs/manual/null-undefined-option.mdx

@@ -126,50 +126,11 @@ compiles to `undefined`! If you've got e.g. a string in JavaScript that you know
 
 ### Caveat 1
 
-The option-to-undefined translation isn't perfect, because on our side, `option` values can be composed:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(Some(Some(5)))
-```
-
-```js
-var x = 5;
-```
-
-</CodeTab>
-
-This still compiles to `5`, but this gets troublesome:
-
-<CodeTab labels={["ReScript", "JS Output"]}>
-
-```res example
-let x = Some(None)
-```
-
-```js
-var Caml_option = require("./stdlib/caml_option.js");
-
-var x = Caml_option.some(undefined);
-```
-
-(See output tab).
-
-</CodeTab>
-
-What's this `Caml_option.some` thing? Why can't this compile to `undefined`? Long story short, when dealing with a polymorphic `option` type (aka `option<'a>`, for any `'a`), many operations become tricky if we don't mark the value with some special annotation. If this doesn't make sense, don't worry; just remember the following rule:
-
-- **Never, EVER, pass a nested `option` value (e.g. `Some(Some(Some(5)))`) into the JS side.**
-- **Never, EVER, annotate a value coming from JS as `option<'a>`. Always give the concrete, non-polymorphic type.**
-
-### Caveat 2
-
 Unfortunately, lots of times, your JavaScript value might be _both_ `null` or `undefined`. In that case, you unfortunately can't type such value as e.g. `option<int>`, since our `option` type only checks for `undefined` and not `null` when dealing with a `None`.
 
 #### Solution: More Sophisticated `undefined` & `null` Interop
 
-To solve this, we provide access to more elaborate `null` and `undefined` helpers through the [`Nullable`](api/core/nullable) module. This somewhat works like an `option` type, but is different from it.
+To solve this, we provide access to more elaborate `null` and `undefined` helpers through the [`Nullable`](api/stdlib/nullable) module. This somewhat works like an `option` type, but is different from it.
 
 #### Examples
 

markdown-pages/docs/manual/primitive-types.mdx

@@ -77,7 +77,7 @@ This is just like JavaScript's backtick string interpolation, except without nee
 
 ### Usage
 
-See the familiar `String` API in the [API docs](api/core/string). Since a ReScript string maps to a JavaScript string, you can mix & match the string operations in all standard libraries.
+See the familiar `String` API in the [API docs](api/stdlib/string). Since a ReScript string maps to a JavaScript string, you can mix & match the string operations in all standard libraries.
 
 ### Tips & Tricks
 
@@ -127,7 +127,7 @@ let r = /b/g;
 
 </CodeTab>
 
-A regular expression like the above has the type `RegExp.t`. The [RegExp](api/core/regexp) module contains the regular expression helpers you have seen in JS.
+A regular expression like the above has the type `RegExp.t`. The [RegExp](api/stdlib/regexp) module contains the regular expression helpers you have seen in JS.
 
 ## Boolean
 
@@ -146,15 +146,15 @@ ReScript's `true/false` compiles into a JavaScript `true/false`.
 
 ## Integers
 
-32-bits, truncated when necessary. We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [Int](api/core/int) for helper functions.
+32-bits, truncated when necessary. We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [Int](api/stdlib/int) for helper functions.
 
 **Be careful when you bind to JavaScript numbers!** Since ReScript integers have a much smaller range than JavaScript numbers, data might get lost when dealing with large numbers. In those cases it’s much safer to bind the numbers as **float**. Be extra mindful of this when binding to JavaScript Dates and their epoch time.
 
 To improve readability, you may place underscores in the middle of numeric literals such as `1_000_000`. Note that underscores can be placed anywhere within a number, not just every three digits.
 
 ## Floats
 
-Float requires other operators: `+.`, `-.`, `*.`, `/.`, etc. Like `0.5 +. 0.6`. See [Float](api/core/float) for helper functions.
+Float requires other operators: `+.`, `-.`, `*.`, `/.`, etc. Like `0.5 +. 0.6`. See [Float](api/stdlib/float) for helper functions.
 
 As with integers, you may use underscores within literals to improve readability.
 
@@ -179,7 +179,7 @@ var result = 1 + 2;
 **Since 11.1**
 
 For values which are too large to be represented by Int or Float, there is the `bigint` primitive type.
-We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [BigInt](api/core/bigint) for helper functions.
+We provide the usual operations on them: `+`, `-`, `*`, `/`, etc. See [BigInt](api/stdlib/bigint) for helper functions.
 
 A `bigint` number is denoted by a trailing `n` like so: `42n`.