package containers

  1. Overview
  2. Docs
package containers
Legend:
Library
Module
Module type
Parameter
Class
Class type

Array utils

type 'a sequence = ('a -> unit) -> unit
type 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]
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

Abstract Signature

module type S = sig ... end

Arrays

type 'a t = 'a array
include S with type 'a t := 'a t
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 set : 'a t -> int -> 'a -> unit
val length : _ t -> int
val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b

fold left on array, with index

val iter : ('a -> unit) -> 'a t -> unit
val iteri : (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 find : ('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 : (int -> 'a -> 'b option) -> 'a t -> 'b option

Like find, but also pass the index to the predicate function.

  • since 0.3.4
val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option

find 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 -> '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 -> 'a -> 'a t -> int

Same as lookup_exn, but

  • raises Not_found

    if the key is not present

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

Forall on pairs of arrays.

  • raises Invalid_argument

    if they have distinct lengths

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

Exists on pairs of arrays.

  • 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 -> (Buffer.t -> 'a -> unit) -> Buffer.t -> 'a t -> unit

print an array of items with printing function

val pp_i : ?sep:string -> (Buffer.t -> int -> 'a -> unit) -> Buffer.t -> 'a t -> unit

print an array, giving the printing function both index and item

val print : ?sep:string -> (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a t -> unit

print an array of items with printing function

val map : ('a -> 'b) -> 'a t -> 'b t
val filter : ('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 : ('a -> 'b option) -> 'a t -> 'b t

Map each element into another value, or discard it

val flat_map : ('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 flat_map

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 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

Slices

A slice is a part of an array, that requires no copying and shares its storage with the original array.

All indexing in a slice is relative to the beginning of a slice, not to the underlying array (meaning a slice is effectively like a regular array)

module Sub : sig ... end