package vec

  1. Overview
  2. Docs
package vec
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module VecSource

Mutable dynamic arrays

Sourcetype ('a, -'p) t

A value of type ('a, 'p) Vec.t is a vector of values of type 'a, with mutability permissions 'p.

The permissions can be [`R | `W] for read-write vectors, [`R] for read-only vectors, or [`W] for write-only vectors.

Reading vector properties

Sourceval length : ('a, [> ]) t -> int

Returns the length of the vector.

Sourceval capacity : ('a, [> ]) t -> int

Returns the capacity of the vector.

Creating vectors

Sourceval make : ?capacity:int -> unit -> ('a, [ `R | `W ]) t

Constructs a vector with the specified capacity (defaults to 0).

Sourceval range : int -> int -> (int, [ `R | `W ]) t

Constructs a vector containing all numbers in the specified range. Both ascending and descending ranges are supported.

Sourceval singleton : 'a -> ('a, [ `R | `W ]) t

Returns a singleton vector containing the specified item. (Applicative functor pure operation)

Sourceval copy : ('a, [> `R ]) t -> ('a, [ `R | `W ]) t

Creates a copy of the vector.

Restricting permissions

Sourceval as_read_only : ('a, [> `R ]) t -> ('a, [ `R ]) t

Reinterprets the vector as a read-only vector.

Sourceval as_write_only : ('a, [> `W ]) t -> ('a, [ `W ]) t

Reinterprets the vector as a write-only vector.

Accessing elements

Sourceval get : ('a, [> `R ]) t -> int -> 'a

Gets the value in the vector at the specified index.

  • raises [Invalid_argument]

    if the index is out of bounds.

Sourceval try_get : ('a, [> `R ]) t -> int -> 'a option

Gets the value in the vector at the specified index. Returns None if the index is out of range.

Sourceval set : ('a, [> `W ]) t -> int -> 'a -> unit

Sets the value in the vector at the specified index to the specified value.

  • raises [Invalid_argument]

    if the index is out of bounds.

Sourceval try_set : ('a, [> `W ]) t -> int -> 'a -> bool

Sets the value in the vector at the specified index to the specified value. Returns false if the index is out of range.

Sourceval find : ('a -> bool) -> ('a, [> `W ]) t -> 'a

Returns the first element of the vector that satisfies the predicate.

  • raises [Not_found]

    if no element satisfies the predicate.

Sourceval try_find : ('a -> bool) -> ('a, [> `W ]) t -> 'a option

Returns the first element of the vector that satisfies the predicate, or None.

Conversions

Sourceval of_list : 'a list -> ('a, [ `R | `W ]) t

Constructs a vector from the specified list.

Sourceval to_list : ('a, [> `R ]) t -> 'a list

Constructs a list from the specified vector.

Sourceval of_array : 'a array -> ('a, [ `R | `W ]) t

Constructs a vector from a copy of the specified array.

Sourceval to_array : ('a, [> `R ]) t -> 'a array

Constructs an array containing the values of specified vector.

Sourceval of_array_unsafe : 'a array -> ('a, [ `R | `W ]) t

Constructs a vector from the specified array, without copying.

Sourceval to_array_unsafe : ('a, [ `R | `W ]) t -> 'a array

Returns the vector's underlying buffer. Note: The array may contain uninitialized elements.

Sourceval pretty_print : ('a -> string) -> ('a, [> `R ]) t -> string

Returns a string representation of the vector, using the specified function to format each value.

Modifying vectors

Sourceval clear : ('a, [> `W ]) t -> unit

Resets the vector to an empty state.

Sourceval reserve : int -> ('a, [> `W ]) t -> unit

Ensures the vector's capacity is at least as large as the specified value, allocating if necessary.

Sourceval shrink_to_fit : ('a, [> `W ]) t -> unit

Shrinks the vector's internal buffer to only be as large as the vector's length.

Sourceval push : 'a -> ('a, [> `W ]) t -> unit

Pushes the specified item onto the end of the vector.

Sourceval pop : ('a, [ `R | `W ]) t -> 'a

Pops off the item from the end of the vector.

  • raises [Invalid_argument]

    if the vector is empty.

Sourceval try_pop : ('a, [ `R | `W ]) t -> 'a option

Pops off the item from the end of the vector. Returns None if the vector is empty.

Sourceval insert_at : int -> 'a -> ('a, [> `W ]) t -> unit

Inserts an item into the vector at the specified index.

  • raises [Invalid_argument]

    if the index is out of bounds.

Sourceval try_insert_at : int -> 'a -> ('a, [> `W ]) t -> bool

Inserts an item into the vector at the specified index. Returns false if the index is out of range.

Sourceval remove_at : int -> ('a, [ `R | `W ]) t -> 'a

Removes and returns the item at the specified index.

  • raises [Invalid_argument]

    if the index is out of bounds.

Sourceval try_remove_at : int -> ('a, [ `R | `W ]) t -> 'a option

Removes and returns the item at the specified index. Returns None if the index is out of range.

Transformations

Sourceval map : ('a -> 'b) -> ('a, [> `R ]) t -> ('b, [ `R | `W ]) t

Maps the specified function over the vector, returning a new vector. (Functor map operation)

Sourceval mapi : (int -> 'a -> 'b) -> ('a, [> `R ]) t -> ('b, [ `R | `W ]) t

Like map, but the function also takes the item's index as a parameter.

Sourceval map_in_place : ('a -> 'a) -> ('a, [ `R | `W ]) t -> unit

Like map, but the transformation is done in-place.

Sourceval flat_map : ('a -> ('b, [> `R ]) t) -> ('a, [> `R ]) t -> ('b, [ `R | `W ]) t

Like map, but flattens the result. (Monad bind operation)

Sourceval rev : ('a, [> `R ]) t -> ('a, [ `R | `W ]) t

Returns a new vector that contains all the items in the specified vector, but in reverse order.

Sourceval rev_in_place : ('a, [ `R | `W ]) t -> unit

Reverses the vector in-place.

Filters & folds

Sourceval filter : ('a -> bool) -> ('a, [> `R ]) t -> ('a, [ `R | `W ]) t

Returns a new vector containing only the items from the first vector that satisfy the specified predicate.

Sourceval filteri : (int -> 'a -> bool) -> ('a, [> `R ]) t -> ('a, [ `R | `W ]) t

Like filter, but the predicate also takes the item's index as a parameter.

Sourceval filter_in_place : ('a -> bool) -> ('a, [ `R | `W ]) t -> unit

Performs a filter in-place, based on the specified predicate.

Sourceval fold_left : ('b -> 'a -> 'b) -> 'b -> ('a, [> `R ]) t -> 'b

Folds the specified function and default value over the array, from left to right.

Sourceval fold_right : ('a -> 'b -> 'b) -> ('a, [> `R ]) t -> 'b -> 'b

Folds the specified function and default value over the array, from right to left.

Combining vectors

Sourceval append : ('a, [> `R ]) t -> ('a, [> `R ]) t -> ('a, [ `R | `W ]) t

Concatenates the two vectors into a new vector.

Sourceval append_in_place : ('a, [ `R | `W ]) t -> ('a, [> `R ]) t -> unit

Appends the second vector to the first vector in-place.

Sourceval cartesian_product : ('a, [> `R ]) t -> ('b, [> `R ]) t -> ('a * 'b, [ `R | `W ]) t

Cartesian product of 2 vectors. (Equivalent to liftA2 (,))

Sourceval map2 : ('a -> 'b -> 'c) -> ('a, [> `R ]) t -> ('b, [> `R ]) t -> ('c, [ `R | `W ]) t

Maps the specified function over all combinations of tuples from the 2 vectors, returning a new vector. (Applicative functor liftA2 operation

Sourceval apply : ('a -> 'b, [> `R ]) t -> ('a, [> `R ]) t -> ('b, [ `R | `W ]) t

Applies every function from the first vector to every value from the second vector, returning a new vector. (Applicatve functor ap operation)

Sourceval flatten : (('a, [> `R ]) t, [> `R ]) t -> ('a, [ `R | `W ]) t

Flattens nested vectors into a single, one-dimensional vector. (Monad join operation)

Sourceval zip : ('a, [> `R ]) t -> ('b, [> `R ]) t -> ('a * 'b, [ `R | `W ]) t

Zips the two vectors together.

Sourceval zip_with : ('a -> 'b -> 'c) -> ('a, [> `R ]) t -> ('b, [> `R ]) t -> ('c, [ `R | `W ]) t

Zips the two vectors together, using the specified function to combine values.

Querying vectors

Sourceval exists : ('a -> bool) -> ('a, [> `R ]) t -> bool

Returns true if any item in the vector satisfies the specified predicate.

Sourceval for_all : ('a -> bool) -> ('a, [> `R ]) t -> bool

Returns true if all items in the vector satisfy the specified predicate.

Sourceval mem : 'a -> ('a, [> `R ]) t -> bool

Returns true if the specified item exists in the vector. Uses structural equality.

Sourceval memq : 'a -> ('a, [> `R ]) t -> bool

Returns true if the specified item exists in the vector. Uses physical equality.

Sorting

Sourceval sort : ('a, [ `R | `W ]) t -> unit

Sorts the vector in-place.

Sourceval sort_by : ('a -> 'a -> int) -> ('a, [ `R | `W ]) t -> unit

Sorts the vector in-place, using the specified comparison function.

Equality and comparison

Sourceval equal : ('a, [> `R ]) t -> ('a, [> `R ]) t -> bool

Compares two vectors for equality.

Sourceval equal_by : ('a -> 'a -> bool) -> ('a, [> `R ]) t -> ('a, [> `R ]) t -> bool

Compares two vectors for equality, using the specified equality function for elements.

Sourceval compare : ('a, [> `R ]) t -> ('a, [> `R ]) t -> int

Compares two vectors lexicographically.

Sourceval compare_by : ('a -> 'a -> int) -> ('a, [> `R ]) t -> ('a, [> `R ]) t -> int

Compares two vectors lexicographically, using the specified comparison function for elements.

Iteration

Sourceval iter : ('a -> unit) -> ('a, [> `R ]) t -> unit

Applies the specified function to each item in the vector.

Sourceval iteri : (int -> 'a -> unit) -> ('a, [> `R ]) t -> unit

Like iter, but the function also takes the item's index as a parameter.

Infix operators

Sourcemodule Infix : sig ... end

Contains infix versions of some vector operations, as well as binding operators and extended indexing operators.