# Functor Nopres_impl.Make

    module Make: functor (S : Strat.T) -> functor (Impl : Implementation) -> sig .. end

Parameters:

`S` | : | `Strat.T`
`Impl` | : | `Implementation`

    module Strategy: S

    type strategy = Strategy.t

    type el = Impl.el

    type t = {

`` | `mutable ar : `Impl.t`;`
`` | `mutable vlix : `int`;`
`` | `mutable strategy : `strategy`;`

`}`

    val name : string

    val invalid_arg : string -> 'a

    val failwith : string -> 'a

    val length : t -> int

    val lix : t -> int

    val real_length : t -> int

    val real_lix : t -> int

    val unsafe_get : t -> int -> Impl.el

    val unsafe_set : t -> int -> Impl.el -> unit

    val get : t -> int -> Impl.el

    val set : t -> int -> Impl.el -> unit

    val creator : int -> Impl.t

    val empty_ar : Impl.t

    val screate : strategy -> int -> t

    val smake : strategy -> int -> Impl.el -> t

    val create_fresh : int -> t

    val create_from : t -> t

    val sempty : strategy -> t

    val empty : unit -> t

    val create : int -> t

    val make : int -> Impl.el -> t

    val sinit : strategy -> int -> (int -> Impl.el) -> t

    val init : int -> (int -> Impl.el) -> t

    val get_strategy : t -> strategy

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

    val enforce_strategy : t -> unit

    val set_strategy : t -> strategy -> unit

    val put_strategy : t -> strategy -> unit

    val unsafe_blit_on_other : t -> int -> t -> int -> int -> unit

    val copy : t -> t

    val append : t -> t -> t

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

    val concat : t list -> t

    val unsafe_sub : t -> int -> int -> t

    val sub : t -> int -> int -> t

    val guarantee_ix : t -> int -> unit

    val maybe_grow_ix : t -> int -> unit

    val add_one : t -> Impl.el -> unit

    val unsafe_remove_one : t -> unit

    val remove_one : t -> unit

    val unsafe_remove_n : t -> int -> unit

    val remove_n : t -> int -> unit

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

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

    val clear : t -> unit

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

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

    val unsafe_swap_in_last : t -> int -> unit

    val swap_in_last : t -> int -> unit

    val unsafe_fill : t -> int -> int -> Impl.el -> unit

    val fill : t -> int -> int -> Impl.el -> unit

    val unsafe_blit : t -> int -> t -> int -> int -> unit

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

    val to_list_aux : Impl.t -> int -> Impl.el list -> Impl.el list

    val to_list : t -> Impl.el list

    val of_list_aux : Impl.t -> int -> Impl.el list -> unit

    val of_list : Impl.el list -> t

    val sof_list : strategy -> Impl.el list -> t

    val to_array : t -> Impl.el array

    val sof_array : strategy -> Impl.el array -> t

    val of_array : Impl.el array -> t

    val iter : (Impl.el -> 'a) -> t -> unit

    val map : (Impl.el -> Impl.el) -> t -> t

    val iteri : (int -> Impl.el -> 'a) -> t -> unit

    val mapi : (int -> Impl.el -> Impl.el) -> t -> t

    val fold_left : ('a -> Impl.el -> 'a) -> 'a -> t -> 'a

    val fold_right : (Impl.el -> 'a -> 'a) -> t -> 'a -> 'a

    val for_all_aux : int -> (Impl.el -> bool) -> t -> bool

    val for_all : (Impl.el -> bool) -> t -> bool

    val exists_aux : int -> (Impl.el -> bool) -> t -> bool

    val exists : (Impl.el -> bool) -> t -> bool

    val mem_aux : int -> Impl.el -> t -> bool

    val mem : Impl.el -> t -> bool

    val memq_aux : int -> Impl.el -> t -> bool

    val memq : Impl.el -> t -> bool

    val pos_aux : int -> Impl.el -> t -> int option

    val pos : Impl.el -> t -> int option

    val posq_aux : int -> Impl.el -> t -> int option

    val posq : Impl.el -> t -> int option

    val find_aux : int -> (Impl.el -> bool) -> t -> Impl.el

    val find : (Impl.el -> bool) -> t -> Impl.el

    val find_index_aux : (Impl.el -> bool) -> t -> int -> int

    val find_index : (Impl.el -> bool) -> t -> int -> int

    val filter : (Impl.el -> bool) -> t -> t

    val find_all : (Impl.el -> bool) -> t -> t

    val filter_in_place : (Impl.el -> bool) -> t -> unit

    val partition : (Impl.el -> bool) ->
           t -> t * t