ReScript
@rescript-lang.org
https://rescript-lang.org/
Ship great products!
Ship great products!
In the next version of our vscode plugin 🚀:
github.com/rescript-lan...
github.com/rescript-lan...
November 11, 2025 at 8:04 PM
In the next version of our vscode plugin 🚀:
github.com/rescript-lan...
github.com/rescript-lan...
Yes, we might have too many binaries currently...
May 3, 2025 at 8:14 AM
Yes, we might have too many binaries currently...
Next up we have a talk about the new build system, Rewatch by Jaap Frolich.
May 3, 2025 at 8:11 AM
Next up we have a talk about the new build system, Rewatch by Jaap Frolich.
Even with a little code tour.
May 3, 2025 at 8:07 AM
Even with a little code tour.
Good morning!
We are currently kicking off this year's ReScript Retreat with a talk about editor tooling by @z-th.bsky.social and @nojaf.com.
We are currently kicking off this year's ReScript Retreat with a talk about editor tooling by @z-th.bsky.social and @nojaf.com.
May 3, 2025 at 7:42 AM
Good morning!
We are currently kicking off this year's ReScript Retreat with a talk about editor tooling by @z-th.bsky.social and @nojaf.com.
We are currently kicking off this year's ReScript Retreat with a talk about editor tooling by @z-th.bsky.social and @nojaf.com.
We just landed a new (experimental) feature for v12 - nested record definitions!
Records is a corner stone in ReScript. However, they can't be nested without explicit definitions. Until now!
Will be especially useful for deeply nested records (like options objects) not intended to be reused.
Records is a corner stone in ReScript. However, they can't be nested without explicit definitions. Until now!
Will be especially useful for deeply nested records (like options objects) not intended to be reused.
March 20, 2025 at 5:37 PM
We just landed a new (experimental) feature for v12 - nested record definitions!
Records is a corner stone in ReScript. However, they can't be nested without explicit definitions. Until now!
Will be especially useful for deeply nested records (like options objects) not intended to be reused.
Records is a corner stone in ReScript. However, they can't be nested without explicit definitions. Until now!
Will be especially useful for deeply nested records (like options objects) not intended to be reused.
One approach is using separate records for grouping related props, and then use record spreads to share them.
Playground: rescript-lang.org/try?version=...
Playground: rescript-lang.org/try?version=...
January 15, 2025 at 6:05 PM
One approach is using separate records for grouping related props, and then use record spreads to share them.
Playground: rescript-lang.org/try?version=...
Playground: rescript-lang.org/try?version=...
Records are powerful, but you need explicit definitions for them. We're experimenting with allowing inline record definitions nested inside a record type definition.
This will make some of the common use cases for records more ergonomic.
This will make some of the common use cases for records more ergonomic.
January 13, 2025 at 1:06 PM
Records are powerful, but you need explicit definitions for them. We're experimenting with allowing inline record definitions nested inside a record type definition.
This will make some of the common use cases for records more ergonomic.
This will make some of the common use cases for records more ergonomic.
The new dot completion also works for objects.
Objects are structurally typed, doesn't need a type definition, and are quite useful in some scenarios.
Completion for object fields will be more ergonomic and get better discoverability with this addition.
Objects are structurally typed, doesn't need a type definition, and are quite useful in some scenarios.
Completion for object fields will be more ergonomic and get better discoverability with this addition.
January 4, 2025 at 3:10 PM
The new dot completion also works for objects.
Objects are structurally typed, doesn't need a type definition, and are quite useful in some scenarios.
Completion for object fields will be more ergonomic and get better discoverability with this addition.
Objects are structurally typed, doesn't need a type definition, and are quite useful in some scenarios.
Completion for object fields will be more ergonomic and get better discoverability with this addition.
With the new dot completion enhancements in our editor tooling you'll now get completions from the Option module when autocompleting on a record field that's an optional value, instead of just no completions like before.
January 3, 2025 at 10:37 AM
With the new dot completion enhancements in our editor tooling you'll now get completions from the Option module when autocompleting on a record field that's an optional value, instead of just no completions like before.
You'll now also get pipe completions when you do dot completion on any type, not just records.
And additionally, you can even configure per type to have the editor give completions from additional modules, not just the module it belongs to.
And additionally, you can even configure per type to have the editor give completions from additional modules, not just the module it belongs to.
January 2, 2025 at 10:19 AM
You'll now also get pipe completions when you do dot completion on any type, not just records.
And additionally, you can even configure per type to have the editor give completions from additional modules, not just the module it belongs to.
And additionally, you can even configure per type to have the editor give completions from additional modules, not just the module it belongs to.
For newcomers, one of the differences to JS is using pipes where you'd normally use method chaining. This takes a bit of time to learn.
To fix this, you now get pipe completions from dots as well.
So the experience is like in JS, but an actual pipe is inserted on completion.
To fix this, you now get pipe completions from dots as well.
So the experience is like in JS, but an actual pipe is inserted on completion.
January 2, 2025 at 10:19 AM
For newcomers, one of the differences to JS is using pipes where you'd normally use method chaining. This takes a bit of time to learn.
To fix this, you now get pipe completions from dots as well.
So the experience is like in JS, but an actual pipe is inserted on completion.
To fix this, you now get pipe completions from dots as well.
So the experience is like in JS, but an actual pipe is inserted on completion.
Type inference is simple but powerful. The compiler will infer each type that's unknown by usage.
A consequence of this is that prop drilling is really simple, because you rarely have to annotate props. Just using the prop in the component defining it is usually enough.
A consequence of this is that prop drilling is really simple, because you rarely have to annotate props. Just using the prop in the component defining it is usually enough.
December 3, 2024 at 10:13 AM
Type inference is simple but powerful. The compiler will infer each type that's unknown by usage.
A consequence of this is that prop drilling is really simple, because you rarely have to annotate props. Just using the prop in the component defining it is usually enough.
A consequence of this is that prop drilling is really simple, because you rarely have to annotate props. Just using the prop in the component defining it is usually enough.
In ReScript, pipes are normally used for chaining fn calls instead of method chaining with dots like in JS.
This is a common gotcha for JS/TS devs who come to ReScript. To ease the transition we're experimenting with letting the editor tooling complete pipes also via dots.
This is a common gotcha for JS/TS devs who come to ReScript. To ease the transition we're experimenting with letting the editor tooling complete pipes also via dots.
November 29, 2024 at 9:19 AM
In ReScript, pipes are normally used for chaining fn calls instead of method chaining with dots like in JS.
This is a common gotcha for JS/TS devs who come to ReScript. To ease the transition we're experimenting with letting the editor tooling complete pipes also via dots.
This is a common gotcha for JS/TS devs who come to ReScript. To ease the transition we're experimenting with letting the editor tooling complete pipes also via dots.
In ReScript you can put expressions almost anywhere. Assign expressions to variables, put them anywhere in JSX, put them directly into function arguments, etc.
Massive readability and productivity boosters, and you'll love it if you haven't written in a language with it before.
Massive readability and productivity boosters, and you'll love it if you haven't written in a language with it before.
November 28, 2024 at 8:23 AM
In ReScript you can put expressions almost anywhere. Assign expressions to variables, put them anywhere in JSX, put them directly into function arguments, etc.
Massive readability and productivity boosters, and you'll love it if you haven't written in a language with it before.
Massive readability and productivity boosters, and you'll love it if you haven't written in a language with it before.
Since v11, ReScript has support for explicit partial application of functions using the "..." syntax at the end of the function call.
Partial application of functions is useful in many scenarios, and this explicit syntax makes code easier to read and reason about.
Partial application of functions is useful in many scenarios, and this explicit syntax makes code easier to read and reason about.
November 27, 2024 at 9:13 AM
Since v11, ReScript has support for explicit partial application of functions using the "..." syntax at the end of the function call.
Partial application of functions is useful in many scenarios, and this explicit syntax makes code easier to read and reason about.
Partial application of functions is useful in many scenarios, and this explicit syntax makes code easier to read and reason about.
Pipes are one of the most powerful concepts in ReScript. Pipes let you build function chains easily, with great support for type inference, and great editor support like autocomplete.
It's just a syntax transform, so it compiles to regular, efficient JS function calls.
It's just a syntax transform, so it compiles to regular, efficient JS function calls.
November 26, 2024 at 8:39 AM
Pipes are one of the most powerful concepts in ReScript. Pipes let you build function chains easily, with great support for type inference, and great editor support like autocomplete.
It's just a syntax transform, so it compiles to regular, efficient JS function calls.
It's just a syntax transform, so it compiles to regular, efficient JS function calls.
ReScript has first class support for tagged template literals since v11.1.
A useful JS technique that's important for interop, and lends itself well to some pretty interesting use cases!
A useful JS technique that's important for interop, and lends itself well to some pretty interesting use cases!
November 22, 2024 at 7:26 AM
ReScript has first class support for tagged template literals since v11.1.
A useful JS technique that's important for interop, and lends itself well to some pretty interesting use cases!
A useful JS technique that's important for interop, and lends itself well to some pretty interesting use cases!
Dynamic imports shipped in ReScript v11. You can easily import both entire file modules, as well as single functions.
For file modules, you simply await the module itself.
For single functions, you use the `import` function.
Makes things like React.lazy easy to use.
For file modules, you simply await the module itself.
For single functions, you use the `import` function.
Makes things like React.lazy easy to use.
November 21, 2024 at 2:45 PM
Dynamic imports shipped in ReScript v11. You can easily import both entire file modules, as well as single functions.
For file modules, you simply await the module itself.
For single functions, you use the `import` function.
Makes things like React.lazy easy to use.
For file modules, you simply await the module itself.
For single functions, you use the `import` function.
Makes things like React.lazy easy to use.
JSX is a 1st class language feature in ReScript. Since v11.1 you've been able to use any createElement-style JSX transform you'd like with ReScript.
Image shows Preact, but there are examples in the community even for non-client side fws, like emitting plain HTML server side.
Image shows Preact, but there are examples in the community even for non-client side fws, like emitting plain HTML server side.
November 20, 2024 at 7:59 AM
JSX is a 1st class language feature in ReScript. Since v11.1 you've been able to use any createElement-style JSX transform you'd like with ReScript.
Image shows Preact, but there are examples in the community even for non-client side fws, like emitting plain HTML server side.
Image shows Preact, but there are examples in the community even for non-client side fws, like emitting plain HTML server side.
ReScript ships with native async/await support that also compiles to async/await in JavaScript.
You can pattern match directly on the await, and handle errors in the pattern match as well.
No need to wrap things manually in try/catch, the compiler still emits the right thing.
You can pattern match directly on the await, and handle errors in the pattern match as well.
No need to wrap things manually in try/catch, the compiler still emits the right thing.
November 19, 2024 at 7:52 AM
ReScript ships with native async/await support that also compiles to async/await in JavaScript.
You can pattern match directly on the await, and handle errors in the pattern match as well.
No need to wrap things manually in try/catch, the compiler still emits the right thing.
You can pattern match directly on the await, and handle errors in the pattern match as well.
No need to wrap things manually in try/catch, the compiler still emits the right thing.
We shipped a %todo extension point in v11.1. It makes it easy to postpone implementing something but not have the compiler block you continuing working.
It'll produce a warning by default, and it's easy to configure the compiler so that it emits a hard error in for example CI.
It'll produce a warning by default, and it's easy to configure the compiler so that it emits a hard error in for example CI.
November 18, 2024 at 8:58 AM
We shipped a %todo extension point in v11.1. It makes it easy to postpone implementing something but not have the compiler block you continuing working.
It'll produce a warning by default, and it's easy to configure the compiler so that it emits a hard error in for example CI.
It'll produce a warning by default, and it's easy to configure the compiler so that it emits a hard error in for example CI.
We'll ship our new standard library Core by default in v12.
Core replaces the current standard lib and most of Belt, with one unified experienced that's built to look and feel more like the JavaScript APIs you're used to, while not sacrificing ergonomics.
Core replaces the current standard lib and most of Belt, with one unified experienced that's built to look and feel more like the JavaScript APIs you're used to, while not sacrificing ergonomics.
November 14, 2024 at 7:54 AM
We'll ship our new standard library Core by default in v12.
Core replaces the current standard lib and most of Belt, with one unified experienced that's built to look and feel more like the JavaScript APIs you're used to, while not sacrificing ergonomics.
Core replaces the current standard lib and most of Belt, with one unified experienced that's built to look and feel more like the JavaScript APIs you're used to, while not sacrificing ergonomics.
We're further closing the syntax gap between ReScript and JavaScript in in v12:
- First class regex syntax (previously needed wrapping in %re("<pattern>"))
- Remainder operator
- Use +, -, / and * for any number type, dedicated operators per type not needed
And more coming!
- First class regex syntax (previously needed wrapping in %re("<pattern>"))
- Remainder operator
- Use +, -, / and * for any number type, dedicated operators per type not needed
And more coming!
November 13, 2024 at 8:25 AM
We're further closing the syntax gap between ReScript and JavaScript in in v12:
- First class regex syntax (previously needed wrapping in %re("<pattern>"))
- Remainder operator
- Use +, -, / and * for any number type, dedicated operators per type not needed
And more coming!
- First class regex syntax (previously needed wrapping in %re("<pattern>"))
- Remainder operator
- Use +, -, / and * for any number type, dedicated operators per type not needed
And more coming!
Another new feature in v12 - variant type spreads in pattern matching!
This allows you to refine variant types and easily match on a whole subset type without having to enumerate it.
This was always possible with polyvariants, and now also with regular variants.
This allows you to refine variant types and easily match on a whole subset type without having to enumerate it.
This was always possible with polyvariants, and now also with regular variants.
November 12, 2024 at 8:46 AM
Another new feature in v12 - variant type spreads in pattern matching!
This allows you to refine variant types and easily match on a whole subset type without having to enumerate it.
This was always possible with polyvariants, and now also with regular variants.
This allows you to refine variant types and easily match on a whole subset type without having to enumerate it.
This was always possible with polyvariants, and now also with regular variants.