devkit

Development kit - general purpose library
IN THIS PACKAGE
Module Devkit_core . Action
val period : int -> ( int -> unit ) -> unit -> unit

period p f

  • returns

    a function pf such that pf () = f i when i mod p = 0, and () otherwise.

val timely : float -> ?first:float -> ( 'a -> unit ) -> 'a -> unit

timely p f

  • parameter first

    the earliest time f x must be executed (now + p by default).

  • returns

    a function pf such that pf x = f x if the last execution of pf x was done more than p seconds ago, or () otherwise.

val timely_counter : float -> ( int -> unit ) -> unit -> unit

Combination of the above, see the code for more info.

Enum utilities

val uniq : ( 'a -> 'b ) -> 'a Enum.t -> 'a Enum.t

uniq f e

  • returns

    enum that will not contain two values x and x' such that f x = f x'.

val all_uniq : ( 'a -> 'b ) -> 'a Enum.t -> bool

all_uniq f e

  • returns

    true iff there is no two values x and x' in e such that f x = f x'.

val chunk_e : int -> 'a Enum.t -> 'a Enum.t Enum.t

chunk_e n e splits enum e into chunks of n elements each (except the last which can be shorter). NB the order in result is not specified

List utilities

val list_min : ?cmp:( 'a -> 'a -> int ) -> 'a list -> 'a

find the minimum element in the list

  • parameter cmp

    compare function, default Pervasives.compare

  • raises Empty_list

    when list is empty

val list_uniq : ( 'a -> 'b ) -> 'a list -> 'a list

list_uniq f l

  • returns

    copy of l that will not contain two values x and x' such that f x = f x'.

val list_sorted_uniq : ( 'a -> 'a -> bool ) -> 'a list -> 'a list

list_sorted_uniq eq_f l

  • returns

    l without consecutive elements x, x' such that eq_f x = eq_f x'.

val list_random_exn : ?state:Random.State.t -> 'a list -> 'a

Get a random element from a list.

val list_random : ?state:Random.State.t -> 'a list -> 'a option
val slice : int -> int -> 'a list -> 'a list

extract sublist from a list, e.g. slice 1 3 [0;1;2;3;4] will return [1;2;3].

Partitioning a list into chunks

val chunk : int -> 'a list -> 'a list list

chunk_e n e splits enum e into chunks of n elements each (except the last which can be shorter). NB the order in result is not specified FIXME?

val partition : int -> 'a list -> 'a list array

partition n l splits l into n chunks, does not preserve the order of the elements.

val unpartition : 'a list array -> 'a list
val stable_partition : int -> 'a list -> 'a list list

stable_partition l n splits l into n chunks, preserves the order of the elements.

val stable_unpartition : 'a list list -> 'a list

Printing

val catmap : ?sep:string -> ( 'a -> string ) -> 'a list -> string
val strl : ( 'a -> string ) -> 'a list -> string
val stra : ( 'a -> string ) -> 'a array -> string

Array utilities

val array_random_exn : ?state:Random.State.t -> 'a array -> 'a
val array_random : ?state:Random.State.t -> 'a array -> 'a option
val array_rfindi : ( 'a -> bool ) -> 'a array -> int

array_rfindi p a

  • returns

    index of first element matching p when iterating a in reverse.

  • raises Not_found

    if no such element exists.

val array_rfind : ( 'a -> bool ) -> 'a array -> 'a

array_rfind p a

  • returns

    value index of first element matching p when iterating a in reverse.

  • raises Not_found

    if no such element exists.

val array_iter_rev : ( 'a -> unit ) -> 'a array -> unit

array_iter_rev f a calls f on each elements of a in reverse order.

val shuffle : ?state:Random.State.t -> 'a array -> unit

shuffle ?state a shuffles an array, giving a uniform random distribution.

  • parameter state

    random state to use (default: global Random state)

val binary_search' : 'a array -> ( 'a -> 'b -> int ) -> 'b -> 'a option

array must be sorted

val chunk_a : int -> 'a array -> 'a array list

chunk_a n a splits array a into chunks of n elements each (except the last which can be shorter), preserving the order of elements, i.e. reverse operation is Array.concat

DynArray utilities

val quick_sort : 'a DynArray.t -> ?start:int -> ?n:int -> ( 'a -> 'a -> int ) -> unit

Hashtbl utilities

val hashtbl_find : ( 'a, 'b ) Hashtbl.t -> ( unit -> 'b ) -> 'a -> 'b

hashtbl_find ht f_default k associates f_default () to k in ht, if no previous association exists.

  • returns

    Hashtbl.find ht k if k is associated with an element in ht, or f_default () otherwise.

Gc / Memory utilities

Memory format parsing/pretty-printing

val parse_bytes_unit : string -> int

Parse memory size specification, accepts: MB KB 1MB 20gb

val show_bytes_unit : int -> string

Pretty-print memory size in a way that can be parsed back by parse_bytes_unit

Pretty-printing

val bytes_of_words : int -> int
val bytes_of_words_f : float -> float
val bytes_string : int -> string

short human-readable display for memory measures

val bytes_string_i64 : int64 -> string
val bytes_string_f : float -> string
val caml_words : int -> string
val caml_words_f : float -> string
val gc_diff : Gc.stat -> Gc.stat -> string

string describing gc current settings.

val gc_show : string -> ( 'a -> 'b ) -> 'a -> 'b
val gc_settings : unit -> string

File IO

val count_bytes_to : int64 ref -> 'a IO.output -> int64 IO.output

Counting bytes. Not closing underlying io.

val count_bytes : 'a IO.output -> int64 IO.output
val io_copy : IO.input -> 'a IO.output -> unit

Copy all data from input to output

val io_null : unit IO.output

/dev/null -like

Extracting lines from a file.

val file_lines_exn : string -> string list
val file_lines : string -> string list
val make_config_lines : string list -> string list

read lines from file skipping empty lines and comments (lines starting with '#')

val config_lines_exn : string -> string list
val config_lines : string -> string list

Time utilities

class timer_start : Time.t -> object ... end

Basic timer. Also allows recording a sequence of interesting times from the given start point. Can serialize recorded events to json (useful for Logstash events)

class timer : object ... end

Convenience wrapper to start timer_start with Time.now()

val uptime : timer

Timer running from the start of the program execution.

val speed : int -> float -> float

Log or time execution of a function

val log : ?name:string -> ( 'a -> unit ) -> 'a -> unit
val log_do : ?name:string -> ( unit -> unit ) -> unit
val perform : ?name:string -> ( 'a -> unit ) -> 'a -> bool

Comparison

val compare_by : ( 'a -> 'b ) -> 'a -> 'a -> int
val compare2 : ( 'a -> 'b -> int ) -> ( 'c -> 'd -> int ) -> ('a * 'c) -> ('b * 'd) -> int
val compare2_by : ( 'a -> 'b ) -> ( 'c -> 'd ) -> ('a * 'c) -> ('a * 'c) -> int
val compare_fst : ( 'a -> 'b -> 'c ) -> ('a * 'd) -> ('b * 'e) -> 'c

Benchmarking functions

val bench : ?compact:( unit -> unit ) -> int -> ( unit -> 'a ) -> string
val run_bench : ?compact:( unit -> unit ) -> int -> (string * ( unit -> 'a )) list -> unit

Command-line arguments

val args : string list

Does not contains Sys.argv.(0).

Misc.

val shell_sequence : string list -> string list

name01 name02 name09 name10 name11 -> name0{1..2} name{09..11}

val hexdump : string -> string
type ewma = ( float -> unit ) * ( unit -> float )

Exponential Weighted Moving Average (smooth) 0.05 < alpha < 0.15 (dynamic)

val ewma : float -> ewma

ewma alpha

  • returns

    f_store, f_get such that f_store is used to add a value to the EWMA and f_get returns the current EWMA including all the value already stored.

val random_bytes : ?state:Random.State.t -> int -> string

generates a string of n random bytes.

val random_ascii : ?state:Random.State.t -> int -> string

generates a string of n random ascii chars.