Previous  Up  Next

Module CCArrayLabels

module CCArrayLabels: sig .. end

Array utils


type 'a sequence = ('a -> unit) -> unit 
type 'a klist = unit -> [ `Cons of 'a * 'a klist | `Nil ] 
type 'a gen = unit -> 'a option 
type 'a equal = 'a -> 'a -> bool 
type 'a ord = 'a -> 'a -> int 
type 'a random_gen = Random.State.t -> 'a 
type 'a printer = Format.formatter -> 'a -> unit

Arrays


include ArrayLabels
type 'a t = 'a array 
val empty : 'a t
val equal : 'a equal -> 'a t equal
val compare : 'a ord -> 'a t ord
val get : 'a t -> int -> 'a
val get_safe : 'a t -> int -> 'a option
get_safe a i returns Some a.(i) if i is a valid index
Since 0.18
val set : 'a t -> int -> 'a -> unit
val length : 'a t -> int
val fold : f:('a -> 'b -> 'a) -> init:'a -> 'b t -> 'a
val foldi : f:('a -> int -> 'b -> 'a) -> init:'a -> 'b t -> 'a
Fold left on array, with index
val fold_while : f:('a -> 'b -> 'a * [ `Continue | `Stop ]) ->
       init:'a -> 'b t -> 'a
Fold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator
Since 0.8
val iter : f:('a -> unit) -> 'a t -> unit
val iteri : f:(int -> 'a -> unit) -> 'a t -> unit
val blit : 'a t -> int -> 'a t -> int -> int -> unit
blit from i into j len copies len elements from the first array to the second. See Array.blit.
val reverse_in_place : 'a t -> unit
Reverse the array in place
val sorted : f:('a -> 'a -> int) -> 'a t -> 'a array
sorted cmp a makes a copy of a and sorts it with cmp.
Since 1.0
val sort_indices : f:('a -> 'a -> int) -> 'a t -> int array
sort_indices cmp a returns a new array b, with the same length as a, such that b.(i) is the index of the i-th element of a in sort cmp a. In other words, map (fun i -> a.(i)) (sort_indices a) = sorted cmp a. a is not modified.
Since 1.0
val sort_ranking : f:('a -> 'a -> int) -> 'a t -> int array
sort_ranking cmp a returns a new array b, with the same length as a, such that b.(i) is the position in sorted cmp a of the i-th element of a. a is not modified.

In other words, map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a.

Without duplicates, we also have lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i)
Since 1.0

val find : f:('a -> 'b option) -> 'a t -> 'b option
find f a returns Some y if there is an element x such that f x = Some y, else it returns None
val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b option
Like CCArrayLabels.find, but also pass the index to the predicate function.
Since 0.3.4
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, and p x holds. Otherwise returns None
Since 0.3.4
val lookup : ?cmp:'a ord -> key:'a -> 'a t -> int option
Lookup the index of some value in a sorted array.
Returns None if the key is not present, or Some i (i the index of the key) otherwise
val lookup_exn : ?cmp:'a ord -> key:'a -> 'a t -> int
Same as CCArrayLabels.lookup_exn, but
Raises Not_found if the key is not present
val bsearch : ?cmp:('a -> 'a -> int) ->
       key:'a ->
       'a t ->
       [ `All_bigger | `All_lower | `At of int | `Empty | `Just_after of int ]
bsearch ?cmp key arr finds the index of the object key in the array arr, provided arr is sorted using cmp. If the array is not sorted, the result is not specified (may raise Invalid_argument).

Complexity: O(log n) where n is the length of the array (dichotomic search).
Since 0.13
Raises Invalid_argument if the array is found to be unsorted w.r.t cmp
Returns - `At i if cmp arr.(i) key = 0 (for some i)


val for_all : f:('a -> bool) -> 'a t -> bool
val for_all2 : f:('a -> 'b -> bool) -> 'a t -> 'b t -> bool
Forall on pairs of arrays.
Since 0.20
Raises Invalid_argument if they have distinct lengths allow different types
val exists : f:('a -> bool) -> 'a t -> bool
val exists2 : f:('a -> 'b -> bool) -> 'a t -> 'b t -> bool
Exists on pairs of arrays.
Since 0.20
Raises Invalid_argument if they have distinct lengths allow different types
val fold2 : f:('acc -> 'a -> 'b -> 'acc) ->
       init:'acc -> 'a t -> 'b t -> 'acc
Fold on two arrays stepwise.
Since 0.20
Raises Invalid_argument if they have distinct lengths
val iter2 : f:('a -> 'b -> unit) -> 'a t -> 'b t -> unit
Iterate on two arrays stepwise.
Since 0.20
Raises Invalid_argument if they have distinct lengths
val shuffle : 'a t -> unit
Shuffle randomly the array, in place
val shuffle_with : Random.State.t -> 'a t -> unit
Like shuffle but using a specialized random state
val random_choose : 'a t -> 'a random_gen
Choose an element randomly.
Raises Not_found if the array/slice is empty
val to_seq : 'a t -> 'a sequence
val to_gen : 'a t -> 'a gen
val to_klist : 'a t -> 'a klist

IO


val pp : ?sep:string ->
       'a printer -> 'a t printer
Print an array of items with printing function
val pp_i : ?sep:string ->
       (int -> 'a printer) -> 'a t printer
Print an array, giving the printing function both index and item
val map : f:('a -> 'b) -> 'a t -> 'b t
val map2 : f:('a -> 'b -> 'c) ->
       'a t -> 'b t -> 'c t
Map on two arrays stepwise.
Since 0.20
Raises Invalid_argument if they have distinct lengths
val rev : 'a t -> 'a t
Copy + reverse in place
Since 0.20
val filter : f:('a -> bool) -> 'a t -> 'a t
Filter elements out of the array. Only the elements satisfying the given predicate will be kept.
val filter_map : f:('a -> 'b option) -> 'a t -> 'b t
Map each element into another value, or discard it
val flat_map : f:('a -> 'b t) -> 'a t -> 'b array
Transform each element into an array, then flatten
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
Infix version of CCArrayLabels.flat_map
val (>>|) : 'a t -> ('a -> 'b) -> 'b t
Infix version of CCArrayLabels.map
Since 0.8
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
Infix version of CCArrayLabels.map
Since 0.8
val except_idx : 'a t -> int -> 'a list
Remove given index, obtaining the list of the other elements
val (--) : int -> int -> int t
Range array
val (--^) : int -> int -> int t
Range array, excluding right bound
Since 0.17
val random : 'a random_gen -> 'a t random_gen
val random_non_empty : 'a random_gen -> 'a t random_gen
val random_len : int ->
       'a random_gen -> 'a t random_gen

Generic Functions


module type MONO_ARRAY = sig .. end
val sort_generic : (module CCArrayLabels.MONO_ARRAY with type elt = 'elt and type t = 'arr) ->
       ?cmp:('elt -> 'elt -> int) -> 'arr -> unit
Sort the array, without allocating (eats stack space though). Performance might be lower than Array.sort.
Since 0.14