obatcher 1.1 · OCaml Package

type 'a t = 'a Sequential.t

type cfg = unit option

type ('elt, 'ret) op =

| Insert : V.t * 'elt -> ('elt, unit) op
| Search : V.t -> ('elt, 'elt option) op
| Size : ('elt, int) op

type 'a wrapped_op =

| Mk : ('a, 'b) op * 'b Picos.Computation.t -> 'a wrapped_op

val init : ?cfg:'a -> unit -> 'b Sequential.t

val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list

val drop_last : 'a list -> 'a list

val int_pow : int -> int -> int

val find_height : t:int -> no_elts:int -> int

val find_split : ?root:bool -> t:int -> h:int -> int -> int * int * int

val partition_range : 
  ?root:bool ->
  t:int ->
  h:int ->
  (int * int) ->
  int array * int array

val build_node : 
  max_children:int ->
  h:int ->
  int ->
  int ->
  (V.t * 'a) array ->
  'a Sequential.node

val par_build_node : 
  max_children:int ->
  h:int ->
  int ->
  int ->
  (V.t * 'a) array ->
  'a Sequential.node

val build_from_sorted : 
  ?max_children:int ->
  (V.t * 'a) array ->
  int * 'a Sequential.node

val int_range_downto : int -> int -> int Stdlib.Seq.t

val flatten : 'a Sequential.node -> (V.t * 'a) Stdlib.Seq.t

val merge : 'a Stdlib.Seq.t -> 'a Stdlib.Seq.t -> ('a -> 'b) -> unit

val par_rebuild : 
  max_children:int ->
  'a Sequential.node ->
  (V.t * 'a) array ->
  int * 'a Sequential.node

val par_search_node : 
  ?par_threshold:int ->
  ?threshold:int ->
  'a Sequential.node ->
  height:int ->
  keys:(V.t * 'a option Picos.Computation.t) array ->
  range:(int * int) ->
  unit

val par_search : 
  ?par_threshold:int ->
  ?threshold:int ->
  'a t ->
  (V.t * 'a option Picos.Computation.t) array ->
  unit

val par_insert_node : 
  ?threshold:int ->
  max_children:int ->
  'a Sequential.node ->
  (V.t * 'a) array ->
  int ->
  int ->
  int

val par_insert : 
  ?threshold:int ->
  ?can_rebuild:bool ->
  'a t ->
  (V.t * 'a) array ->
  unit

val run : 'a t -> 'a wrapped_op array -> unit

package obatcher