'a Option_array.t
is a compact representation of 'a option array
: it avoids allocating heap objects representing Some x
, usually representing them with x
instead. It uses a special representation for None
that's guaranteed to never collide with any representation of Some x
.
include Sexplib0 .Sexpable.S1 with type 'a t := '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 create : len :int -> _ t
Initially filled with all None
include Indexed_container.Generic
with type ('a, _) t := 'a t
and type 'a elt := 'a option
include Container.Generic
with type ('a, _) t := 'a t
with type 'a elt := 'a option
val is_empty : _ 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.t ) ->
('acc , 'e ) Result.t
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 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
These are all like their equivalents in Container
except that an index starting at 0 is added as the first argument to f
.
val foldi : 'a t -> init :_ -> f :(int -> _ -> 'a option -> _ ) -> _
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 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.t
val get : 'a t -> int -> 'a option
get t i
returns the element number i
of array t
, raising if i
is outside the range 0 to length t - 1
.
val get_some_exn : 'a t -> int -> 'a
Raises if the element number i
is None
.
val is_none : _ t -> int -> bool
is_none t i = Option.is_none (get t i)
val is_some : _ t -> int -> bool
is_some t i = Option.is_some (get t i)
These can cause arbitrary behavior when used for an out-of-bounds array access.
val unsafe_get : 'a t -> int -> 'a option
val unsafe_get_some_exn : 'a t -> int -> 'a
unsafe_get_some_exn t i
is unsafe because it does not bounds check i
. It does, however check whether the value at index i
is none or some, and raises if it is none.
val unsafe_get_some_assuming_some : 'a t -> int -> 'a
unsafe_get_some_assuming_some t i
is unsafe both because it does not bounds check i
and because it does not check whether the value at index i
is none or some, assuming that it is some.
val unsafe_is_some : _ t -> int -> bool
val set : 'a t -> int -> 'a option -> unit
set t i x
modifies array t
in place, replacing element number i
with x
, raising if i
is outside the range 0 to length t - 1
.
val set_some : 'a t -> int -> 'a -> unit
val set_none : _ t -> int -> unit
val swap : _ t -> int -> int -> unit
Replaces all the elements of the array with None
.
val map : 'a t -> f :('a option -> 'b option ) -> 'b t
map f [|a1; ...; an|]
applies function f
to a1
, a2
, ..., an
, in order, and builds the option_array [|f a1; ...; f an|]
with the results returned by f
.
val map_some : 'a t -> f :('a -> 'b ) -> 'b t
map_some t ~f
is like map
, but None
elements always map to None
and Some
always map to Some
.
Unsafe versions of set*
. Can cause arbitrary behaviour when used for an out-of-bounds array access.
val unsafe_set : 'a t -> int -> 'a option -> unit
val unsafe_set_some : 'a t -> int -> 'a -> unit
val unsafe_set_none : _ t -> int -> unit
include Blit.S1 with type 'a t := 'a t
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
Makes a (shallow) copy of the array.