package kaputt

  1. Overview
  2. Docs
type random = Random.State.t
val make_random : unit -> random
val make_random_seed : int -> random
val make_random_full : int array -> random
type !'a t = (random -> 'a) * ('a -> string)
val unit : unit t
val bool : bool t
val make_bool : int -> int -> bool t
val int : int t
val pos_int : int t
val neg_int : int t
val make_int : int -> int -> int t
val int32 : int32 t
val pos_int32 : int32 t
val neg_int32 : int32 t
val make_int32 : int32 -> int32 -> int32 t
val int64 : int64 t
val pos_int64 : int64 t
val neg_int64 : int64 t
val make_int64 : int64 -> int64 -> int64 t
val nativeint : nativeint t
val pos_nativeint : nativeint t
val neg_nativeint : nativeint t
val make_nativeint : nativeint -> nativeint -> nativeint t
val char : char t
val digit : char t
val digit_bin : char t
val digit_oct : char t
val digit_hex : char t
val letter : char t
val alphanum : char t
val string : int t -> char t -> string t
val strings : string -> int t -> string t -> string t
val number : int t -> string t
val number_bin : int t -> string t
val number_oct : int t -> string t
val number_hex : int t -> string t
val word : int t -> string t
val words : int t -> int t -> string t
val float : float t
val make_float : float -> float -> float t
val complex : float t -> float t -> Complex.t t
type !'a outcome =
  1. | Value of 'a
  2. | Exception of exn
val total_function : 'b t -> ('a -> 'b) t
val partial_function : 'b outcome t -> ('a -> 'b) t
val array : int t -> 'a t -> 'a array t
val list : int t -> 'a t -> 'a list t
val option : bool t -> 'a t -> 'a option t
val ref : 'a t -> 'a Pervasives.ref t
val buffer : string t -> Buffer.t t
module type Gen = sig ... end
module Map (M : Map.S) (G : sig ... end) : sig ... end
module Set (S : Set.S) (G : sig ... end) : sig ... end
val hashtbl : int t -> 'a t -> 'b t -> ('a, 'b) Hashtbl.t t
val queue : int t -> 'a t -> 'a Queue.t t
val stack : int t -> 'a t -> 'a Stack.t t
val weak : int t -> 'a option t -> 'a Weak.t t
module Weak (W : Weak.S) (G : sig ... end) : sig ... end
val lift : 'a -> string -> 'a t
val select_list : 'a list -> ('a -> string) -> 'a t
val select_list_weighted : ('a * int) list -> ('a -> string) -> 'a t
val select_array : 'a array -> ('a -> string) -> 'a t
val select_array_weighted : ('a * int) array -> ('a -> string) -> 'a t
val choose_list : 'a t list -> 'a t
val choose_list_weighted : ('a t * int) list -> 'a t
val choose_array : 'a t array -> 'a t
val choose_array_weighted : ('a t * int) array -> 'a t
val filter : ('a -> bool) -> 'a t -> 'a t
val transform : ('a -> 'a) -> 'a t -> 'a t
val map1 : ('a -> 'b) -> ('b -> string) -> 'a t -> 'b t
val map2 : ('a -> 'b -> 'c) -> ('c -> string) -> ('a t * 'b t) -> 'c t
val map3 : ('a -> 'b -> 'c -> 'd) -> ('d -> string) -> ('a t * 'b t * 'c t) -> 'd t
val map4 : ('a -> 'b -> 'c -> 'd -> 'e) -> ('e -> string) -> ('a t * 'b t * 'c t * 'd t) -> 'e t
val map5 : ('a -> 'b -> 'c -> 'd -> 'e -> 'f) -> ('f -> string) -> ('a t * 'b t * 'c t * 'd t * 'e t) -> 'f t
val zip1 : 'a t -> 'a t
val zip2 : 'a t -> 'b t -> ('a * 'b) t
val zip3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val zip4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val zip5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t
val apply1 : ('a -> 'b) -> 'a -> 'b
val apply2 : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c
val apply3 : ('a -> 'b -> 'c -> 'd) -> ('a * 'b * 'c) -> 'd
val apply4 : ('a -> 'b -> 'c -> 'd -> 'e) -> ('a * 'b * 'c * 'd) -> 'e
val apply5 : ('a -> 'b -> 'c -> 'd -> 'e -> 'f) -> ('a * 'b * 'c * 'd * 'e) -> 'f
val tuple_apply1 : ('a -> 'b) -> 'a -> 'b
val tuple_apply2 : (('a * 'b) -> 'c) -> 'a -> 'b -> 'c
val tuple_apply3 : (('a * 'b * 'c) -> 'd) -> 'a -> 'b -> 'c -> 'd
val tuple_apply4 : (('a * 'b * 'c * 'd) -> 'e) -> 'a -> 'b -> 'c -> 'd -> 'e
val tuple_apply5 : (('a * 'b * 'c * 'd * 'e) -> 'f) -> 'a -> 'b -> 'c -> 'd -> 'e -> 'f
OCaml

Innovation. Community. Security.