simon/ocaml-containers
1
0
Fork 0
mirror of https://github.com/c-cube/ocaml-containers.git synced 2025-12-06 11:15:31 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

change signatures of CCArray to include labels

Browse source
This commit is contained in:
Simon Cruanes 2015-11-09 21:52:30 +01:00
parent c2b9de44f9
commit 4b6ff6555b
3 changed files with 136 additions and 120 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
benchs/run_benchs.ml
View file

@ -718,8 +718,14 @@ module Batch = struct
end end
module BenchArray = Make(struct module BenchArray = Make(struct
include CCArray type 'a t = 'a array
let name = "array" let name = "array"
let empty = CCArray.empty
let (--) = CCArray.(--)
let flat_map f a = CCArray.flat_map ~f a
let filter_map f a = CCArray.filter_map ~f a
let filter f a = CCArray.filter ~f a
let map = Array.map
let equal a b = a=b let equal a b = a=b
let doubleton x y = [| x; y |] let doubleton x y = [| x; y |]
let fold = Array.fold_left let fold = Array.fold_left

195
src/core/CCArray.ml
View file

@ -38,9 +38,9 @@ module type S = sig
val empty : 'a t val empty : 'a t
val equal : 'a equal -> 'a t equal val equal : ?eq:'a equal -> 'a t equal
val compare : 'a ord -> 'a t ord val compare : ?cmp:'a ord -> 'a t ord
val get : 'a t -> int -> 'a val get : 'a t -> int -> 'a
@ -48,52 +48,55 @@ module type S = sig
val length : _ t -> int val length : _ t -> int
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val fold : f:('a -> 'b -> 'a) -> x:'a -> 'b t -> 'a
val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b t -> 'a val foldi : f:('a -> int -> 'b -> 'a) -> x:'a -> 'b t -> 'a
(** Fold left on array, with index *) (** Fold left on array, with index *)
val fold_while : ('a -> 'b -> 'a * [`Stop | `Continue]) -> 'a -> 'b t -> 'a val fold_while :
f:('a -> 'b -> 'a * [`Stop | `Continue]) ->
x:'a -> 'b t -> 'a
(** Fold left on array until a stop condition via [('a, `Stop)] is (** Fold left on array until a stop condition via [('a, `Stop)] is
indicated by the accumulator indicated by the accumulator
@since 0.8 *) @since 0.8 *)
val iter : ('a -> unit) -> 'a t -> unit val iter : f:('a -> unit) -> 'a t -> unit
val iteri : (int -> 'a -> unit) -> 'a t -> unit val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
val blit : 'a t -> int -> 'a t -> int -> int -> unit val blit : from:'a t -> i:int -> into:'a t -> j:int -> len:int -> unit
(** [blit from i into j len] copies [len] elements from the first array (** [blit from i into j len] copies [len] elements from the first array
to the second. See {!Array.blit}. *) to the second. See {!Array.blit}. *)
val reverse_in_place : 'a t -> unit val reverse_in_place : 'a t -> unit
(** Reverse the array in place *) (** Reverse the array in place *)
val find : ('a -> 'b option) -> 'a t -> 'b option val find : f:('a -> 'b option) -> 'a t -> 'b option
(** [find f a] returns [Some y] if there is an element [x] such (** [find f a] returns [Some y] if there is an element [x] such
that [f x = Some y], else it returns [None] *) that [f x = Some y], else it returns [None] *)
val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
(** Like {!find}, but also pass the index to the predicate function. (** Like {!find}, but also pass the index to the predicate function.
@since 0.3.4 *) @since 0.3.4 *)
val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option val find_idx : f:('a -> bool) -> 'a t -> (int * 'a) option
(** [find_idx p x] returns [Some (i,x)] where [x] is the [i]-th element of [l], (** [find_idx p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
and [p x] holds. Otherwise returns [None] and [p x] holds. Otherwise returns [None]
@since 0.3.4 *) @since 0.3.4 *)
val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option val lookup : ?cmp:'a ord -> x:'a -> 'a t -> int option
(** Lookup the index of some value in a sorted array. (** Lookup the index of some value in a sorted array.
@param x the value that is looked up
@return [None] if the key is not present, or @return [None] if the key is not present, or
[Some i] ([i] the index of the key) otherwise *) [Some i] ([i] the index of the key) otherwise *)
val lookup_exn : ?cmp:'a ord -> 'a -> 'a t -> int val lookup_exn : ?cmp:'a ord -> x:'a -> 'a t -> int
(** Same as {!lookup_exn}, but (** Same as {!lookup_exn}, but
@raise Not_found if the key is not present *) @raise Not_found if the key is not present *)
val bsearch : ?cmp:('a -> 'a -> int) -> 'a -> 'a t -> val bsearch : ?cmp:('a -> 'a -> int) -> x:'a -> 'a t ->
[ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ] [ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
(** [bsearch ?cmp x arr] finds the index of the object [x] in the array [arr], (** [bsearch ?cmp ~x arr] finds the index of the object [x] in the array [arr],
provided [arr] is {b sorted} using [cmp]. If the array is not sorted, provided [arr] is {b sorted} using [cmp]. If the array is not sorted,
the result is not specified (may raise Invalid_argument). the result is not specified (may raise Invalid_argument).
@ -110,22 +113,22 @@ module type S = sig
@raise Invalid_argument if the array is found to be unsorted w.r.t [cmp] @raise Invalid_argument if the array is found to be unsorted w.r.t [cmp]
@since 0.13 *) @since 0.13 *)
val for_all : ('a -> bool) -> 'a t -> bool val for_all : f:('a -> bool) -> 'a t -> bool
val for_all2 : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val for_all2 : f:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
(** Forall on pairs of arrays. (** Forall on pairs of arrays.
@raise Invalid_argument if they have distinct lengths *) @raise Invalid_argument if they have distinct lengths *)
val exists : ('a -> bool) -> 'a t -> bool val exists : f:('a -> bool) -> 'a t -> bool
val exists2 : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val exists2 : f:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
(** Exists on pairs of arrays. (** Exists on pairs of arrays.
@raise Invalid_argument if they have distinct lengths *) @raise Invalid_argument if they have distinct lengths *)
val shuffle : 'a t -> unit val shuffle : 'a t -> unit
(** shuffle randomly the array, in place *) (** Shuffle randomly the array, in place *)
val shuffle_with : Random.State.t -> 'a t -> unit val shuffle_with : st:Random.State.t -> 'a t -> unit
(** Like shuffle but using a specialized random state *) (** Like shuffle but using a specialized random state *)
val random_choose : 'a t -> 'a random_gen val random_choose : 'a t -> 'a random_gen
@ -140,15 +143,15 @@ module type S = sig
val pp: ?sep:string -> (Buffer.t -> 'a -> unit) -> val pp: ?sep:string -> (Buffer.t -> 'a -> unit) ->
Buffer.t -> 'a t -> unit Buffer.t -> 'a t -> unit
(** print an array of items with printing function *) (** Print an array of items with printing function *)
val pp_i: ?sep:string -> (Buffer.t -> int -> 'a -> unit) -> val pp_i: ?sep:string -> (Buffer.t -> int -> 'a -> unit) ->
Buffer.t -> 'a t -> unit Buffer.t -> 'a t -> unit
(** print an array, giving the printing function both index and item *) (** Print an array, giving the printing function both index and item *)
val print : ?sep:string -> (Format.formatter -> 'a -> unit) -> val print : ?sep:string -> (Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a t -> unit Format.formatter -> 'a t -> unit
(** print an array of items with printing function *) (** Print an array of items with printing function *)
end end
(** {2 General Implementation} (** {2 General Implementation}
@ -185,10 +188,10 @@ let rec _compare cmp a1 i1 j1 a2 i2 j2 =
else c else c
(*$T (*$T
compare CCOrd.compare [| 1; 2; 3 |] [| 1; 2; 3 |] = 0 compare ~cmp:CCOrd.compare [| 1; 2; 3 |] [| 1; 2; 3 |] = 0
compare CCOrd.compare [| 1; 2; 3 |] [| 2; 2; 3 |] < 0 compare ~cmp:CCOrd.compare [| 1; 2; 3 |] [| 2; 2; 3 |] < 0
compare CCOrd.compare [| 1; 2; |] [| 1; 2; 3 |] < 0 compare ~cmp:CCOrd.compare [| 1; 2; |] [| 1; 2; 3 |] < 0
compare CCOrd.compare [| 1; 2; 3 |] [| 1; 2; |] > 0 compare ~cmp:CCOrd.compare [| 1; 2; 3 |] [| 1; 2; |] > 0
*) *)
let rec _find f a i j = let rec _find f a i j =
@ -307,7 +310,7 @@ type 'a t = 'a array
let empty = [| |] let empty = [| |]
let map = Array.map let map ~f a = Array.map f a
let length = Array.length let length = Array.length
@ -315,11 +318,11 @@ let get = Array.get
let set = Array.set let set = Array.set
let fold = Array.fold_left let fold ~f ~x a = Array.fold_left f x a
let foldi f acc a = _foldi f acc a 0 (Array.length a) let foldi ~f ~x:acc a = _foldi f acc a 0 (Array.length a)
let fold_while f acc a = let fold_while ~f ~x:acc a =
let rec fold_while_i f acc i = let rec fold_while_i f acc i =
if i < Array.length a then if i < Array.length a then
let acc, cont = f acc a.(i) in let acc, cont = f acc a.(i) in
@ -330,14 +333,16 @@ let fold_while f acc a =
in fold_while_i f acc 0 in fold_while_i f acc 0
(*$T (*$T
fold_while (fun acc b -> if b then acc+1, `Continue else acc, `Stop) 0 (Array.of_list [true;true;false;true]) = 2 fold_while \
~f:(fun acc b -> if b then acc+1, `Continue else acc, `Stop) \
~x:0 (Array.of_list [true;true;false;true]) = 2
*) *)
let iter = Array.iter let iter ~f a = Array.iter f a
let iteri = Array.iteri let iteri ~f a = Array.iteri f a
let blit = Array.blit let blit ~from ~i ~into ~j ~len = Array.blit from i into j len
let reverse_in_place a = let reverse_in_place a =
_reverse_in_place a 0 ~len:(Array.length a) _reverse_in_place a 0 ~len:(Array.length a)
@ -353,16 +358,16 @@ let reverse_in_place a =
a = [| 6;5;4;3;2;1 |] a = [| 6;5;4;3;2;1 |]
*) *)
let find f a = let find ~f a =
_find (fun _ -> f ) a 0 (Array.length a) _find (fun _ -> f ) a 0 (Array.length a)
let findi f a = let findi ~f a =
_find f a 0 (Array.length a) _find f a 0 (Array.length a)
let find_idx p a = let find_idx ~f a =
_find (fun i x -> if p x then Some (i,x) else None) a 0 (Array.length a) _find (fun i x -> if f x then Some (i,x) else None) a 0 (Array.length a)
let filter_map f a = let filter_map ~f a =
let rec aux acc i = let rec aux acc i =
if i = Array.length a if i = Array.length a
then ( then (
@ -382,8 +387,8 @@ let filter_map f a =
= [| "2"; "4"; "6" |] = [| "2"; "4"; "6" |]
*) *)
let filter p a = let filter ~f a =
filter_map (fun x -> if p x then Some x else None) a filter_map ~f:(fun x -> if f x then Some x else None) a
(* append [rev a] in front of [acc] *) (* append [rev a] in front of [acc] *)
let rec __rev_append_list a acc i = let rec __rev_append_list a acc i =
@ -392,7 +397,7 @@ let rec __rev_append_list a acc i =
else else
__rev_append_list a (a.(i) :: acc) (i+1) __rev_append_list a (a.(i) :: acc) (i+1)
let flat_map f a = let flat_map ~f a =
let rec aux acc i = let rec aux acc i =
if i = Array.length a if i = Array.length a
then ( then (
@ -411,11 +416,11 @@ let flat_map f a =
a' = [| 1; 2; 3; 4; 5; 6 |] a' = [| 1; 2; 3; 4; 5; 6 |]
*) *)
let lookup_exn ?(cmp=Pervasives.compare) k a = let lookup_exn ?(cmp=Pervasives.compare) ~x a =
_lookup_exn ~cmp k a 0 (Array.length a-1) _lookup_exn ~cmp x a 0 (Array.length a-1)
let lookup ?(cmp=Pervasives.compare) k a = let lookup ?(cmp=Pervasives.compare) ~x a =
try Some (_lookup_exn ~cmp k a 0 (Array.length a-1)) try Some (_lookup_exn ~cmp x a 0 (Array.length a-1))
with Not_found -> None with Not_found -> None
(*$T (*$T
@ -428,7 +433,8 @@ let lookup ?(cmp=Pervasives.compare) k a =
lookup 2 [| 1 |] = None lookup 2 [| 1 |] = None
*) *)
let bsearch ?(cmp=Pervasives.compare) k a = bsearch_ ~cmp k a 0 (Array.length a-1) let bsearch ?(cmp=Pervasives.compare) ~x a =
bsearch_ ~cmp x a 0 (Array.length a-1)
(*$T bsearch (*$T bsearch
bsearch 3 [|1; 2; 2; 3; 4; 10|] = `At 3 bsearch 3 [|1; 2; 2; 3; 4; 10|] = `At 3
@ -440,23 +446,23 @@ let bsearch ?(cmp=Pervasives.compare) k a = bsearch_ ~cmp k a 0 (Array.length a-
bsearch 3 [| |] = `Empty bsearch 3 [| |] = `Empty
*) *)
let (>>=) a f = flat_map f a let (>>=) a f = flat_map ~f a
let (>>|) a f = map f a let (>>|) a f = map ~f a
let (>|=) a f = map f a let (>|=) a f = map ~f a
let for_all p a = _for_all p a 0 (Array.length a) let for_all ~f a = _for_all f a 0 (Array.length a)
let exists p a = _exists p a 0 (Array.length a) let exists ~f a = _exists f a 0 (Array.length a)
let for_all2 p a b = let for_all2 ~f a b =
Array.length a = Array.length b Array.length a = Array.length b
&& &&
_for_all2 p a b 0 0 ~len:(Array.length a) _for_all2 f a b 0 0 ~len:(Array.length a)
let exists2 p a b = let exists2 ~f a b =
_exists2 p a b 0 0 ~len:(min (Array.length a) (Array.length b)) _exists2 f a b 0 0 ~len:(min (Array.length a) (Array.length b))
let (--) i j = let (--) i j =
if i<=j if i<=j
@ -466,22 +472,22 @@ let (--) i j =
Array.init (i-j+1) (fun k -> i-k) Array.init (i-j+1) (fun k -> i-k)
(** all the elements of a, but the i-th, into a list *) (** all the elements of a, but the i-th, into a list *)
let except_idx a i = let except_idx a ~i =
foldi foldi
(fun acc j elt -> if i = j then acc else elt::acc) ~f:(fun acc j elt -> if i = j then acc else elt::acc)
[] a ~x:[] a
let equal eq a b = let equal ?(eq=(=)) a b =
Array.length a = Array.length b Array.length a = Array.length b
&& &&
_equal eq a 0 (Array.length a) b 0 (Array.length b) _equal eq a 0 (Array.length a) b 0 (Array.length b)
let compare cmp a b = let compare ?(cmp=Pervasives.compare) a b =
_compare cmp a 0 (Array.length a) b 0 (Array.length b) _compare cmp a 0 (Array.length a) b 0 (Array.length b)
let shuffle a = _shuffle Random.int a 0 (Array.length a) let shuffle a = _shuffle Random.int a 0 (Array.length a)
let shuffle_with st a = _shuffle (Random.State.int st) a 0 (Array.length a) let shuffle_with ~st a = _shuffle (Random.State.int st) a 0 (Array.length a)
let random_choose a st = _choose a 0 (Array.length a) st let random_choose a st = _choose a 0 (Array.length a) st
@ -502,7 +508,7 @@ let pp_i ?(sep=", ") pp_item buf a = _pp_i ~sep pp_item buf a 0 (Array.length a)
let print ?(sep=", ") pp_item fmt a = _print ~sep pp_item fmt a 0 (Array.length a) let print ?(sep=", ") pp_item fmt a = _print ~sep pp_item fmt a 0 (Array.length a)
let to_seq a k = iter k a let to_seq a k = iter ~f:k a
let to_gen a = _to_gen a 0 (Array.length a) let to_gen a = _to_gen a 0 (Array.length a)
@ -539,21 +545,21 @@ module Sub = struct
let sub a i len = make a.arr ~len:(a.i + i) len let sub a i len = make a.arr ~len:(a.i + i) len
let equal eq a b = let equal ?(eq=(=)) a b =
length a = length b && _equal eq a.arr a.i a.j b.arr b.i b.j length a = length b && _equal eq a.arr a.i a.j b.arr b.i b.j
let compare cmp a b = let compare ?(cmp=Pervasives.compare) a b =
_compare cmp a.arr a.i a.j b.arr b.i b.j _compare cmp a.arr a.i a.j b.arr b.i b.j
let fold f acc a = let fold ~f ~x a =
let rec _fold acc i j = let rec _fold acc i j =
if i=j then acc if i=j then acc
else _fold (f acc a.arr.(i)) (i+1) j else _fold (f acc a.arr.(i)) (i+1) j
in _fold acc a.i a.j in _fold x a.i a.j
let foldi f acc a = _foldi f acc a.arr a.i a.j let foldi ~f ~x a = _foldi f x a.arr a.i a.j
let fold_while f acc a = let fold_while ~f ~x:acc a =
let rec fold_while_i f acc i = let rec fold_while_i f acc i =
if i < Array.length a.arr && i < a.j then if i < Array.length a.arr && i < a.j then
let acc, cont = f acc a.arr.(i) in let acc, cont = f acc a.arr.(i) in
@ -573,15 +579,16 @@ module Sub = struct
if i<0 || j>=a.j then invalid_arg "Array.Sub.set"; if i<0 || j>=a.j then invalid_arg "Array.Sub.set";
a.arr.(j) <- x a.arr.(j) <- x
let iter f a = let iter ~f a =
for k=a.i to a.j-1 do f a.arr.(k) done for k=a.i to a.j-1 do f a.arr.(k) done
let iteri f a = let iteri ~f a =
for k=0 to length a-1 do f k a.arr.(a.i + k) done for k=0 to length a-1 do f k a.arr.(a.i + k) done
let blit a i b j len = let blit ~from ~i ~into ~j ~len =
if i+len>length a || j+len>length b then invalid_arg "Array.Sub.blit"; if i+len>length from || j+len>length into
Array.blit a.arr (a.i+i) b.arr (b.i+j) len then invalid_arg "Array.Sub.blit";
Array.blit from.arr (from.i+i) into.arr (into.i+j) len
let reverse_in_place a = _reverse_in_place a.arr a.i ~len:(length a) let reverse_in_place a = _reverse_in_place a.arr a.i ~len:(length a)
@ -590,32 +597,32 @@ module Sub = struct
Sub.reverse_in_place s; a = [| 1; 2; 5; 4; 3; 6 |] Sub.reverse_in_place s; a = [| 1; 2; 5; 4; 3; 6 |]
*) *)
let find f a = _find (fun _ -> f) a.arr a.i a.j let find ~f a = _find (fun _ -> f) a.arr a.i a.j
let findi f a = _find (fun i -> f (i-a.i)) a.arr a.i a.j let findi ~f a = _find (fun i -> f (i-a.i)) a.arr a.i a.j
let find_idx p a = let find_idx ~f a =
_find (fun i x -> if p x then Some (i,x) else None) a.arr a.i a.j _find (fun i x -> if f x then Some (i,x) else None) a.arr a.i a.j
let lookup_exn ?(cmp=Pervasives.compare) k a = let lookup_exn ?(cmp=Pervasives.compare) ~x a =
_lookup_exn ~cmp k a.arr a.i (a.j-1) _lookup_exn ~cmp x a.arr a.i (a.j-1)
let lookup ?(cmp=Pervasives.compare) k a = let lookup ?(cmp=Pervasives.compare) ~x a =
try Some (_lookup_exn ~cmp k a.arr a.i (a.j-1)) try Some (_lookup_exn ~cmp x a.arr a.i (a.j-1))
with Not_found -> None with Not_found -> None
let bsearch ?(cmp=Pervasives.compare) k a = let bsearch ?(cmp=Pervasives.compare) ~x a =
bsearch_ ~cmp k a.arr a.i (a.j - 1) bsearch_ ~cmp x a.arr a.i (a.j - 1)
let for_all p a = _for_all p a.arr a.i a.j let for_all ~f a = _for_all f a.arr a.i a.j
let exists p a = _exists p a.arr a.i a.j let exists ~f a = _exists f a.arr a.i a.j
let for_all2 p a b = let for_all2 ~f a b =
length a = length b && _for_all2 p a.arr b.arr a.i b.i ~len:(length a) length a = length b && _for_all2 f a.arr b.arr a.i b.i ~len:(length a)
let exists2 p a b = let exists2 ~f a b =
_exists2 p a.arr b.arr a.i b.i ~len:(min (length a) (length b)) _exists2 f a.arr b.arr a.i b.i ~len:(min (length a) (length b))
(*$T (*$T
Sub.exists2 (=) (Sub.make [| 1;2;3;4 |] 1 ~len:2) (Sub.make [| 0;1;3;4 |] 1 ~len:3) Sub.exists2 (=) (Sub.make [| 1;2;3;4 |] 1 ~len:2) (Sub.make [| 0;1;3;4 |] 1 ~len:3)
@ -624,7 +631,7 @@ module Sub = struct
let shuffle a = let shuffle a =
_shuffle Random.int a.arr a.i a.j _shuffle Random.int a.arr a.i a.j
let shuffle_with st a = let shuffle_with ~st a =
_shuffle (Random.State.int st) a.arr a.i a.j _shuffle (Random.State.int st) a.arr a.i a.j
let random_choose a st = _choose a.arr a.i a.j st let random_choose a st = _choose a.arr a.i a.j st
@ -635,7 +642,7 @@ module Sub = struct
let print ?(sep=", ") pp_item fmt a = _print ~sep pp_item fmt a.arr a.i a.j let print ?(sep=", ") pp_item fmt a = _print ~sep pp_item fmt a.arr a.i a.j
let to_seq a k = iter k a let to_seq a k = iter ~f:k a
let to_gen a = _to_gen a.arr a.i a.j let to_gen a = _to_gen a.arr a.i a.j

53
src/core/CCArray.mli
View file

@ -40,9 +40,9 @@ module type S = sig
val empty : 'a t val empty : 'a t
val equal : 'a equal -> 'a t equal val equal : ?eq:'a equal -> 'a t equal
val compare : 'a ord -> 'a t ord val compare : ?cmp:'a ord -> 'a t ord
val get : 'a t -> int -> 'a val get : 'a t -> int -> 'a
@ -50,52 +50,55 @@ module type S = sig
val length : _ t -> int val length : _ t -> int
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a val fold : f:('a -> 'b -> 'a) -> x:'a -> 'b t -> 'a
val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b t -> 'a val foldi : f:('a -> int -> 'b -> 'a) -> x:'a -> 'b t -> 'a
(** Fold left on array, with index *) (** Fold left on array, with index *)
val fold_while : ('a -> 'b -> 'a * [`Stop | `Continue]) -> 'a -> 'b t -> 'a val fold_while :
f:('a -> 'b -> 'a * [`Stop | `Continue]) ->
x:'a -> 'b t -> 'a
(** Fold left on array until a stop condition via [('a, `Stop)] is (** Fold left on array until a stop condition via [('a, `Stop)] is
indicated by the accumulator indicated by the accumulator
@since 0.8 *) @since 0.8 *)
val iter : ('a -> unit) -> 'a t -> unit val iter : f:('a -> unit) -> 'a t -> unit
val iteri : (int -> 'a -> unit) -> 'a t -> unit val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
val blit : 'a t -> int -> 'a t -> int -> int -> unit val blit : from:'a t -> i:int -> into:'a t -> j:int -> len:int -> unit
(** [blit from i into j len] copies [len] elements from the first array (** [blit from i into j len] copies [len] elements from the first array
to the second. See {!Array.blit}. *) to the second. See {!Array.blit}. *)
val reverse_in_place : 'a t -> unit val reverse_in_place : 'a t -> unit
(** Reverse the array in place *) (** Reverse the array in place *)
val find : ('a -> 'b option) -> 'a t -> 'b option val find : f:('a -> 'b option) -> 'a t -> 'b option
(** [find f a] returns [Some y] if there is an element [x] such (** [find f a] returns [Some y] if there is an element [x] such
that [f x = Some y], else it returns [None] *) that [f x = Some y], else it returns [None] *)
val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
(** Like {!find}, but also pass the index to the predicate function. (** Like {!find}, but also pass the index to the predicate function.
@since 0.3.4 *) @since 0.3.4 *)
val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option val find_idx : f:('a -> bool) -> 'a t -> (int * 'a) option
(** [find_idx p x] returns [Some (i,x)] where [x] is the [i]-th element of [l], (** [find_idx p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
and [p x] holds. Otherwise returns [None] and [p x] holds. Otherwise returns [None]
@since 0.3.4 *) @since 0.3.4 *)
val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option val lookup : ?cmp:'a ord -> x:'a -> 'a t -> int option
(** Lookup the index of some value in a sorted array. (** Lookup the index of some value in a sorted array.
@param x the value that is looked up
@return [None] if the key is not present, or @return [None] if the key is not present, or
[Some i] ([i] the index of the key) otherwise *) [Some i] ([i] the index of the key) otherwise *)
val lookup_exn : ?cmp:'a ord -> 'a -> 'a t -> int val lookup_exn : ?cmp:'a ord -> x:'a -> 'a t -> int
(** Same as {!lookup_exn}, but (** Same as {!lookup_exn}, but
@raise Not_found if the key is not present *) @raise Not_found if the key is not present *)
val bsearch : ?cmp:('a -> 'a -> int) -> 'a -> 'a t -> val bsearch : ?cmp:('a -> 'a -> int) -> x:'a -> 'a t ->
[ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ] [ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
(** [bsearch ?cmp x arr] finds the index of the object [x] in the array [arr], (** [bsearch ?cmp ~x arr] finds the index of the object [x] in the array [arr],
provided [arr] is {b sorted} using [cmp]. If the array is not sorted, provided [arr] is {b sorted} using [cmp]. If the array is not sorted,
the result is not specified (may raise Invalid_argument). the result is not specified (may raise Invalid_argument).
@ -112,22 +115,22 @@ module type S = sig
@raise Invalid_argument if the array is found to be unsorted w.r.t [cmp] @raise Invalid_argument if the array is found to be unsorted w.r.t [cmp]
@since 0.13 *) @since 0.13 *)
val for_all : ('a -> bool) -> 'a t -> bool val for_all : f:('a -> bool) -> 'a t -> bool
val for_all2 : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val for_all2 : f:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
(** Forall on pairs of arrays. (** Forall on pairs of arrays.
@raise Invalid_argument if they have distinct lengths *) @raise Invalid_argument if they have distinct lengths *)
val exists : ('a -> bool) -> 'a t -> bool val exists : f:('a -> bool) -> 'a t -> bool
val exists2 : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val exists2 : f:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
(** Exists on pairs of arrays. (** Exists on pairs of arrays.
@raise Invalid_argument if they have distinct lengths *) @raise Invalid_argument if they have distinct lengths *)
val shuffle : 'a t -> unit val shuffle : 'a t -> unit
(** Shuffle randomly the array, in place *) (** Shuffle randomly the array, in place *)
val shuffle_with : Random.State.t -> 'a t -> unit val shuffle_with : st:Random.State.t -> 'a t -> unit
(** Like shuffle but using a specialized random state *) (** Like shuffle but using a specialized random state *)
val random_choose : 'a t -> 'a random_gen val random_choose : 'a t -> 'a random_gen
@ -159,16 +162,16 @@ type 'a t = 'a array
include S with type 'a t := 'a t include S with type 'a t := 'a t
val map : ('a -> 'b) -> 'a t -> 'b t val map : f:('a -> 'b) -> 'a t -> 'b t
val filter : ('a -> bool) -> 'a t -> 'a t val filter : f:('a -> bool) -> 'a t -> 'a t
(** Filter elements out of the array. Only the elements satisfying (** Filter elements out of the array. Only the elements satisfying
the given predicate will be kept. *) the given predicate will be kept. *)
val filter_map : ('a -> 'b option) -> 'a t -> 'b t val filter_map : f:('a -> 'b option) -> 'a t -> 'b t
(** Map each element into another value, or discard it *) (** Map each element into another value, or discard it *)
val flat_map : ('a -> 'b t) -> 'a t -> 'b array val flat_map : f:('a -> 'b t) -> 'a t -> 'b array
(** Transform each element into an array, then flatten *) (** Transform each element into an array, then flatten *)
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
@ -182,7 +185,7 @@ val (>|=) : 'a t -> ('a -> 'b) -> 'b t
(** Infix version of {!map} (** Infix version of {!map}
@since 0.8 *) @since 0.8 *)
val except_idx : 'a t -> int -> 'a list val except_idx : 'a t -> i:int -> 'a list
(** Remove given index, obtaining the list of the other elements *) (** Remove given index, obtaining the list of the other elements *)
val (--) : int -> int -> int t val (--) : int -> int -> int t