# Functor Weak_impl.Make

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

Parameters:

`S` | : | `Strat.T`

    module Strategy: S

    type strategy = Strategy.t

    type 'a t = {

`` | `mutable ar : `'a Stdlib.Weak.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 : 'a t -> int -> 'a option

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

    val check : 'a t -> int -> bool

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

    val get_copy : 'a t -> int -> 'a option

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

    val creator : int -> 'a Stdlib.Weak.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 smake : strategy -> int -> 'a option -> 'a t

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

    val create : int -> 'a t

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

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

    val init : int -> (int -> 'a option) -> '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 copy : 'a t -> 'a t

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

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

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

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

    val unsafe_sub : 'a t -> int -> int -> 'a 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 -> 'a option -> 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 -> 'a option -> unit

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

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

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

    val to_std : 'a t -> 'a Stdlib.Weak.t

    val sof_std : strategy -> 'a Stdlib.Weak.t -> 'a t

    val of_std : 'a Stdlib.Weak.t -> 'a t

    val to_list_aux : 'a t -> int -> 'a option list -> 'a option list

    val to_list : 'a t -> 'a option list

    val of_list_aux : 'a t -> int -> 'a option list -> 'a t

    val of_list : 'a option list -> 'a t

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

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

    val fold_left : ('a -> 'b option -> 'a) -> 'a -> 'b t -> 'a

    val fold_right : ('a option -> 'b -> 'b) -> 'a t -> 'b -> 'b

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    val filter : ('a option -> bool) -> 'a t -> 'a t

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

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

    val partition : ('a option -> bool) ->
           'a t -> 'a t * 'a t