When browsing rescript-lang.org is hard to figure out where to report issues like broken links and typos.

Currently I clicked on the github link in the top right and navigates to ReScript Github profile

I would expect to find the repo for rescript-lang.org there, so I can open a github issue. So then I had to search until I found that this repo was under the reason-association.

I suggest placing an easy call to action for reporting issues

These docs are missing on the site, would you accept a PR adding them?

https://reasonml.github.io/api/index

it seems some names are marked as keyword by mistake, ie class related keywords, struct sig etc.

https://rescript-lang.org/try?code=DYUwLgBGBcHAlgZzAHmQJ3gOwOYD4IBeCACgEYAaCAJgEoBuIA

Compiling in https://rescript-lang.org/try with .res syntax.

Input code:

let t: list<string> = (1, 2);

Error message:

[E] Line 1, column 22:

This has type:
    'a * 'b
  But somewhere wanted:
    string list

Expected:

[E] Line 1, column 22:

This has type:
    ('a, 'b)
  But somewhere wanted:
     list<string>

Can't reproduce when compiling code with bsb.

I believe the best way to use rescript atm is using reason syntax. since it's more mature and has a greater editor support.
don't get me wrong I like rescript syntax (I even wrote small vim syntax for it) and appreciate all the work done behind the scene to move to new syntax (especially the work done by @IwanKaramazow for parser) but the new syntax still needs a bit more time to be more mature and polished (there are some bugs occasionally and it's getting better by adding more features).
it makes adoption a bit harder, people don't want to use a language with immature parser and w/o editor support, I think prioritizing rescript syntax in the docs atm makes people feel using it is the best option and reason syntax is not supported in newer versions.

https://github.com/reason-association/reasonml.org/blob/master/pages/docs/reason-compiler/latest/function.mdx#fixed-arguments

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|json}], [@bs.as {json|{"name": "John"}|json}], etc.

Above was about everything I could find about JSON literal on the doc and it doesn't have its own section. Also, it is hard to find about this. I think it should be included in a doc about JSON or have its own page and better paragraphs.

Just found out about ReScript, looks very promising. But I almost threw it to the trash because I thought there was no TS interop. Shouldn't genType for TS be one of the main parts of Language Manual?

This one is definitely an advanced topic.

• What does + and - mean?
• What syntax constructs are possible? (type, function, etc.)
• What practical use-cases does it have / Why do we need it?

Things to avoid:

• Complex / too scientific wording
• Too generic examples without practical context

Hints:

• We use a covariant type in Js.Promise.t (see it here)

Hello

In this file, the documentation is incorrect regarding JavaScript "Integer Division/Multiplication".
https://github.com/reason-association/rescript-lang.org/blob/cfb9ea89d3d42fee1ce3e8e67e76dd82e0fa49b1/pages/docs/manual/latest/overview.mdx

It states that in JavaScript 2 / 23 * 1 is integer division, but it is not.

Right now, there's a section that lists them, but information about how to use them is scattered in quite a few places, turning them into hidden knowledge. This will definitely confuse beginners and make them want to go back to their former community.

The link to a BS_VSCODE usage example is broken due to its removal in this rescript-lang/rescript-compiler#4187 PR

Hi,

It looks like the syntactic sugar about opening a module indicated on https://rescript-lang.org/docs/manual/latest/module#opening-a-module isn't valid anymore in rescript.

On the playground, the following code

module School = {
  type profession = Teacher | Director

  let person1 = Teacher
  let getProfession = (person) =>
    switch person {
    | Teacher => "A teacher"
    | Director => "A director"
    }
}

School.(getProfession(person1))

will produce the error

[E] Line 12, column 8:
I'm not sure what to parse here when looking at "(".

on the last line with the res syntax.

Currently there is a rogue ';' in the let binding section of the docs in the 'Design Decisions' section of the docs:

if displayGreeting {
  let message = "Enjoying the docs so far?"
  Js.log(message)
}; // <~ here

My understanding is that this is no longer necessary to have a semicolon here, so it can be dropped. Please let me know if I am mistaken as I'm not 100% confident given the changeover to ReScript and optional semicolons.

Could we please link to the old docs at https://bucklescript.netlify.app/ ? As a kindness for people who are still on versions of Bucklescript older than 8.0.0. The company where I work is doing our best to migrate to 8.0.0 but we're not there yet. No one on my team knew how to find the old docs, and the only reason I knew is because I asked on the Discord channel. It shouldn't be that hidden. Please, for the sake of long time bucklescript users, can we support the old docs a little?

Hello,
I have issues opening any page on https://rescript-lang.org/ on Firefox. I guess the issue is related with the noscript extension.
When opening the page, I briefly see the content, then the page goes blank, and the "A webpage is slowing down your browser" banner appears.
The console is spammed with the following error :

TypeError: o.apply is not a function
    NextJS 57

