package clarity

  1. Overview
  2. Docs
module Arr : sig ... end
module AP : sig ... end
val ceil_div : int -> int -> int
val _BITS : int
val _BRANCHING : int
val _EXTRA_STEPS : int
val _SKIP_SIZE : int
val check_depth : int -> unit
type 'a t =
  1. | Leaf of 'a array
  2. | R_node of int array * 'a t array
  3. | B_node of 'a t array
val depth : 'a t -> int
val length : 'a t -> int
val update_lengths : 'a t -> unit
val mk_rnode : 'a t array -> 'a t
val max_nodes_allowed : int -> int
val empty : 'a t
val get_leaf : 'a t -> 'a array
val get_rnode : 'a t -> int array * 'a t array
val get_bnode : 'a t -> 'a t array
val node_len : 'a. 'a t -> int
module Concatenation : sig ... end
val append : 'a t -> 'a t -> 'a t
exception Out_of_bounds of {
  1. index : int;
  2. size : int;
}
val check_bounds : 'a t -> int -> unit
val get : 'a. 'a t -> int -> 'a
val update : 'a. 'a t -> int -> 'a -> 'a t
val split_at : 'a. 'a t -> int -> 'a t * 'a t
val take : 'a. 'a t -> int -> 'a t
val drop : 'a. 'a t -> int -> 'a t
val iter : ('a -> unit) -> 'a t -> unit
val make_pb : unit -> ('a -> unit) * (unit -> 'a t)
val init : 'a. int -> (int -> 'a) -> 'a t
include sig ... end
val bind : ('a -> 'b t) -> 'a t -> 'b t
val pure : 'a -> 'a t
val ap : ('a -> 'b) t -> (unit -> 'a t) -> 'b t
val map : ('a -> 'b) -> 'a t -> 'b t
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val replace : 'a -> 'b t -> 'a t
val void : 'a t -> unit t
val ap' : ('a -> 'b) t -> 'a t -> 'b t
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
val (<~>) : ('a -> 'b) t -> (unit -> 'a t) -> 'b t
val discard_left : 'a t -> (unit -> 'b t) -> 'b t
val discard_right : 'a t -> (unit -> 'b t) -> 'a t
val repeat : int -> 'a t -> 'a list t
val repeat_ : int -> 'a t -> unit t
val forever : 'a t -> 'b t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val join : 'a t t -> 'a t
val mcompose : ('b -> 'c t) -> ('a -> 'b t) -> 'a -> 'c t
include sig ... end
val foldl : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val foldr : ('a -> (unit -> 'b) -> 'b) -> (unit -> 'b) -> 'a t -> 'b
val fold_map : (module Monoid.S with type t = 'm) -> ('a -> 'm) -> 'a t -> 'm
val any : ('a -> bool) -> 'a t -> bool
val all : ('a -> bool) -> 'a t -> bool
val find : ('a -> bool) -> 'a t -> 'a option
val foldr' : ('a -> 'b -> 'b) -> 'b -> 'a t -> 'b
val to_list : 'a t -> 'a list
val of_list : 'a list -> 'a t
include sig ... end
val align_with : (('a, 'b) These.t -> 'c) -> 'a t -> 'b t -> 'c t
val align : 'a t -> 'b t -> ('a, 'b) These.t t
val falign : ('a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
val pad_zip_with : ('a option -> 'b option -> 'c) -> 'a t -> 'b t -> 'c t
val pad_zip : 'a t -> 'b t -> ('a option * 'b option) t
module A3 (A : Applicative.Basic3) : sig ... end
module A2 (A : Applicative.Basic2) : sig ... end
module A (A : Applicative.Basic) : sig ... end
module M3 (M : Monad.Basic3) : sig ... end
module M2 (M : Monad.Basic2) : sig ... end
module M (M : Monad.Basic) : sig ... end
OCaml

Innovation. Community. Security.