Remove bs. prefix

Author: ryyppy

pages/docs/manual/latest/attribute.mdx

@@ -11,7 +11,7 @@ Like many other languages, ReScript allows annotating a piece of code to express
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res
-@bs.inline
+@inline
 let mode = "dev"
 
 let mode2 = mode
@@ -22,7 +22,7 @@ var mode2 = "dev";
 
 </CodeTab>
 
-The `@bs.inline` annotation tells `mode`'s value to be inlined into its usage sites (see output). We call such annotation "attribute" (or "decorator" in JavaScript).
+The `@inline` annotation tells `mode`'s value to be inlined into its usage sites (see output). We call such annotation "attribute" (or "decorator" in JavaScript).
 
 An attribute starts with `@` and goes before the item it annotates. In the above example, it's hooked onto the let binding.
 
@@ -39,11 +39,11 @@ You can put an attribute almost anywhere. You can even add extra data to them by
 @unboxed
 type a = Name(string)
 
-@bs.val external message: string = "message"
+@val external message: string = "message"
 
 type student = {
   age: int,
-  @bs.as("aria-label") ariaLabel: string,
+  @as("aria-label") ariaLabel: string,
 }
 
 @deprecated
@@ -59,8 +59,8 @@ let customTriple = foo => foo * 3
 
 1. `@@warning("-27")` is a standalone attribute that annotates the entire file. Those attributes start with `@@`. Here, it carries the data `"-27"`.
 2. `@unboxed` annotates the type definition.
-3. `@bs.val` annotates the `external` statement.
-4. `@bs.as("aria-label")` annotates the `ariaLabel` record field.
+3. `@val` annotates the `external` statement.
+4. `@as("aria-label")` annotates the `ariaLabel` record field.
 5. `@deprecated` annotates the `customDouble` expression. This shows a warning while compiling telling consumers to not rely on this method long-term.
 6. `@deprecated("Use SomeOther.customTriple instead")` annotates the `customTriple` expression with a string to describe the reason for deprecation.
 

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

@@ -13,8 +13,8 @@ Some JS values, like `setTimeout`, live in the global scope. You can bind to the
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.val external setTimeout: (unit => unit, int) => float = "setTimeout"
-@bs.val external clearTimeout: float => unit = "clearTimeout"
+@val external setTimeout: (unit => unit, int) => float = "setTimeout"
+@val external clearTimeout: float => unit = "clearTimeout"
 ```
 ```js
 // Empty output
@@ -40,8 +40,8 @@ We're in a language with a great type system now! Let's leverage a popular featu
 
 ```res example
 type timerId
-@bs.val external setTimeout: (unit => unit, int) => timerId = "setTimeout"
-@bs.val external clearTimeout: timerId => unit = "clearTimeout"
+@val external setTimeout: (unit => unit, int) => timerId = "setTimeout"
+@val external clearTimeout: timerId => unit = "clearTimeout"
 
 let id = setTimeout(() => Js.log("hello"), 100)
 clearTimeout(id)
@@ -62,12 +62,12 @@ Since `external`s are inlined, we end up with JS output as readable as hand-writ
 
 ## Global Modules
 
-If you want to bind to a value inside a global module, e.g. `Math.random`, attach a `bs.scope` to your `bs.val` external:
+If you want to bind to a value inside a global module, e.g. `Math.random`, attach a `scope` to your `val` external:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.scope("Math") @bs.val external random: unit => float = "random"
+@scope("Math") @val external random: unit => float = "random"
 let someNumber = random()
 ```
 ```js
@@ -76,12 +76,12 @@ var someNumber = Math.random();
 
 </CodeTab>
 
-you can bind to an arbitrarily deep object by passing a tuple to `bs.scope`:
+you can bind to an arbitrarily deep object by passing a tuple to `scope`:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.val @bs.scope(("window", "___location", "ancestorOrigins"))
+@val @scope(("window", "___location", "ancestorOrigins"))
 external length: int = "length"
 ```
 ```js

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

@@ -12,7 +12,7 @@ Binding a JS function is like binding any other value:
 
 ```res example
 // Import nodejs' path.dirname
-@bs.module("path") external dirname: string => string = "dirname"
+@module("path") external dirname: string => string = "dirname"
 let root = dirname("/User/github") // returns "User"
 ```
 ```js
