package containers

You can search for identifiers within the package.

in-package search v0.2.0

package containers

containers
- CCArray
  - S
  - Sub
- CCBV
- CCBool
- CCCache
- CCDeque
- CCError
  - MONAD
  - Traverse
    
    M
- CCFQueue
- CCFlatHashtbl
  - HASHABLE
  - Make
    
    X
  - S
- CCFloat
- CCFun
  - Monad
    
    X
- CCGen
  - Infix
  - Restart
    
    Infix
- CCHash
- CCHashtbl
  - COUNTER
  - DEFAULT
  - Make
    
    X
  - MakeCounter
    
    X
  - MakeDefault
    
    X
  - S
- CCHeap
  - Make
    
    E
  - PARTIAL_ORD
  - S
- CCIO
  - File
- CCInt
- CCKList
  - MONAD
  - Traverse
    
    M
- CCKTree
  - Dot
  - pset
- CCList
  - Assoc
  - Idx
  - MONAD
  - Ref
  - Set
  - Traverse
    
    M
  - Zipper
- CCMap
  - Make
    
    O
  - S
- CCMultiMap
  - BIDIR
  - Make
    
    K
    
    V
  - MakeBidir
    
    L
    
    R
  - OrderedType
  - S
- CCMultiSet
  - Make
    
    O
  - S
- CCOpt
- CCOrd
- CCPair
- CCPersistentHashtbl
  - HashedType
  - Make
    
    H
  - S
- CCPrint
  - MONAD_IO
  - MakeIO
    
    M
- CCRandom
- CCSequence
  - IO
  - Infix
  - Map
    
    Adapt
    
    M
    
    Make
    
    V
    
    S
  - Set
    
    Adapt
    
    X
    
    Make
    
    X
    
    S
- CCSexp
  - L
  - Lexer
  - ParseGen
  - Source
    
    Manual
  - Traverse
- CCString
  - S
  - Split
  - Sub
- CCTrie
  - Make
    
    W
  - MakeArray
    
    X
  - MakeList
    
    X
  - ORDERED
  - S
  - String
  - WORD
- CCVector
- Gen_intf
  - S
    
    Infix
containers.advanced
- Containers_advanced
containers.misc
- Containers_misc
containers.pervasives
- CCPervasives
  - Array
  - List
  - String
containers.string
- Containers_string

Legend:
Library
Module
Module type
Parameter
Class
Class type

type 'a t

A slice is an array, an offset, and a length

val make : 'a array -> int -> len:int -> 'a t

Create a slice.

raises Invalid_argument
if the slice isn't valid

val of_slice : ('a array * int * int) -> 'a t

Make a sub-array from a triple (arr, i, len) where arr is the array, i the offset in arr, and len the number of elements of the slice.

raises Invalid_argument
if the slice isn't valid (See make)

val to_slice : 'a t -> 'a array * int * int

Convert into a triple (arr, i, len) where len is the length of the subarray of arr starting at offset i

val full : 'a array -> 'a t

Slice that covers the full array

val underlying : 'a t -> 'a array

Underlying array (shared). Modifying this array will modify the slice

val copy : 'a t -> 'a array

Copy into a new array

val sub : 'a t -> int -> int -> 'a t

Sub-slice

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