After stopping Js execution and opening the NoScript panel, the site went fine after activating scripts from jsdeliver.net

Here the |> is used which is deprecated.

"The above restriction might sound unpractical at first. How are would you change a value then? Usually, 2 ways:"

In the complex example there is a comment:

// this is matched only if `name` isn't "Joe"

Although it should be something like:

// this is matched only if `name` isn't "Mary" or "Joe"

In the guide to external it says:

Imagine writing a let binding, but

external is like a let binding, but:

So either something is missing in the first sentence or it can be removed altogether 🙂

The following syntax is undocumented:

module rec MyModule: MyModuleType = {
  ...
}

transferred from rescript-lang/rescript-compiler#4869 by @earksiinni

I encountered the following code in the wild:

type thunk('state) = ..;

type ReduxThunk.thunk(_) +=
  | StringAction (stringAction)
  | CounterAction (action);

This code essentially creates an "extensible variant" called thunk and adds two constructors to it. I'm not certain whether I'm using the right term to explain this feature since it's not described anywhere in the ReasonML or ReScript docs. It should be.

The ReScript docs also don't explain .., which is an elision, which is documented in ReasonML's docs on open objects. ReScript's docs don't talk about open objects at all, let alone elisions, but both sets of docs omit the fact that you can apparently use elisions to define extensible variants.

The use of the += feature isn't described anywhere in either set of docs, either.

It would be great to describe all these features, and while we're at it it would be great to have ReScript docs on polymorphic variants and how they differ from this kind of extensible non-polymorphic variant.

in the old website we have:

npm install -g bs-platform
bsb -init my-first-app -theme basic-reason
cd my-first-app
npm run start```

It's probably what 90% of the people would be using (isn't it the defacto standard for NodeJS as well at this point?).

Also it would be great to store the settings in localstorage, so they are restored on refresh

Hello everyone,

Today I was talking with a member of reasonml-editor on this PR reasonml-editor/reason-mode#53

We have a idea to create a separated mode to ReScript in my case I'll use in Emacs but I think it can be centralized to editor cases.

I created an organization called https://github.com/rescript-editor to create and share some modes, but I think it can be make at this community.

What do you think about?

In the first step I'm thinking to fork reason-mode to just support ReScript extensions files at Emacs.

@bobzhang is that runtime representation usable on the JS side now?

We recently found this really neat widget for discovering JS operators, and we think this is a really great way to look for dedicated syntax constructs as well.

Some rough implementation details on how this widget could be built:

We'd create a SyntaxWidget component, that will import some arbitrary markdown files as React components, and put them in an array of items.

type mdxComponent = Js.t({..}) => React.element
@module("./syntax-widget/decorator-module.mdx") external decoratorModule: mdxComponent = "default"

type item = {
  keywords: array<string>,
  summary: string,
  component: mdxComponent
}

let items = [
  keywords: ["bs.module", "module"],
  component: decoratorModule
];

let make = () => {
  // use state to fuzzy find through the keywords and get the right `component` item
   let component = findMatches(items);


   <div>
    <input type_="text" />
    <div>
        { component(Js.Obj.empty()) }        
    </div>
   </div>
 }

In our markdown file (probably within the pages/docs/manual/latest folder), we'd use our new component like this:

import { make as SyntaxWidget } from "components/SyntaxWidget"

<SyntaxWidget />

Remarks

With this implementation we are pretty flexible with editing the content in a separate syntax folder which could also act as our syntax spec documentation.

In case we need to be flexible with the styling, we could wrap the SyntaxWidget with a MdxProvider with custom a custom components prop.

I'm new in the ReScript community and haven't written any working code yet. So for now, I'm just covering all the listed language features and I have to admit that I already love it.

But I've found that the usage example of the Lazy Values feature is confusing. The biggest accent in the doc is made on the fact that the value is only computed once. Yeah, that's cool, but then I've remembered about another cool feature called something like block let binding (literally a self-called function) where value is also computed once when it initialized.

And then I had a dilemma then what for..., and realized that the biggest advantage of the Lazy Values feature is the Lazy.force that gives you total control under when you want to compute the value of a variable and either want to do it at all.

So as an example I think it's more appropriate to add something like this:

type payload =
  | NeedFilesWithLogHi
  | NeedFilesWithLogBye
  | NoResult
let getFiles =
  lazy({
    Js.log("Reading dir")
    Node.Fs.readdirSync("./pages")
  })

let data = NeedFilesWithLogHi
switch data {
| NeedFilesWithLogHi => {
  Js.log("Hi")
  getFiles
}
| NeedFilesWithLogBye => {
  Js.log("Bye")
  getFiles
| NoResult =>
  Js.log("Bah.")
}

We kind of define the lazy value in an upper scope, but don't compute it if this is not really necessary.

After that, I'll have a question "why not to use a normal function instead" and I'll gladly listen to your arguments that a lazy value is only computed once, doesn't have a runtime overhead etc-etc. I think at that point it will be more reasonable.

See https://forum.rescript-lang.org/t/how-to-use-js-belt-set-belt-map-dict/432/7?u=ryyppy

The following link: https://bucklescript.github.io/bucklescript/api/Dom.html

Redirects to: https://rescript-lang.org/apis/latest

Which does not have the Dom module available.

Right now when you are loading a shared URL, all the query parameters are getting stripped.
Actually we only want to remove code, because this particular query param can get out of date very easily.

Would also be great to update the query params in the url when a setting has been toggled

editor page in 8.2 docs points to reason-vscode which doesn't contain rescript syntax anymore

As a complete newbie teaching myself Rescript, it's very difficult to know what to google for when you're not sure on some syntax. I find it very useful to past a snippet into a tool like https://astexplorer.net to find out what's going on in the syntax.

Could such a tool be added to the playground? Maybe it would be easier to integrate Recript into astexplorer itself, such is the case for Reason: https://astexplorer.net/#/gist/3412c637cd5ffe6019f772f540d14365/f0a2a0945bba8cade7a1d28896409db872a0af0e

Hi!
It seems that the new website points to an old version (0.7, as opposed to the current 0.91) of reason-react (including old bs-platform)
https://rescript-lang.org/docs/reason-react/latest/introduction

Should we have a section showing companies/projects which are using rescript like what we had in old bucklescript and reason website?

Hello,
this issue is just a reminder that some documentation about module type of (cf https://caml.inria.fr/pub/docs/manual-ocaml/moduletypeof.html) would be welcome.
I could find an example usage here: rescript-lang/rescript-compiler#2765

Cheers,

Since we released the logo, our primary brand color fire has changed to a more red-pinkish value #e6484f.
We need to verify this change with the current website design

According to #102 there are apparently some missing pieces on features that ppl rely on.
This thread lists missing items, so we can add them back accordingly.

• bs.deriving (jsConverter, abstract)
• Node API docs
• decorator index pointing to the relevant sections

If anyone is missing some other information, please add this to this thread. Some features were initially left out, since there are a lot of features with duplicate functionality.

Looks like the docs are missing the setItem functions from the Dom.Storage modules.

On the blog: https://rescript-lang.org/blog

There is no article index, it's impossible to visit older articles.

Tried to show the playground to someone, but they didn't have it cached. It failed to load with a 403:

403: GET https://cdn.jsdelivr.net/gh/ryyppy/bs-platform-js-releases@latest/VERSIONS

Package size exceeded the configured limit of 50 MB. Try https://github.com/ryyppy/bs-platform-js-releases/tree/master/VERSIONS instead.

Would it be worth including an example of using %obj() in the section on Object Creation?

Edit: It's used in examples in the API docs, but not sure if it was intentionally omitted from the main docs or not. Thanks.

I recently looked at rescript-lang.org on a fresh browser and the twitter logo went full screen for half a sec, i'm assuming this happens b/c tailwind or the css doesn't load fast enough

not sure if this is a real big issue but wanted to post it anyway

After experimenting around a bit I felt like having the line-height smaller (putting every item closer together) was easier to read on the eyes.

The suggested differences:

before (current way):

after:

For people considering ReScript for full stack development I think it would help looking at what certain rescript snippet produces when compiled to OCaml. I think the reasonml Try already does that, since rescript is like the natural successor to reasonml. I think it would help to have that too may not on by default but a toggle in settings like there is for res and re syntaxes.

Between 768-850 pixels, the left navigation bar content moves off the screen.

(The Documentation)

According to the documentation and the definition, Js.Promise.then_ receives a callback as the first argument, and the promise to chain as the second argument. However, inside the documentation, -> is used instead of |>, which makes the code invalid.

According to the ReScript manual, a string "a" can be converted to char 'a' by .[0]

To convert a String to a Char, use "a".[0]. To convert a Char to a String, use String.make(1, 'a').

but the syntax is not working in ReScript.

>>>> Start compiling
bsb: [1/5] src/Test.ast
FAILED: src/Test.ast

  Syntax error!
  /home/cometkim/Workspace/tmp/rescript-template-test-8/src/Test.res:1:13

  1 │ let a = "a".[0]
  2 │

  I'm not sure what to parse here when looking at "[".


  Syntax error!
  /home/cometkim/Workspace/tmp/rescript-template-test-8/src/Test.res:1:14

  1 │ let a = "a".[0]
  2 │

  consecutive statements on a line must be separated by ';' or a newline

bsb: [2/5] src/App-MyRescriptApp.cmj
FAILED: src/App-MyRescriptApp.cmj

I'm not sure it's a compiler bug or It is just a mistake. I'd like to update the docs to use String.unsafe_get instead.