@@ -43,7 +43,7 @@ It'd be nice if on ReScript's side, we can bind & call `draw` while labeling thi
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.module("MyGame")
+@module("MyGame")
 external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw"
 
 draw(~x=10, ~y=20, ~border=true, ())
@@ -67,7 +67,7 @@ Note that you can freely reorder the labels on the ReScript side; they'll always
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.module("MyGame")
+@module("MyGame")
 external draw: (~x: int, ~y: int, ~border: bool=?, unit) => unit = "draw"
 
 draw(~x=10, ~y=20, ())
@@ -84,14 +84,14 @@ MyGame.draw(10, 20, undefined);
 
 ## Object Method
 
-Functions attached to a JS objects (other than JS modules) require a special way of binding to them, using `bs.send`:
+Functions attached to a JS objects (other than JS modules) require a special way of binding to them, using `send`:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
 type document // abstract type for a document object
-@bs.send external getElementById: (document, string) => Dom.element = "getElementById"
-@bs.val external doc: document = "document"
+@send external getElementById: (document, string) => Dom.element = "getElementById"
+@val external doc: document = "document"
 
 let el = getElementById(doc, "myId")
 ```
@@ -101,20 +101,20 @@ var el = document.getElementById("myId");
 
 </CodeTab>
 
-In a `bs.send`, the object is always the first argument. Actual arguments of the method follow (this is a bit what modern OOP objects are really).
+In a `send`, the object is always the first argument. Actual arguments of the method follow (this is a bit what modern OOP objects are really).
 
 ### Chaining
 
 Ever used `foo().bar().baz()` chaining ("fluent api") in JS OOP? We can model that in ReScript too, through the [pipe operator](pipe.md).
 
 ## Variadic Function Arguments
 
-You might have JS functions that take an arbitrary amount of arguments. ReScript supports modeling those, under the condition that the arbitrary arguments part is homogenous (aka of the same type). If so, add `bs.variadic` to your `external`.
+You might have JS functions that take an arbitrary amount of arguments. ReScript supports modeling those, under the condition that the arbitrary arguments part is homogenous (aka of the same type). If so, add `variadic` to your `external`.
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.module("path") @bs.variadic
+@module("path") @variadic
 external join: array<string> => string = "join"
 
 let v = join(["a", "b"])
@@ -126,7 +126,7 @@ var v = Path.join("a", "b");
 
 </CodeTab>
 
-`bs.module` will be explained in [Import from/Export to JS](import-from-export-to-js.md).
+`module` will be explained in [Import from/Export to JS](import-from-export-to-js.md).
 
 ## Modeling Polymorphic Function
 
@@ -139,9 +139,9 @@ If you can exhaustively enumerate the many forms an overloaded JS function can t
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.module("MyGame") external drawCat: unit => unit = "draw"
-@bs.module("MyGame") external drawDog: (~giveName: string) => unit = "draw"
-@bs.module("MyGame") external draw: (string, ~useRandomAnimal: bool) => unit = "draw"
+@module("MyGame") external drawCat: unit => unit = "draw"
+@module("MyGame") external drawDog: (~giveName: string) => unit = "draw"
+@module("MyGame") external draw: (string, ~useRandomAnimal: bool) => unit = "draw"
 ```
 ```js
 // Empty output
@@ -151,7 +151,7 @@ If you can exhaustively enumerate the many forms an overloaded JS function can t
 
 Note how all three externals bind to the same JS function, `draw`.
 
-### Trick 2: Polymorphic Variant + `bs.unwrap`
+### Trick 2: Polymorphic Variant + `unwrap`
 
 If you have the irresistible urge of saying "if only this JS function argument was a variant instead of informally being either `string` or `int`", then good news: we do provide such `external` features through annotating a parameter as a polymorphic variant! Assuming you have the following JS function you'd like to bind to:
 
@@ -172,10 +172,10 @@ Here, `padding` is really conceptually a variant. Let's model it as such.
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.val
+@val
 external padLeft: (
   string,
-  @bs.unwrap [
+  @unwrap [
     | #Str(string)
     | #Int(int)
   ])
@@ -190,21 +190,21 @@ padLeft("Hello World", "Message from ReScript: ");
 
 </CodeTab>
 
-Obviously, the JS side couldn't have an argument that's a polymorphic variant! But here, we're just piggy backing on poly variants' type checking and syntax. The secret is the `@bs.unwrap` annotation on the type. It strips the variant constructors and compile to just the payload's value. See the output.
+Obviously, the JS side couldn't have an argument that's a polymorphic variant! But here, we're just piggy backing on poly variants' type checking and syntax. The secret is the `@unwrap` annotation on the type. It strips the variant constructors and compile to just the payload's value. See the output.
 
 ## Constrain Arguments Better
 
-Consider the Node `fs.readFileSync`'s second argument. It can take a string, but really only a defined set: `"ascii"`, `"utf8"`, etc. You can still bind it as a string, but we can use poly variants + `bs.string` to ensure that our usage's more correct:
+Consider the Node `fs.readFileSync`'s second argument. It can take a string, but really only a defined set: `"ascii"`, `"utf8"`, etc. You can still bind it as a string, but we can use poly variants + `string` to ensure that our usage's more correct:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.module("fs")
+@module("fs")
 external readFileSync: (
   ~name: string,
-  @bs.string [
+  @string [
     | #utf8
-    | @bs.as("ascii") #useAscii
+    | @as("ascii") #useAscii
   ],
 ) => string = "readFileSync"
 
@@ -217,21 +217,21 @@ Fs.readFileSync("xx.txt", "ascii");
 
 </CodeTab>
 
-- Attaching `@bs.string` to the whole poly variant type makes its constructor compile to a string of the same name.
-- Attaching a `@bs.as("bla")` to a constructor lets you customize the final string.
+- Attaching `@string` to the whole poly variant type makes its constructor compile to a string of the same name.
+- Attaching a `@as("bla")` to a constructor lets you customize the final string.
 
 And now, passing something like `"myOwnUnicode"` or other variant constructor names to `readFileSync` would correctly error.
 
-Aside from string, you can also compile an argument to an int, using `bs.int` instead of `bs.string` in a similar way:
+Aside from string, you can also compile an argument to an int, using `int` instead of `string` in a similar way:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.val
+@val
 external testIntType: (
-  @bs.int [
+  @int [
     | #onClosed
-    | @bs.as(20) #onOpen
+    | @as(20) #onOpen
     | #inBinary
   ])
   => int = "testIntType"
@@ -254,10 +254,10 @@ One last trick with polymorphic variants:
 ```res example
 type readline
 
