package core_kernel

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

Generate a specialised version of Vec with a custom index type.

Parameters

module M : Core.Intable.S

Signature

type 'a t
include Ppx_compare_lib.Comparable.S1 with type 'a t := 'a t
val compare : 'a Base__Ppx_compare_lib.compare -> 'a t Base__Ppx_compare_lib.compare
include Ppx_compare_lib.Equal.S1 with type 'a t := 'a t
val equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equal
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
include Core.Invariant.S1 with type 'a t := 'a t
val invariant : 'a Base__Invariant_intf.inv -> 'a t Base__Invariant_intf.inv
val create : ?initial_capacity:int -> unit -> 'a t
val init : int -> f:(int -> 'a) -> 'a t

init n ~f returns a fresh vector of length n, with element number i initialized to the result of f i. In other words, init n ~f tabulates the results of f applied to the integers 0 to n-1.

Raise Invalid_argument if n < 0.

val get : 'a t -> M.t -> 'a

Raises if the index is invalid.

val maybe_get : 'a t -> M.t -> 'a option
val set : 'a t -> M.t -> 'a -> unit

Raises if the index is invalid.

include Core.Container.S1 with type 'a t := 'a t
val mem : 'a t -> 'a -> equal:('a -> 'a -> bool) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc
val fold_result : 'a t -> init:'acc -> f:('acc -> 'a -> ('acc, 'e) Base__.Result.t) -> ('acc, 'e) Base__.Result.t
val fold_until : 'a t -> init:'acc -> f:('acc -> 'a -> ('acc, 'final) Base__Container_intf.Continue_or_stop.t) -> finish:('acc -> 'final) -> 'final
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum : (module Base__Container_intf.Summable with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_array : 'a t -> 'a array
val min_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> compare:('a -> 'a -> int) -> 'a option
include Core.Blit.S1 with type 'a t := 'a t
val blit : ('a t, 'a t) Base__Blit_intf.blit
val blito : ('a t, 'a t) Base__Blit_intf.blito
val unsafe_blit : ('a t, 'a t) Base__Blit_intf.blit
val sub : ('a t, 'a t) Base__Blit_intf.sub
val subo : ('a t, 'a t) Base__Blit_intf.subo
val find_exn : 'a t -> f:('a -> bool) -> 'a

Finds the first 'a for which f is true *

val sort : ?pos:int -> ?len:int -> 'a t -> compare:('a -> 'a -> int) -> unit

sort uses constant heap space. To sort only part of the array, specify pos to be the index to start sorting from and len indicating how many elements to sort.

val is_sorted : 'a t -> compare:('a -> 'a -> int) -> bool
val next_free_index : 'a t -> M.t
val push_back : 'a t -> 'a -> unit
val push_back_index : 'a t -> 'a -> M.t
val grow_to : 'a t -> len:int -> default:'a -> unit

Grows the vec to the specified length if it is currently shorter. Sets all new indices to default.

val shrink_to : 'a t -> len:int -> unit

Shortens the vec to the specified length if it is currently longer. Raises if len < 0.

val remove_exn : 'a t -> int -> unit

remove vec i Removes the i-th element of the vector. This is not a fast implementation, and runs in O(N) time. (ie: it calls caml_modify under the hood)

val find_and_remove : 'a t -> f:('a -> bool) -> 'a option

Find the first element that satisfies f. If exists, remove the element from the vector and return it. This is not a fast implementation, and runs in O(N) time.

val pop_back_exn : 'a t -> 'a
val pop_back_unit_exn : 'a t -> unit
val peek_back : 'a t -> 'a option
val peek_back_exn : 'a t -> 'a
val iteri : 'a t -> f:(M.t -> 'a -> unit) -> unit
val to_list : 'a t -> 'a list
val to_alist : 'a t -> (M.t * 'a) list
val of_list : 'a list -> 'a t
val of_array : 'a array -> 'a t
val take_while : 'a t -> f:('a -> bool) -> 'a t

take_while t ~f returns a fresh vec containing the longest prefix of t for which f is true.

module Inplace : sig ... end
val capacity : _ t -> int

The number of elements we can hold without growing.

val clear : _ t -> unit

clear t discards all elements from t in O(length) time.

val copy : 'a t -> 'a t

copy t returns a copy of t, that is, a fresh vec containing the same elements as t.

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

exists t ~f returns true if f evaluates true on any element, else false

val swap : _ t -> M.t -> M.t -> unit

swap the values at the provided indices

val swap_to_last_and_pop : 'a t -> M.t -> 'a

swap_to_last_and_pop t i is equivalent to swap t i (length t - 1); pop_back_exn t. It raises if i is out of bounds.

module With_structure_details : sig ... end
val unsafe_get : 'a t -> M.t -> 'a
val unsafe_set : 'a t -> M.t -> 'a -> unit
module Stable : sig ... end
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct