Module Js

type +'a null

type null(+'a);

A value of this type can be either null or 'a. This type is the same as type t in Null

type +'a undefined

type undefined(+'a);

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

type +'a nullable

type nullable(+'a);

A value of this type can be undefined, null or 'a. This type is the same as type t n Nullable

type re

type re;

The type for JavaScript RegExp

type 'a dict

type dict('a);

The type for a simple key-value dictionary abstraction over native JavaScript objects

type 'a iterator

type iterator('a);

The type for JavaScript iterators

type 'a array_like

type array_like('a);

The type for array-like objects in JavaScript

type bigint

type bigint;

The type for JavaScript BigInt

type +'a promise

type promise(+'a);

The type for JavaScript Promise

type blob

type blob;

The type for JavaScript Blob

type file

type file;

The type for JavaScript File

type arrayBuffer

type arrayBuffer;

type int8Array

type int8Array;

type uint8Array

type uint8Array;

type uint8ClampedArray

type uint8ClampedArray;

type int16Array

type int16Array;

type uint16Array

type uint16Array;

type int32Array

type int32Array;

type uint32Array

type uint32Array;

type float32Array

type float32Array;

type float64Array

type float64Array;

val toOption : 'a nullable -> 'a option

let toOption: nullable('a) => option('a);

val undefinedToOption : 'a undefined -> 'a option

let undefinedToOption: undefined('a) => option('a);

val nullToOption : 'a null -> 'a option

let nullToOption: null('a) => option('a);

val isNullable : 'a nullable -> bool

let isNullable: nullable('a) => bool;

val import : 'a -> 'a promise

let import: 'a => promise('a);

TODO(anmonteiro): document

val testAny : 'a -> bool

let testAny: 'a => bool;

The same as isNullable except that it is more permissive on the types of input

val null : 'a null

let null: null('a);

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

val undefined : 'a undefined

let undefined: undefined('a);

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

val typeof : 'a -> string

let typeof: 'a => string;

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

val log : 'a -> unit

let log: 'a => unit;

A convenience function to log everything

val log2 : 'a -> 'b -> unit

let log2: 'a => 'b => unit;

val log3 : 'a -> 'b -> 'c -> unit

let log3: 'a => 'b => 'c => unit;

val log4 : 'a -> 'b -> 'c -> 'd -> unit

let log4: 'a => 'b => 'c => 'd => unit;

val logMany : 'a array -> unit

let logMany: array('a) => unit;

A convenience function to log more than 4 arguments

val eqNull : 'a -> 'a null -> bool

let eqNull: 'a => null('a) => bool;

val eqUndefined : 'a -> 'a undefined -> bool

let eqUndefined: 'a => undefined('a) => bool;

val eqNullable : 'a -> 'a nullable -> bool

let eqNullable: 'a => nullable('a) => bool;

Operators

val unsafe_lt : 'a -> '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

val unsafe_le : 'a -> 'a -> bool

let unsafe_le: 'a => 'a => bool;

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

val unsafe_gt : 'a -> 'a -> bool

let unsafe_gt: 'a => 'a => bool;

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

val unsafe_ge : 'a -> 'a -> bool

let unsafe_ge: 'a => 'a => bool;

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

Types for JS objects

type 'a t

type t('a);

This used to be mark a Js object type.

module Exn : sig ... end

module Exn: { ... };

Utilities for dealing with Js exceptions

module String : sig ... end

module String: { ... };

Bindings to the functions in String.prototype

module Null : sig ... end

module Null: { ... };

Utility functions on null

module Undefined : sig ... end

module Undefined: { ... };

Utility functions on undefined

module Nullable : sig ... end

module Nullable: { ... };

Utility functions on nullable

module Array : sig ... end

module Array: { ... };

Bindings to the functions in Array.prototype

module Re : sig ... end

module Re: { ... };

Bindings to the functions in RegExp.prototype

module Promise : sig ... end

module Promise: { ... };

Bindings to JS Promise functions

module Date : sig ... end

module Date: { ... };

Bindings to the functions in JS's Date.prototype

module Dict : sig ... end

module Dict: { ... };

Utility functions to treat a JS object as a dictionary

module Global : sig ... end

module Global: { ... };

Bindings to functions in the JS global namespace

module Json : sig ... end

module Json: { ... };

Utility functions to manipulate JSON values

module Math : sig ... end

module Math: { ... };

Bindings to the functions in the Math object

module Obj : sig ... end

module Obj: { ... };

Utility functions on `Js.t` JS objects

module Typed_array : sig ... end

module Typed_array: { ... };

Bindings to the functions in TypedArray.prototype

module Types : sig ... end

module Types: { ... };

Utility functions for runtime reflection on JS types

module Float : sig ... end

module Float: { ... };

Bindings to functions in JavaScript's Number that deal with floats

module Int : sig ... end

module Int: { ... };

Bindings to functions in JavaScript's Number that deal with ints

module Bigint : sig ... end

module Bigint: { ... };

Bindings to functions in JavaScript's BigInt

module Console : sig ... end

module Console: { ... };

module Set : sig ... end

module Set: { ... };

Bindings to functions in Set

module WeakSet : sig ... end

module WeakSet: { ... };

Bindings to functions in WeakSet

module Map : sig ... end

module Map: { ... };

Bindings to functions in Map

module WeakMap : sig ... end

module WeakMap: { ... };

Bindings to functions in WeakMap

module Iterator : sig ... end

module Iterator: { ... };

Bindings to functions on Iterator

module Blob : sig ... end

module Blob: { ... };

Bindings to Blob

module File : sig ... end

module File: { ... };

Bindings to File

module ReadableStream : sig ... end

module ReadableStream: { ... };

Bindings to ReadableStream

module FormData : sig ... end

module FormData: { ... };

Bindings to FormData

module Fetch : sig ... end

module Fetch: { ... };

Abstract types for Fetch