Js

The Js module mostly contains ReScript bindings to standard JavaScript APIs like console.log, or the JavaScript String, Date, and Promise classes.

It is meant as a zero-abstraction interop layer and directly exposes JavaScript functions as they are. If you can find your API in this module, prefer this over an equivalent Belt helper. For example, prefer Js.Array2 over Belt.Array

Argument Order

For historical reasons, some APIs in the Js namespace (e.g. Js.String) are using the data-last argument order whereas others (e.g. Js.Date) are using data-first.

For more information about these argument orders and the trade-offs between them, see this blog post.

Eventually, all modules in the Js namespace are going to be migrated to data-first though.

In the meantime, there are several options for dealing with the data-last APIs:

RES
/* Js.String (data-last API used with pipe last operator) */
Js.log("2019-11-10" |> Js.String.split("-"))
Js.log("ReScript" |> Js.String.startsWith("Re"))

/* Js.String (data-last API used with pipe first operator) */
Js.log("2019-11-10"->Js.String.split("-", _))
Js.log("ReScript"->Js.String.startsWith("Re", _))

/* Js.String (data-last API used without any piping) */
Js.log(Js.String.split("-", "2019-11-10"))
Js.log(Js.String.startsWith("Re", "ReScript"))

Js.Xxx2 Modules

Prefer Js.Array2 over Js.Array, Js.String2 over Js.String, etc. The latters are old modules.

Object

type t<+'a>

Js object type.

RES
let x: {"x": int, "y": int} = {"x": 1, "y": 2}

Nullable and Undefined

RES
type null<+'a>

nullable, value of this type can be either null or 'a this type is the same as type t in Js.Null

RES
type undefined<+'a>

value of this type can be either undefined or 'a this type is the same as type t in Js.Undefined

RES
type nullable<+'a>

value of this type can be undefined, null or 'a this type is the same as type t n Js.Null_undefined

RES
type null_undefined<'a> = Js.nullable<'a>

let toOption: Js.nullable<'a> => option<'a>

let undefinedToOption: Js.undefined<'a> => option<'a>

let nullToOption: Js.null<'a> => option<'a>

let test: Js.nullable<'a> => bool

let isNullable: Js.nullable<'a> => bool

let testAny: 'a => bool

The same as Js.test except that it is more permissive on the types of input.

type promise<+'a, +'e>

Deprecated. please use Js.Promise. The promise type, defined here for interoperation across packages.

let null: Js.null<'a>

The same as empty in Js.Null. Will be compiled as null.

let undefined: Js.undefined<'a>

The same as empty Js.Undefined. Will be compiled as undefined.

TypeOf

let typeof: 'a => string

typeof x will be compiled as typeof x in JS. Please consider functions in Js.Types for a type safe way of reflection.

Logging

let log: 'a => unit
let log2: ('a, 'b) => unit
let log3: ('a, 'b, 'c) => unit
let log4: ('a, 'b, 'c, 'd) => unit

A convenience function to log everything.

let logMany: array<'a> => unit

A convenience function to log more than 4 arguments

Comparison

let eqNull: ('a, null<'a>) => bool
let eqUndefined: ('a, undefined<'a>) => bool
let eqNullable: ('a, nullable<'a>) => bool

let unsafe_lt: ('a, 'a) => bool

unsafe_lt a b will be compiled as a < b. It is marked as unsafe, since it is impossible to give a proper semantics for comparision which applies to any type.

let unsafe_le: ('a, 'a) => bool

unsafe_le a b will be compiled as a <= b. See also Js.unsafe_lt.

let unsafe_gt: ('a, 'a) => bool

unsafe_gt a b will be compiled as a > b. See also Js.unsafe_lt.

let unsafe_ge: ('a, 'a) => bool

unsafe_ge a b will be compiled as a >= b. See also Js.unsafe_lt.