Option_array (base.Base.Option

type 'a t

val t_of_sexp : (Sexplib0__.Sexp.t -> 'a) -> Sexplib0__.Sexp.t -> 'a t

val sexp_of_t : ('a -> Sexplib0__.Sexp.t) -> 'a t -> Sexplib0__.Sexp.t

val t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a t Sexplib0.Sexp_grammar.t

val empty : 'a t

val create : len:int -> 'a t

val is_empty : 'a t -> bool

val mem : 'a t -> 'a option -> equal:('a option -> 'a option -> bool) -> bool

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

val fold : 'a t -> init:'acc -> f:('acc -> 'a option -> 'acc) -> 'acc

val fold_result : 
  'a t ->
  init:'acc ->
  f:('acc -> 'a option -> ('acc, 'e) result) ->
  ('acc, 'e) result

val fold_until : 
  'a t ->
  init:'acc ->
  f:
    ('acc ->
      'a option ->
      ('acc, 'final) Base__Container_intf.Continue_or_stop.t) ->
  finish:('acc -> 'final) ->
  'final

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

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

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

val sum : 
  (module Base__Container_intf.Summable with type t = 'sum) ->
  'a t ->
  f:('a option -> 'sum) ->
  'sum

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

val find_map : 'a t -> f:('a option -> 'b option) -> 'b option

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

val min_elt : 
  'a t ->
  compare:('a option -> 'a option -> int) ->
  'a option option

val max_elt : 
  'a t ->
  compare:('a option -> 'a option -> int) ->
  'a option option

val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a option -> 'b) -> 'b

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

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

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

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

val findi : 'a t -> f:(int -> 'a option -> bool) -> (int * 'a option) option

val find_mapi : 'a t -> f:(int -> 'a option -> 'b option) -> 'b option

val length : 'a t -> int

val init_some : int -> f:(int -> 'a) -> 'a t

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

val of_array : 'a option array -> 'a t

val of_array_some : 'a array -> 'a t

val to_array : 'a t -> 'a option array

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

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

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

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

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

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

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

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

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

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

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

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

val clear : 'a t -> unit

val map : 'a t -> f:('a option -> 'b option) -> 'b t

val map_some : 'a t -> f:('a -> 'b) -> 'b t

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

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

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

val blit : 
  src:'a t ->
  src_pos:int ->
  dst:'a t ->
  dst_pos:int ->
  len:int ->
  unit

val blito : 
  src:'a t ->
  ?src_pos:int ->
  ?src_len:int ->
  dst:'a t ->
  ?dst_pos:int ->
  unit ->
  unit

val unsafe_blit : 
  src:'a t ->
  src_pos:int ->
  dst:'a t ->
  dst_pos:int ->
  len:int ->
  unit

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

val subo : ?pos:int -> ?len:int -> 'a t -> 'a t

val copy : 'a t -> 'a t

module For_testing : sig ... end