-@bs.send
+@send
 external on: (
     readline,
-    @bs.string [
+    @string [
       | #close(unit => unit)
       | #line(string => unit)
     ]
@@ -290,9 +290,9 @@ Sometimes it's convenient to bind to a function using an `external`, while passi
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.val
+@val
 external processOnExit: (
-  @bs.as("exit") _,
+  @as("exit") _,
   int => unit
 ) => unit = "process.on"
 
@@ -308,7 +308,7 @@ process.on("exit", function (exitCode) {
 
 </CodeTab>
 
-The `@bs.as("exit")` and the placeholder `_` argument together indicates that you want the first argument to compile to the string `"exit"`. You can also use any JSON literal with `bs.as`: `` @bs.as(json`true`) ``, `` @bs.as(json`{"name": "John"}`) ``, etc.
+The `@as("exit")` and the placeholder `_` argument together indicates that you want the first argument to compile to the string `"exit"`. You can also use any JSON literal with `as`: `` @as(json`true`) ``, `` @as(json`{"name": "John"}`) ``, etc.
 
 ## Curry & Uncurry
 
@@ -338,7 +338,7 @@ Unfortunately, due to JS not having currying because of the aforementioned reaso
 
 ReScript tries to do #1 as much as it can. Even when it bails and uses #2's currying mechanism, it's usually harmless.
 
-**However**, if you encounter #3, heuristics are not good enough: you need a guaranteed way of fully applying a function, without intermediate currying steps. We provide such guarantee through the use of the `@bs` "uncurrying" annotation on a function declaration & call site.
+**However**, if you encounter #3, heuristics are not good enough: you need a guaranteed way of fully applying a function, without intermediate currying steps. We provide such guarantee through the use of the ["uncurrying" syntax](./function#uncurried-function) on a function declaration & call site.
 
 ### Solution: Use Guaranteed Uncurrying
 
@@ -348,7 +348,7 @@ ReScript tries to do #1 as much as it can. Even when it bails and uses #2's curr
 
 ```res example
 type timerId
-@bs.val external setTimeout: ((. unit) => unit, int) => timerId = "setTimeout"
+@val external setTimeout: ((. unit) => unit, int) => timerId = "setTimeout"
 
 let id = setTimeout((.) => Js.log("hello"), 1000)
 ```
@@ -370,12 +370,12 @@ The above solution is safe, guaranteed, and performant, but sometimes visually a
 
 <!-- TODO: is this up-to-date info? -->
 
-Then try `@bs.uncurry`:
+Then try `@uncurry`:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
-@bs.send external map: (array<'a>, @bs.uncurry ('a => 'b)) => array<'b> = "map"
+@send external map: (array<'a>, @uncurry ('a => 'b)) => array<'b> = "map"
 map([1, 2, 3], x => x + 1)
 ```
 ```js
@@ -384,7 +384,7 @@ map([1, 2, 3], x => x + 1)
 
 </CodeTab>
 
-In general, `bs.uncurry` is recommended; the compiler will do lots of optimizations to resolve the currying to uncurrying at compile time. However, there are some cases the compiler can't optimize it. In these cases, it will be converted to a runtime check.
+In general, `uncurry` is recommended; the compiler will do lots of optimizations to resolve the currying to uncurrying at compile time. However, there are some cases the compiler can't optimize it. In these cases, it will be converted to a runtime check.
 
 ## Modeling `this`-based Callbacks
 
@@ -396,16 +396,16 @@ x.onload = function(v) {
 }
 ```
 
-Here, `this` would point to `x` (actually, it depends on how `onload` is called, but we digress). It's not correct to declare `x.onload` of type `(. unit) -> unit`. Instead, we introduced a special attribute, `bs.this`, which allows us to type `x` as so:
+Here, `this` would point to `x` (actually, it depends on how `onload` is called, but we digress). It's not correct to declare `x.onload` of type `(. unit) -> unit`. Instead, we introduced a special attribute, `this`, which allows us to type `x` as so:
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
 type x
-@bs.val external x: x = "x"
-@bs.set external setOnload: (x, @bs.this ((x, int) => unit)) => unit = "onload"
-@bs.get external resp: x => int = "response"
-setOnload(x, @bs.this ((o, v) => Js.log(resp(o) + v)))
+@val external x: x = "x"
+@set external setOnload: (x, @this ((x, int) => unit)) => unit = "onload"
+@get external resp: x => int = "response"
+setOnload(x, @this ((o, v) => Js.log(resp(o) + v)))
 ```
 ```js
 x.onload = function (v) {
@@ -416,19 +416,19 @@ x.onload = function (v) {
 
 </CodeTab>
 
-`bs.this` has its first parameter is reserved for `this` and for arity of 0, there is no need for a redundant `unit` type.
+`this` has its first parameter is reserved for `this` and for arity of 0, there is no need for a redundant `unit` type.
 
 ## Function Nullable Return Value Wrapping
 
-For JS functions that return a value that can also be `undefined` or `null`, we provide `@bs.return(...)`. To automatically convert that value to an `option` type (recall that ReScript `option` type's `None` value only compiles to `undefined` and not `null`).
+For JS functions that return a value that can also be `undefined` or `null`, we provide `@return(...)`. To automatically convert that value to an `option` type (recall that ReScript `option` type's `None` value only compiles to `undefined` and not `null`).
 
 <CodeTab labels={["ReScript", "JS Output"]}>
 
 ```res example
 type element
 type dom
 
-@bs.send @bs.return(nullable)
+@send @return(nullable)
 external getElementById: (dom, string) => option<element> = "getElementById"
 
 let test = dom => {
@@ -454,7 +454,7 @@ function test(dom) {
 
 </CodeTab>
 
-`bs.return(nullable)` attribute will automatically convert `null` and `undefined` to `option` type.
+`return(nullable)` attribute will automatically convert `null` and `undefined` to `option` type.
 
 Currently 4 directives are supported: `null_to_opt`, `undefined_to_opt`, `nullable` and `identity`.