ReasonML是否支持async/await？其与现代ES该语法的等价实现是什么？

Hey there! Great question—you’re right that the JS→Reason cheat sheet misses async/await coverage, but ReasonML absolutely has solid support for asynchronous code, just with its own idiomatic twists that map directly to what you’re used to in modern JS.

Short Answer #

ReasonML doesn’t use the exact async/await keyword pair out of the box, but it provides equivalent (and type-safe!) syntax and utilities to handle asynchronous operations, fully compatible with JavaScript Promises.

1. Idiomatic Async/Await Equivalent (Syntax Sugar) #

You can use ReasonML’s async function modifier and await binding to replicate JS’s async/await behavior almost exactly. This relies on BuckleScript (now ReScript, fully compatible with ReasonML syntax)’s support for asynchronous syntax.

Example: JS vs ReasonML

JavaScript:

async function fetchUser(userId) {
  try {
    const response = await fetch(`/api/users/${userId}`);
    if (!response.ok) throw new Error("Request failed");
    const user = await response.json();
    return user.username;
  } catch (err) {
    console.error("Error:", err);
    return "Guest";
  }
}

ReasonML Equivalent:

let fetchUser = async (userId) => {
  try {
    let response = await Js.Fetch.fetch(`/api/users/${userId}`);
    if (Js.Fetch.Response.ok(response) === false) {
      Js.Exn.raiseError("Request failed");
    };
    let user = await Js.Fetch.Response.json(response);
    user##username;
  } catch (err) {
    Js.log2("Error:", err);
    "Guest";
  };
};

• The async keyword marks the function as returning a Js.Promise.t<'a> (Reason’s typed version of a JS Promise).
• await unwraps the value inside a Promise, just like in JS—you can use it anywhere you’d use await in JavaScript.
• The type system will enforce that you only await values that are Promises, preventing common JS async bugs.

2. Manual Promise Chaining (No Syntax Sugar) #

If you prefer to avoid syntax sugar (or need more control), you can use Js.Promise.bind and Js.Promise.catch to chain operations, which is the underlying implementation of the async/await syntax.

Equivalent to the above example:

let fetchUser = (userId) => {
  Js.Fetch.fetch(`/api/users/${userId}`)
  |> Js.Promise.bind(response => {
       if (Js.Fetch.Response.ok(response) === false) {
         Js.Promise.reject(Js.Exn.make("Request failed"));
       } else {
         Js.Fetch.Response.json(response);
       };
     })
  |> Js.Promise.bind(user => Js.Promise.resolve(user##username))
  |> Js.Promise.catch(err => {
       Js.log2("Error:", err);
       Js.Promise.resolve("Guest");
     });
};

Key Notes #

• ReasonML’s async system is fully interoperable with JavaScript: you can call JS async functions from Reason and vice versa without extra work.
• Ensure your bsconfig.json is configured to support ReasonML syntax (set "reason": {"react-jsx": 3} or similar, depending on your setup) and uses a recent version of BuckleScript/ReScript.
• The type safety of ReasonML means you’ll get compile-time errors if you try to use non-Promise values with await, or if you mishandle Promise types—something JS can’t offer.

内容的提问来源于stack exchange，提问作者sdgfsdh