res 4.0.7 · OCaml Package

Parameters

module S : Strat.T

module Impl : Implementation

Signature

module Strategy = S

type strategy = Strategy.t

type 'a t = {

mutable ar : 'a option Impl.t;
mutable vlix : int;
mutable strategy : strategy;

}

val name : string

val invalid_arg : string -> 'a

val failwith : string -> 'a

val length : 'a t -> int

val lix : 'a t -> int

val real_length : 'a t -> int

val real_lix : 'a t -> int

val unsafe_get_ar : 'a option Impl.t -> int -> 'b

val unsafe_get : 'a t -> int -> 'b

val unsafe_set_ar : 'a option Impl.t -> int -> 'b -> unit

val unsafe_set : 'a t -> int -> 'b -> unit

val get : 'a t -> int -> 'b

val set : 'a t -> int -> 'b -> unit

val creator : int -> 'a option Impl.t

val screate_fresh : strategy -> int -> 'a t

val create_fresh : int -> 'a t

val create_from : 'a t -> 'b t

val sempty : strategy -> 'a t

val empty : unit -> 'a t

val screate : strategy -> int -> 'a -> 'b t

val smake : strategy -> int -> 'a -> 'a t

val create : int -> 'a -> 'a t

val make : int -> 'a -> 'a t

val sinit : strategy -> int -> (int -> 'a) -> 'b t

val init : int -> (int -> 'a) -> 'a t

val to_array : 'a t -> 'b array

val sof_array : strategy -> 'a array -> 'b t

val of_array : 'a array -> 'a t

val get_strategy : 'a t -> strategy

val resizer : int -> 'a t -> int -> unit

val enforce_strategy : 'a t -> unit

val set_strategy : 'a t -> strategy -> unit

val put_strategy : 'a t -> strategy -> unit

val make_matrix : int -> int -> 'a -> 'b t t

val copy : 'a t -> 'b t

val unsafe_blit_on_other : 'a t -> int -> 'b t -> int -> int -> unit

val append : 'a t -> 'b t -> 'c t

val concat_aux : 'a t -> int -> 'a t list -> 'a t

val concat : 'a t list -> 'b t

val unsafe_sub : 'a t -> int -> int -> 'b t

val sub : 'a t -> int -> int -> 'a t

val guarantee_ix : 'a t -> int -> unit

val maybe_grow_ix : 'a t -> int -> unit

val add_one : 'a t -> 'b -> unit

val unsafe_remove_one : 'a t -> unit

val remove_one : 'a t -> unit

val unsafe_remove_n : 'a t -> int -> unit

val remove_n : 'a t -> int -> unit

val unsafe_remove_range : 'a t -> int -> int -> unit

val remove_range : 'a t -> int -> int -> unit

val clear : 'a t -> unit

val unsafe_swap : 'a t -> int -> int -> unit

val swap : 'a t -> int -> int -> unit

val unsafe_swap_in_last : 'a t -> int -> unit

val swap_in_last : 'a t -> int -> unit

val unsafe_fill : 'a t -> int -> int -> 'b -> unit

val fill : 'a t -> int -> int -> 'b -> unit

val unsafe_blit : 'a t -> int -> 'b t -> int -> int -> unit

val blit : 'a t -> int -> 'a t -> int -> int -> unit

val to_list_aux : 'a option Impl.t -> int -> 'b list -> 'b list

val to_list : 'a t -> 'b list

val of_list_aux : 'a option Impl.t -> int -> 'b list -> unit

val of_list : 'a list -> 'b t

val sof_list : strategy -> 'a list -> 'b t

val iter : ('a -> unit) -> 'b t -> unit

val map : ('a -> 'b) -> 'c t -> 'd t

val iteri : (int -> 'a -> unit) -> 'b t -> unit

val mapi : (int -> 'a -> 'b) -> 'c t -> 'd t

val fold_left : ('a -> 'b -> 'c) -> 'd -> 'e t -> 'f

val fold_right : ('a -> 'b -> 'c) -> 'd t -> 'e -> 'f

val for_all_aux : int -> ('a -> bool) -> 'b t -> bool

val for_all : ('a -> bool) -> 'a t -> bool

val exists_aux : int -> ('a -> bool) -> 'b t -> bool

val exists : ('a -> bool) -> 'a t -> bool

val mem_aux : int -> 'a -> 'b t -> bool

val mem : 'a -> 'b t -> bool

val memq_aux : int -> 'a -> 'b t -> bool

val memq : 'a -> 'b t -> bool

val pos_aux : int -> 'a -> 'b t -> int option

val pos : 'a -> 'b t -> int option

val posq_aux : int -> 'a -> 'b t -> int option

val posq : 'a -> 'b t -> int option

val find_aux : int -> ('a -> bool) -> 'b t -> 'c

val find : ('a -> bool) -> 'a t -> 'b

val find_index_aux : ('a -> bool) -> 'b t -> int -> int

val find_index : ('a -> bool) -> 'a t -> int -> int

val filter : ('a -> bool) -> 'b t -> 'c t

val find_all : ('a -> bool) -> 'a t -> 'a t

val filter_in_place : ('a -> bool) -> 'b t -> unit

val partition : ('a -> bool) -> 'b t -> 'c t * 'd t

package res

Parameters

Signature