You are currently looking at the v6.0 - v8.2 docs (Reason v3.6 syntax edition). You can find the latest manual page here.
(These docs are equivalent to the old BuckleScript docs before the ReScript rebrand)
Variant
So far, most of ReScript's data structures might look familiar to you. This section introduces an extremely important, and perhaps unfamiliar, data structure: variant.
Most data structures in most languages are about "this and that". A variant allows us to express "this or that".
type myResponse =
| Yes
| No
| PrettyMuch;
let areYouCrushingIt = Yes;
myResponse
is a variant type with the cases Yes
, No
and PrettyMuch
, which are called "variant constructors" (or "variant tag"). The |
bar separates each constructor.
Note: a variant's constructors need to be capitalized.
Variant Needs an Explicit Definition
If the variant you're using is in a different file, bring it into scope like you'd do for a record:
// Zoo.re
type animal = Dog | Cat | Bird;
// Example.re
let pet: Zoo.animal = Dog; // preferred
// or
let pet2 = Zoo.Dog;
Constructor Arguments
A variant's constructors can hold extra data separated by comma.
type account =
| None
| Instagram(string)
| Facebook(string, int);
Here, Instagram
holds a string
, and Facebook
holds a string
and an int
. Usage:
let myAccount = Facebook("Josh", 26);
let friendAccount = Instagram("Jenny");
Records in Variants
You can use a record type in a variant:
type idType = {name: string, password: string};
type user =
| Number(int)
| Id(idType);
If the record type is used only in the variant definition, you may put it in line:
type user =
| Number(int)
| Id({name: string, password: string});
Pattern Matching On Variant
See the Pattern Matching/Destructuring section later.
Tips & Tricks
Be careful not to confuse a constructor carrying 2 arguments with a constructor carrying a single tuple argument:
type account =
| Facebook(string, int); // 2 arguments
type account2 =
| Instagram((string, int)); // 1 argument - happens to be a 2-tuple
If you come from an untyped language, you might be tempted to try type myType = int | string
. This isn't possible in ReScript; you'd have to give each branch a constructor: type myType = Int(int) | String(string)
. The former looks nice, but causes lots of trouble down the line.
Interop with JavaScript
This section assumes knowledge about our JavaScript interop. Skip this if you haven't felt the itch to use variants for wrapping JS functions yet.
Quite a few JS libraries use functions that can accept many types of arguments. In these cases, it's very tempting to model them as variants. For example, suppose there's a myLibrary.draw
JS function that takes in either a number
or a string
. You might be tempted to bind it like so:
// reserved for internal usage
[@bs.module "myLibrary"] external draw: 'a => unit = "draw";
type animal =
| MyFloat(float)
| MyString(string);
let betterDraw = (animal) =>
switch (animal) {
| MyFloat(f) => draw(f)
| MyString(s) => draw(s)
};
betterDraw(MyFloat(1.5));
You could definitely do that, but there are better ways! For example, define two external
s that both compile to the same JS call:
[@bs.module "myLibrary"] external drawFloat: float => unit = "draw";
[@bs.module "myLibrary"] external drawString: string => unit = "draw";
ReScript also provides a few other ways to do this.
Variant Types Are Found By Field Name
Please refer to this record section. Variants are the same: a function can't accept an arbitrary constructor shared by two different variants. Again, such feature exists; it's called a polymorphic variant. We'll talk about this in the future =).
Design Decisions
Variants, in their many forms (polymorphic variant, open variant, GADT, etc.), are likely the feature of a type system such as ReScript's. The aforementioned option
variant, for example, obliterates the need for nullable types, a major source of bugs in other languages. Philosophically speaking, a problem is composed of many possible branches/conditions. Mishandling these conditions is the majority of what we call bugs. A type system doesn't magically eliminate bugs; it points out the unhandled conditions and asks you to cover them*. The ability to model "this or that" correctly is crucial.
For example, some folks wonder how the type system can safely eliminate badly formatted JSON data from propagating into their program. They don't, not by themselves! But if the parser returns the option
type None | Some(actualData)
, then you'd have to handle the None
case explicitly in later call sites. That's all there is.
Performance-wise, a variant can potentially tremendously speed up your program's logic. Here's a piece of JavaScript:
JSlet data = 'dog'
if (data === 'dog') {
...
} else if (data === 'cat') {
...
} else if (data === 'bird') {
...
}
There's a linear amount of branch checking here (O(n)
). Compare this to using a ReScript variant:
type animal = Dog | Cat | Bird;
let data = Dog
switch (data) {
| Dog => Js.log("Wof")
| Cat => Js.log("Meow")
| Bird => Js.log("Kashiiin")
}
The compiler sees the variant, then
conceptually turns them into
type animal = 0 | 1 | 2
compiles
switch
to a constant-time jump table (O(1)
).