Standard Library
Below is the API for the OCaml standard library. It's directly copied over from the OCaml Manual, formatted to the Reason syntax and styled accordingly. The API docs are work-in-progress; we'll be polishing these gradually!
If you're targeting JavaScript, the API docs for BuckleScript includes all of below, plus JS-specific APIs.
sig
module Hashtbl :
sig
type ('a, 'b) t = ('a, 'b) Hashtbl.t
val create : ?random:bool -> int -> ('a, 'b) MoreLabels.Hashtbl.t
val clear : ('a, 'b) MoreLabels.Hashtbl.t -> unit
val reset : ('a, 'b) MoreLabels.Hashtbl.t -> unit
val copy :
('a, 'b) MoreLabels.Hashtbl.t -> ('a, 'b) MoreLabels.Hashtbl.t
val add : ('a, 'b) MoreLabels.Hashtbl.t -> key:'a -> data:'b -> unit
val find : ('a, 'b) MoreLabels.Hashtbl.t -> 'a -> 'b
val find_all : ('a, 'b) MoreLabels.Hashtbl.t -> 'a -> 'b list
val mem : ('a, 'b) MoreLabels.Hashtbl.t -> 'a -> bool
val remove : ('a, 'b) MoreLabels.Hashtbl.t -> 'a -> unit
val replace :
('a, 'b) MoreLabels.Hashtbl.t -> key:'a -> data:'b -> unit
val iter :
f:(key:'a -> data:'b -> unit) ->
('a, 'b) MoreLabels.Hashtbl.t -> unit
val fold :
f:(key:'a -> data:'b -> 'c -> 'c) ->
('a, 'b) MoreLabels.Hashtbl.t -> init:'c -> 'c
val length : ('a, 'b) MoreLabels.Hashtbl.t -> int
val randomize : unit -> unit
type statistics = Hashtbl.statistics
val stats :
('a, 'b) MoreLabels.Hashtbl.t -> MoreLabels.Hashtbl.statistics
module type HashedType = Hashtbl.HashedType
module type SeededHashedType = Hashtbl.SeededHashedType
module type S =
sig
type key
and 'a t
val create : int -> 'a MoreLabels.Hashtbl.S.t
val clear : 'a MoreLabels.Hashtbl.S.t -> unit
val reset : 'a MoreLabels.Hashtbl.S.t -> unit
val copy : 'a MoreLabels.Hashtbl.S.t -> 'a MoreLabels.Hashtbl.S.t
val add :
'a MoreLabels.Hashtbl.S.t ->
key:MoreLabels.Hashtbl.S.key -> data:'a -> unit
val remove :
'a MoreLabels.Hashtbl.S.t -> MoreLabels.Hashtbl.S.key -> unit
val find :
'a MoreLabels.Hashtbl.S.t -> MoreLabels.Hashtbl.S.key -> 'a
val find_all :
'a MoreLabels.Hashtbl.S.t -> MoreLabels.Hashtbl.S.key -> 'a list
val replace :
'a MoreLabels.Hashtbl.S.t ->
key:MoreLabels.Hashtbl.S.key -> data:'a -> unit
val mem :
'a MoreLabels.Hashtbl.S.t -> MoreLabels.Hashtbl.S.key -> bool
val iter :
f:(key:MoreLabels.Hashtbl.S.key -> data:'a -> unit) ->
'a MoreLabels.Hashtbl.S.t -> unit
val fold :
f:(key:MoreLabels.Hashtbl.S.key -> data:'a -> 'b -> 'b) ->
'a MoreLabels.Hashtbl.S.t -> init:'b -> 'b
val length : 'a MoreLabels.Hashtbl.S.t -> int
val stats :
'a MoreLabels.Hashtbl.S.t -> MoreLabels.Hashtbl.statistics
end
module type SeededS =
sig
type key
and 'a t
val create : ?random:bool -> int -> 'a MoreLabels.Hashtbl.SeededS.t
val clear : 'a MoreLabels.Hashtbl.SeededS.t -> unit
val reset : 'a MoreLabels.Hashtbl.SeededS.t -> unit
val copy :
'a MoreLabels.Hashtbl.SeededS.t ->
'a MoreLabels.Hashtbl.SeededS.t
val add :
'a MoreLabels.Hashtbl.SeededS.t ->
key:MoreLabels.Hashtbl.SeededS.key -> data:'a -> unit
val remove :
'a MoreLabels.Hashtbl.SeededS.t ->
MoreLabels.Hashtbl.SeededS.key -> unit
val find :
'a MoreLabels.Hashtbl.SeededS.t ->
MoreLabels.Hashtbl.SeededS.key -> 'a
val find_all :
'a MoreLabels.Hashtbl.SeededS.t ->
MoreLabels.Hashtbl.SeededS.key -> 'a list
val replace :
'a MoreLabels.Hashtbl.SeededS.t ->
key:MoreLabels.Hashtbl.SeededS.key -> data:'a -> unit
val mem :
'a MoreLabels.Hashtbl.SeededS.t ->
MoreLabels.Hashtbl.SeededS.key -> bool
val iter :
f:(key:MoreLabels.Hashtbl.SeededS.key -> data:'a -> unit) ->
'a MoreLabels.Hashtbl.SeededS.t -> unit
val fold :
f:(key:MoreLabels.Hashtbl.SeededS.key -> data:'a -> 'b -> 'b) ->
'a MoreLabels.Hashtbl.SeededS.t -> init:'b -> 'b
val length : 'a MoreLabels.Hashtbl.SeededS.t -> int
val stats :
'a MoreLabels.Hashtbl.SeededS.t -> MoreLabels.Hashtbl.statistics
end
module Make :
functor (H : HashedType) ->
sig
type key = H.t
and 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key:key -> data:'a -> unit
val mem : 'a t -> key -> bool
val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
val fold :
f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
end
module MakeSeeded :
functor (H : SeededHashedType) ->
sig
type key = H.t
and 'a t
val create : ?random:bool -> int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key:key -> data:'a -> unit
val mem : 'a t -> key -> bool
val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
val fold :
f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
end
val hash : 'a -> int
val seeded_hash : int -> 'a -> int
val hash_param : int -> int -> 'a -> int
val seeded_hash_param : int -> int -> int -> 'a -> int
end
module Map :
sig
module type OrderedType = Map.OrderedType
module type S =
sig
type key
and +'a t
val empty : 'a MoreLabels.Map.S.t
val is_empty : 'a MoreLabels.Map.S.t -> bool
val mem : MoreLabels.Map.S.key -> 'a MoreLabels.Map.S.t -> bool
val add :
key:MoreLabels.Map.S.key ->
data:'a -> 'a MoreLabels.Map.S.t -> 'a MoreLabels.Map.S.t
val singleton : MoreLabels.Map.S.key -> 'a -> 'a MoreLabels.Map.S.t
val remove :
MoreLabels.Map.S.key ->
'a MoreLabels.Map.S.t -> 'a MoreLabels.Map.S.t
val merge :
f:(MoreLabels.Map.S.key -> 'a option -> 'b option -> 'c option) ->
'a MoreLabels.Map.S.t ->
'b MoreLabels.Map.S.t -> 'c MoreLabels.Map.S.t
val compare :
cmp:('a -> 'a -> int) ->
'a MoreLabels.Map.S.t -> 'a MoreLabels.Map.S.t -> int
val equal :
cmp:('a -> 'a -> bool) ->
'a MoreLabels.Map.S.t -> 'a MoreLabels.Map.S.t -> bool
val iter :
f:(key:MoreLabels.Map.S.key -> data:'a -> unit) ->
'a MoreLabels.Map.S.t -> unit
val fold :
f:(key:MoreLabels.Map.S.key -> data:'a -> 'b -> 'b) ->
'a MoreLabels.Map.S.t -> init:'b -> 'b
val for_all :
f:(MoreLabels.Map.S.key -> 'a -> bool) ->
'a MoreLabels.Map.S.t -> bool
val exists :
f:(MoreLabels.Map.S.key -> 'a -> bool) ->
'a MoreLabels.Map.S.t -> bool
val filter :
f:(MoreLabels.Map.S.key -> 'a -> bool) ->
'a MoreLabels.Map.S.t -> 'a MoreLabels.Map.S.t
val partition :
f:(MoreLabels.Map.S.key -> 'a -> bool) ->
'a MoreLabels.Map.S.t ->
'a MoreLabels.Map.S.t * 'a MoreLabels.Map.S.t
val cardinal : 'a MoreLabels.Map.S.t -> int
val bindings :
'a MoreLabels.Map.S.t -> (MoreLabels.Map.S.key * 'a) list
val min_binding :
'a MoreLabels.Map.S.t -> MoreLabels.Map.S.key * 'a
val max_binding :
'a MoreLabels.Map.S.t -> MoreLabels.Map.S.key * 'a
val choose : 'a MoreLabels.Map.S.t -> MoreLabels.Map.S.key * 'a
val split :
MoreLabels.Map.S.key ->
'a MoreLabels.Map.S.t ->
'a MoreLabels.Map.S.t * 'a option * 'a MoreLabels.Map.S.t
val find : MoreLabels.Map.S.key -> 'a MoreLabels.Map.S.t -> 'a
val map :
f:('a -> 'b) -> 'a MoreLabels.Map.S.t -> 'b MoreLabels.Map.S.t
val mapi :
f:(MoreLabels.Map.S.key -> 'a -> 'b) ->
'a MoreLabels.Map.S.t -> 'b MoreLabels.Map.S.t
end
module Make :
functor (Ord : OrderedType) ->
sig
type key = Ord.t
and +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key:key -> data:'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
f:(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
val fold :
f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
val for_all : f:(key -> 'a -> bool) -> 'a t -> bool
val exists : f:(key -> 'a -> bool) -> 'a t -> bool
val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t
val partition : f:(key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : f:('a -> 'b) -> 'a t -> 'b t
val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
end
end
module Set :
sig
module type OrderedType = Set.OrderedType
module type S =
sig
type elt
and t
val empty : MoreLabels.Set.S.t
val is_empty : MoreLabels.Set.S.t -> bool
val mem : MoreLabels.Set.S.elt -> MoreLabels.Set.S.t -> bool
val add :
MoreLabels.Set.S.elt -> MoreLabels.Set.S.t -> MoreLabels.Set.S.t
val singleton : MoreLabels.Set.S.elt -> MoreLabels.Set.S.t
val remove :
MoreLabels.Set.S.elt -> MoreLabels.Set.S.t -> MoreLabels.Set.S.t
val union :
MoreLabels.Set.S.t -> MoreLabels.Set.S.t -> MoreLabels.Set.S.t
val inter :
MoreLabels.Set.S.t -> MoreLabels.Set.S.t -> MoreLabels.Set.S.t
val diff :
MoreLabels.Set.S.t -> MoreLabels.Set.S.t -> MoreLabels.Set.S.t
val compare : MoreLabels.Set.S.t -> MoreLabels.Set.S.t -> int
val equal : MoreLabels.Set.S.t -> MoreLabels.Set.S.t -> bool
val subset : MoreLabels.Set.S.t -> MoreLabels.Set.S.t -> bool
val iter :
f:(MoreLabels.Set.S.elt -> unit) -> MoreLabels.Set.S.t -> unit
val fold :
f:(MoreLabels.Set.S.elt -> 'a -> 'a) ->
MoreLabels.Set.S.t -> init:'a -> 'a
val for_all :
f:(MoreLabels.Set.S.elt -> bool) -> MoreLabels.Set.S.t -> bool
val exists :
f:(MoreLabels.Set.S.elt -> bool) -> MoreLabels.Set.S.t -> bool
val filter :
f:(MoreLabels.Set.S.elt -> bool) ->
MoreLabels.Set.S.t -> MoreLabels.Set.S.t
val partition :
f:(MoreLabels.Set.S.elt -> bool) ->
MoreLabels.Set.S.t -> MoreLabels.Set.S.t * MoreLabels.Set.S.t
val cardinal : MoreLabels.Set.S.t -> int
val elements : MoreLabels.Set.S.t -> MoreLabels.Set.S.elt list
val min_elt : MoreLabels.Set.S.t -> MoreLabels.Set.S.elt
val max_elt : MoreLabels.Set.S.t -> MoreLabels.Set.S.elt
val choose : MoreLabels.Set.S.t -> MoreLabels.Set.S.elt
val split :
MoreLabels.Set.S.elt ->
MoreLabels.Set.S.t ->
MoreLabels.Set.S.t * bool * MoreLabels.Set.S.t
val find :
MoreLabels.Set.S.elt ->
MoreLabels.Set.S.t -> MoreLabels.Set.S.elt
val of_list : MoreLabels.Set.S.elt list -> MoreLabels.Set.S.t
end
module Make :
functor (Ord : OrderedType) ->
sig
type elt = Ord.t
and t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : f:(elt -> unit) -> t -> unit
val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
val for_all : f:(elt -> bool) -> t -> bool
val exists : f:(elt -> bool) -> t -> bool
val filter : f:(elt -> bool) -> t -> t
val partition : f:(elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
end
end
end