package res

You can search for identifiers within the package.

in-package search v0.2.0

res
- Nopres_impl
  - Implementation
  - Make
    
    Impl
    
    S
    
    Strategy
- Nopres_intf
  - Buffer
    
    Strategy
  - T
    
    Strategy
- Pres_impl
  - Implementation
  - Make
    
    Impl
    
    S
    
    Strategy
- Pres_intf
  - T
    
    Strategy
- Res
  - Array
    
    Strategy
  - BitDefStrat
  - Bits
    
    Strategy
  - Buffer
    
    Strategy
  - DefStrat
  - Floats
    
    Strategy
  - MakeArray
    
    S
    
    Strategy
  - MakeBits
    
    S
    
    Strategy
  - MakeBuffer
    
    S
    
    Strategy
  - MakeFloats
    
    S
    
    Strategy
  - MakeWeak
    
    S
    
    Strategy
  - Weak
    
    Strategy
- Strat
  - T
- Weak_impl
  - Make
    
    S
    
    Strategy
- Weak_intf
  - T
    
    Strategy

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Strategy : sig ... end

type strategy = Strategy.t

type t

type el = float

val length : t -> int

val lix : t -> int

val real_length : t -> int

val real_lix : t -> int

val get : t -> int -> el

val set : t -> int -> el -> unit

val sempty : strategy -> t

val empty : unit -> t

val screate : strategy -> int -> t

val create : int -> t

val smake : strategy -> int -> el -> t

val make : int -> el -> t

val sinit : strategy -> int -> (int -> el) -> t

val init : int -> (int -> el) -> t

val get_strategy : t -> strategy

val set_strategy : t -> strategy -> unit

val put_strategy : t -> strategy -> unit

val enforce_strategy : t -> unit

val copy : t -> t

val sub : t -> int -> int -> t

val fill : t -> int -> int -> el -> unit

val blit : t -> int -> t -> int -> int -> unit

val append : t -> t -> t

val concat : t list -> t

val add_one : t -> el -> unit

val remove_one : t -> unit

val remove_n : t -> int -> unit

val remove_range : t -> int -> int -> unit

val clear : t -> unit

val swap : t -> int -> int -> unit

val swap_in_last : t -> int -> unit

val to_array : t -> el array

val sof_array : strategy -> el array -> t

val of_array : el array -> t

val to_list : t -> el list

val sof_list : strategy -> el list -> t

val of_list : el list -> t

val iter : (el -> unit) -> t -> unit

val map : (el -> el) -> t -> t

val iteri : (int -> el -> unit) -> t -> unit

val mapi : (int -> el -> el) -> t -> t

val fold_left : ('a -> el -> 'a) -> 'a -> t -> 'a

val fold_right : (el -> 'a -> 'a) -> t -> 'a -> 'a

val for_all : (el -> bool) -> t -> bool

val exists : (el -> bool) -> t -> bool

val mem : el -> t -> bool

val memq : el -> t -> bool

val pos : el -> t -> int option

val posq : el -> t -> int option

val find : (el -> bool) -> t -> el

val find_index : (el -> bool) -> t -> int -> int

val filter : (el -> bool) -> t -> t

val find_all : (el -> bool) -> t -> t

val filter_in_place : (el -> bool) -> t -> unit

val partition : (el -> bool) -> t -> t * t

val unsafe_get : t -> int -> el

val unsafe_set : t -> int -> el -> unit

val unsafe_sub : t -> int -> int -> t

val unsafe_fill : t -> int -> int -> el -> unit

val unsafe_blit : t -> int -> t -> int -> int -> unit

val unsafe_remove_one : t -> unit

val unsafe_remove_n : t -> int -> unit

val unsafe_swap : t -> int -> int -> unit

val unsafe_swap_in_last : t -> int -> unit