package commons

  1. Overview
  2. Docs
val verbose_level : int ref
val generic_print : 'a -> string -> string
class 'a olist : 'a list -> object ... end
val typing_sux_test : unit -> unit
type filename = string
type dirname = string
type path = string
module BasicType : sig ... end
module Infix : sig ... end
val _tab_level_print : int ref
val indent_do : (unit -> 'a) -> 'a
val reset_pr_indent : unit -> unit
val _prefix_pr : string ref
val pr : string -> unit
val pr_no_nl : string -> unit
val pr_xxxxxxxxxxxxxxxxx : unit -> unit
val _chan_pr2 : out_channel option ref
val pr2 : string -> unit
val pr2_no_nl : string -> unit
val pr2_xxxxxxxxxxxxxxxxx : unit -> unit
val pr2_gen : 'a -> unit
val dump : 'a -> string
val pr2_once : string -> unit
val mk_pr2_wrappers : bool ref -> (string -> unit) * (string -> unit)
val redirect_stdout_opt : filename option -> (unit -> 'a) -> 'a
val redirect_stdout_stderr : filename -> (unit -> unit) -> unit
val redirect_stdin : filename -> (unit -> unit) -> unit
val redirect_stdin_opt : filename option -> (unit -> unit) -> unit
val with_pr2_to_string : (unit -> unit) -> string list
val spf : ('a, unit, string) format -> 'a
val _chan : out_channel ref
val start_log_file : unit -> unit
val log : string -> unit
val log2 : string -> unit
val log3 : string -> unit
val log4 : string -> unit
val if_log : (unit -> unit) -> unit
val if_log2 : (unit -> unit) -> unit
val if_log3 : (unit -> unit) -> unit
val if_log4 : (unit -> unit) -> unit
val pause : unit -> unit
val _trace_var : int ref
val add_var : unit -> unit
val dec_var : unit -> unit
val get_var : unit -> int
val print_n : int -> string -> unit
val printerr_n : int -> string -> unit
val _debug : bool ref
val debugon : unit -> unit
val debugoff : unit -> unit
val debug : (unit -> unit) -> unit
val get_mem : unit -> string
val memory_stat : unit -> string
val timenow : unit -> string
val _count1 : int ref
val _count2 : int ref
val _count3 : int ref
val _count4 : int ref
val _count5 : int ref
val count1 : unit -> unit
val count2 : unit -> unit
val count3 : unit -> unit
val count4 : unit -> unit
val count5 : unit -> unit
val profile_diagnostic_basic : unit -> string
val time_func : (unit -> 'a) -> 'a
val example : bool -> unit
val example2 : string -> bool -> unit
val assert_equal : 'a -> 'a -> unit
val _list_bool : (string * bool) list ref
val example3 : string -> bool -> unit
val test_all : unit -> unit
type score_result =
  1. | Ok
  2. | Pb of string
type score = (string, score_result) Hashtbl.t
type score_list = (string * score_result) list
val empty_score : unit -> score
val regression_testing : score -> filename -> unit
val regression_testing_vs : score -> score -> score
val total_scores : score -> int * int
val print_score : score -> unit
val print_total_score : score -> unit
type 'a gen = unit -> 'a
val ig : int gen
val lg : 'a gen -> 'a list gen
val pg : 'a gen -> 'b gen -> ('a * 'b) gen
val polyg : int gen
val ng : string gen
val oneofl : 'a list -> 'a gen
val oneof : 'a gen list -> 'a gen
val always : 'a -> 'a gen
val frequency : (int * 'a gen) list -> 'a gen
val frequencyl : (int * 'a) list -> 'a gen
val laws : string -> ('a -> bool) -> 'a gen -> 'a option
val statistic_number : 'a list -> (int * 'a) list
val statistic : 'a list -> (int * 'a) list
val laws2 : string -> ('a -> bool * 'b) -> 'a gen -> 'a option * (int * 'b) list
val get_value : filename -> 'a
val read_value : filename -> 'a
val write_value : 'a -> filename -> unit
val write_back : ('a -> 'b) -> filename -> unit
val marshal__to_string : 'a -> Marshal.extern_flags list -> string
val marshal__from_string : string -> int -> 'a
val _counter : int ref
val _counter2 : int ref
val _counter3 : int ref
val counter : unit -> int
val counter2 : unit -> int
val counter3 : unit -> int
type timestamp = int
val string_of_string : (string -> string) -> string
val string_of_list : ('a -> string) -> 'a list -> string
val string_of_unit : unit -> string
val string_of_array : ('a -> string) -> 'a array -> string
val string_of_option : ('a -> string) -> 'a option -> string
val print_bool : bool -> unit
val print_option : ('a -> unit) -> 'a option -> unit
val print_list : ('a -> unit) -> 'a list -> unit
val print_between : (unit -> unit) -> ('a -> unit) -> 'a list -> unit
val pp_do_in_box : (unit -> unit) -> unit
val pp_f_in_box : (unit -> 'a) -> 'a
val pp_do_in_zero_box : (unit -> unit) -> unit
val pp : string -> unit
val format_to_string : (unit -> unit) -> string
val adjust_pp_with_indent : (unit -> unit) -> unit
val adjust_pp_with_indent_and_header : string -> (unit -> unit) -> unit
val mk_str_func_of_assoc_conv : ('a * string) list -> (string -> 'a) * ('a -> string)
val macro_expand : string -> unit
val (+!>) : 'a ref -> ('a -> 'a) -> unit
val ($) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
val curry : (('a * 'b) -> 'c) -> 'a -> 'b -> 'c
val uncurry : ('a -> 'b -> 'c) -> ('a * 'b) -> 'c
val id : 'a -> 'a
val do_nothing : unit -> unit
val const : 'a -> 'b -> 'a
val forever : (unit -> unit) -> unit
val applyn : int -> ('a -> 'a) -> 'a -> 'a
class 'a shared_variable_hook : 'a -> object ... end
val fixpoint : ('a -> 'a) -> 'a -> 'a
val fixpoint_for_object : (< equal : 'a -> bool.. > as 'a -> 'a) -> 'a -> 'a
val add_hook : ('a -> ('a -> 'b) -> 'b) ref -> ('a -> ('a -> 'b) -> 'b) -> unit
val add_hook_action : ('a -> unit) -> ('a -> unit) list ref -> unit
val run_hooks_action : 'a -> ('a -> unit) list ref -> unit
type 'a mylazy = unit -> 'a
val save_excursion : 'a ref -> 'a -> (unit -> 'b) -> 'b
val save_excursion_and_disable : bool ref -> (unit -> 'b) -> 'b
val save_excursion_and_enable : bool ref -> (unit -> 'b) -> 'b
val memoized : ?use_cache:bool -> ('a, 'b) Hashtbl.t -> 'a -> (unit -> 'b) -> 'b
val cache_in_ref : 'a option ref -> (unit -> 'a) -> 'a
val cache_computation : ?verbose:bool -> ?use_cache:bool -> filename -> string -> (unit -> 'a) -> 'a
val cache_computation_robust : filename -> string -> (filename list * 'x) -> string -> (unit -> 'a) -> 'a
val oncef : ('a -> unit) -> 'a -> unit
val once : bool ref -> (unit -> unit) -> unit
val before_leaving : ('a -> unit) -> 'a -> 'a
exception FileAlreadyLocked
val acquire_file_lock : filename -> unit
val release_file_lock : filename -> unit
exception Here
exception ReturnExn
exception WrongFormat of string
val internal_error : string -> 'a
val myassert : bool -> unit
val warning : string -> 'a -> 'a
val error_cant_have : 'a -> 'b
val exn_to_s : exn -> string
val string_of_exn : exn -> string
val exn_to_s_with_backtrace : exn -> string
type error =
  1. | Error of string
type evotype = unit
val evoval : evotype
val _check_stack : bool ref
val check_stack_size : int -> unit
val check_stack_nbfiles : int -> unit
val _init_gc_stack : unit
val (=|=) : int -> int -> bool
val (=<=) : char -> char -> bool
val (=$=) : string -> string -> bool
val (=:=) : bool -> bool -> bool
val (=*=) : 'a -> 'a -> bool
val (|||) : 'a -> 'a -> 'a
val (==>) : bool -> bool -> bool
val xor : 'a -> 'a -> bool
val string_of_char : char -> string
val string_of_chars : char list -> string
val is_single : char -> bool
val is_symbol : char -> bool
val is_space : char -> bool
val is_upper : char -> bool
val is_lower : char -> bool
val is_alpha : char -> bool
val is_digit : char -> bool
val cbetween : char -> char -> char -> bool
val (/!) : int -> int -> int
val do_n : int -> (unit -> unit) -> unit
val foldn : ('a -> int -> 'a) -> 'a -> int -> 'a
val times : (unit -> unit) -> int -> unit
val pi : float
val pi2 : float
val pi4 : float
val deg_to_rad : float -> float
val clampf : float -> float
val square : float -> float
val power : int -> int -> int
val between : 'a -> 'a -> 'a -> bool
val between_strict : int -> int -> int -> bool
val bitrange : int -> int -> bool
val borne : min:'a -> max:'a -> 'a -> 'a
val prime1 : int -> int option
val prime : int -> int option
val sum : int list -> int
val product : int list -> int
val decompose : int -> int list
val mysquare : int -> int
val sqr : float -> float
type compare =
  1. | Equal
  2. | Inf
  3. | Sup
val (<=>) : 'a -> 'a -> compare
val (<==>) : 'a -> 'a -> int
type uint = int
val int_of_stringchar : string -> int
val int_of_base : string -> int -> int
val int_of_stringbits : string -> int
val int_of_octal : string -> int
val int_of_all : string -> int
val int_of_string_c_octal_opt : string -> int option
val float_of_string_opt : string -> float option
val (+=) : int ref -> int -> unit
val (-=) : int ref -> int -> unit
val pourcent : int -> int -> int
val pourcent_float : int -> int -> float
val pourcent_float_of_floats : float -> float -> float
val pourcent_good_bad : int -> int -> int
val pourcent_good_bad_float : int -> int -> float
type 'a max_with_elem = int ref * 'a ref
val update_max_with_elem : 'a max_with_elem -> is_better:(int -> int ref -> bool) -> (int * 'a) -> unit
type 'a numdict =
  1. | NumDict of ('a -> 'a -> 'a) * ('a -> 'a -> 'a) * ('a -> 'a -> 'a) * ('a -> 'a)
val add : 'a numdict -> 'a -> 'a -> 'a
val mul : 'a numdict -> 'a -> 'a -> 'a
val div : 'a numdict -> 'a -> 'a -> 'a
val neg : 'a numdict -> 'a -> 'a
val numd_int : int numdict
val numd_float : float numdict
val testd : 'a numdict -> 'a -> 'a
module ArithFloatInfix : sig ... end
val _init_random : unit
val random_list : 'a list -> 'a
val randomize_list : 'a list -> 'a list
val random_subset_of_list : int -> 'a list -> 'a list
type 'a pair = 'a * 'a
type 'a triple = 'a * 'a * 'a
val fst3 : ('a * 'b * 'c) -> 'a
val snd3 : ('a * 'b * 'c) -> 'b
val thd3 : ('a * 'b * 'c) -> 'c
val sndthd : ('a * 'b * 'c) -> 'b * 'c
val map_fst : ('a -> 'b) -> ('a * 'c) -> 'b * 'c
val map_snd : ('a -> 'b) -> ('c * 'a) -> 'c * 'b
val pair : ('a -> 'b) -> ('a * 'a) -> 'b * 'b
val triple : ('a -> 'b) -> ('a * 'a * 'a) -> 'b * 'b * 'b
val double : 'a -> 'a * 'a
val swap : ('a * 'b) -> 'b * 'a
val tuple_of_list1 : 'a list -> 'a
val tuple_of_list2 : 'a list -> 'a * 'a
val tuple_of_list3 : 'a list -> 'a * 'a * 'a
val tuple_of_list4 : 'a list -> 'a * 'a * 'a * 'a
val tuple_of_list5 : 'a list -> 'a * 'a * 'a * 'a * 'a
val tuple_of_list6 : 'a list -> 'a * 'a * 'a * 'a * 'a * 'a
type ('a, 'b) either =
  1. | Left of 'a
  2. | Right of 'b
type ('a, 'b, 'c) either3 =
  1. | Left3 of 'a
  2. | Middle3 of 'b
  3. | Right3 of 'c
val just : 'a option -> 'a
val some : 'a option -> 'a
val fmap : ('a -> 'b) -> 'a option -> 'b option
val map_option : ('a -> 'b) -> 'a option -> 'b option
val do_option : ('a -> unit) -> 'a option -> unit
val opt : ('a -> unit) -> 'a option -> unit
val optionise : (unit -> 'a) -> 'a option
val some_or : 'a option -> 'a -> 'a
val option_to_list : 'a option -> 'a list
val partition_either : ('a -> ('b, 'c) either) -> 'a list -> 'b list * 'c list
val partition_either3 : ('a -> ('b, 'c, 'd) either3) -> 'a list -> 'b list * 'c list * 'd list
val filter_some : 'a option list -> 'a list
val map_filter : ('a -> 'b option) -> 'a list -> 'b list
val find_some : ('a -> 'b option) -> 'a list -> 'b
val find_some_opt : ('a -> 'b option) -> 'a list -> 'b option
val list_to_single_or_exn : 'a list -> 'a
val while_some : gen:(unit -> 'a option) -> f:('a -> 'b) -> unit -> 'b list
val (||=) : 'a option ref -> (unit -> 'a) -> unit
val (>>=) : 'a option -> ('a -> 'b option) -> 'b option
val (|?) : 'a option -> 'a Lazy.t -> 'a
type bool3 =
  1. | True3
  2. | False3
  3. | TrueFalsePb3 of string
val slength : string -> int
val concat : string -> string list -> string
val i_to_s : int -> string
val s_to_i : string -> int
val _shareds : (string, string) Hashtbl.t
val shared_string : string -> string
val chop : string -> string
val chop_dirsymbol : string -> string
val (<!!>) : string -> (int * int) -> string
val (<!>) : string -> int -> char
val take_string : int -> string -> string
val take_string_safe : int -> string -> string
val split_on_char : char -> string -> string list
val quote : string -> string
val unquote : string -> string
val null_string : string -> bool
val is_blank_string : string -> bool
val is_string_prefix : string -> string -> bool
val plural : int -> string -> string
val showCodeHex : int list -> unit
val size_mo_ko : int -> string
val size_ko : int -> string
val edit_distance : string -> string -> int
val md5sum_of_string : string -> string
val wrap : ?width:int -> string -> string
val regexp_alpha : Str.regexp
val regexp_word : Str.regexp
val _memo_compiled_regexp : (string, Str.regexp) Hashtbl.t
val (=~) : string -> string -> bool
val (==~) : string -> Str.regexp -> bool
val regexp_match : string -> string -> string
val matched : int -> string -> string
val matched1 : string -> string
val matched2 : string -> string * string
val matched3 : string -> string * string * string
val matched4 : string -> string * string * string * string
val matched5 : string -> string * string * string * string * string
val matched6 : string -> string * string * string * string * string * string
val matched7 : string -> string * string * string * string * string * string * string
val string_match_substring : Str.regexp -> string -> bool
val split : string -> string -> string list
val join : string -> string list -> string
val split_list_regexp : string -> string list -> (string * string list) list
val split_list_regexp_noheading : string
val all_match : string -> string -> string list
val global_replace_regexp : string -> (string -> string) -> string -> string
val regular_words : string -> string list
val contain_regular_word : string -> bool
type regexp =
  1. | Contain of string
  2. | Start of string
  3. | End of string
  4. | Exact of string
val regexp_string_of_regexp : regexp -> string
val str_regexp_of_regexp : regexp -> Str.regexp
val compile_regexp_union : regexp list -> Str.regexp
val dirname : string -> string
val basename : string -> string
val filesuffix : filename -> string
val fileprefix : filename -> string
val adjust_ext_if_needed : filename -> string -> filename
val db_of_filename : filename -> string * filename
val filename_of_db : (string * filename) -> filename
val dbe_of_filename : filename -> string * string * string
val dbe_of_filename_nodot : filename -> string * string * string
val dbe_of_filename_safe : filename -> (string * string * string, string * string) either
val dbe_of_filename_noext_ok : filename -> string * string * string
val dbe_of_filename_many_ext_opt : filename -> (dirname * string * string) option
val filename_of_dbe : (string * string * string) -> filename
val replace_ext : filename -> string -> string -> filename
val normalize_path : filename -> filename
val relative_to_absolute : filename -> filename
val is_relative : filename -> bool
val is_absolute : filename -> bool
val filename_without_leading_path : string -> filename -> filename
val realpath : filename -> filename
val inits_of_absolute_dir : dirname -> dirname list
val inits_of_relative_dir : dirname -> dirname list
type filepos = {
  1. l : int;
  2. c : int;
}
type langage =
  1. | English
  2. | Francais
  3. | Deutsch
type month =
  1. | Jan
  2. | Feb
  3. | Mar
  4. | Apr
  5. | May
  6. | Jun
  7. | Jul
  8. | Aug
  9. | Sep
  10. | Oct
  11. | Nov
  12. | Dec
type year =
  1. | Year of int
type day =
  1. | Day of int
type date_dmy =
  1. | DMY of day * month * year
type hour =
  1. | Hour of int
type minute =
  1. | Min of int
type second =
  1. | Sec of int
type time_hms =
  1. | HMS of hour * minute * second
type full_date = date_dmy * time_hms
type days =
  1. | Days of int
type time_dmy =
  1. | TimeDMY of day * month * year
type float_time = float
val mk_date_dmy : int -> int -> int -> date_dmy
val check_date_dmy : date_dmy -> unit
val check_time_dmy : time_dmy -> unit
val check_time_hms : time_hms -> unit
val int_to_month : int -> string
val int_of_month : month -> int
val month_of_string : string -> month
val month_of_string_long : string -> month
val string_of_month : month -> string
val string_of_date_dmy : date_dmy -> string
val date_dmy_of_string : string -> date_dmy
val string_of_unix_time : ?langage:langage -> Unix.tm -> string
val short_string_of_unix_time : ?langage:langage -> Unix.tm -> string
val string_of_floattime : ?langage:langage -> float_time -> string
val short_string_of_floattime : ?langage:langage -> float_time -> string
val floattime_of_string : string -> float_time
val dmy_to_unixtime : date_dmy -> float_time * Unix.tm
val unixtime_to_dmy : Unix.tm -> date_dmy
val unixtime_to_floattime : Unix.tm -> float_time
val floattime_to_unixtime : float_time -> Unix.tm
val floattime_to_dmy : float_time -> date_dmy
val sec_to_days : int -> string
val sec_to_hours : int -> string
val today : unit -> float_time
val yesterday : unit -> float_time
val tomorrow : unit -> float_time
val lastweek : unit -> float_time
val lastmonth : unit -> float_time
val week_before : float_time -> float_time
val month_before : float_time -> float_time
val week_after : float_time -> float_time
val days_in_week_of_day : float_time -> float_time list
val first_day_in_week_of_day : float_time -> float_time
val last_day_in_week_of_day : float_time -> float_time
val day_secs : float_time
val rough_days_since_jesus : date_dmy -> days
val rough_days_between_dates : date_dmy -> date_dmy -> days
val string_of_unix_time_lfs : Unix.tm -> string
val is_more_recent : date_dmy -> date_dmy -> bool
val max_dmy : date_dmy -> date_dmy -> date_dmy
val min_dmy : date_dmy -> date_dmy -> date_dmy
val maximum_dmy : date_dmy list -> date_dmy
val minimum_dmy : date_dmy list -> date_dmy
val timestamp : unit -> string
val list_of_string : string -> char list
val lines : string -> string list
val unlines : string list -> string
val words : string -> string list
val unwords : string list -> string
val split_space : string -> string list
val lines_with_nl : string -> string list
val nblines : filename -> int
val nblines_eff : filename -> int
val nblines_with_wc : filename -> int
val unix_diff : filename -> filename -> string list
val unix_diff_strings : string -> string -> string list
val words_of_string_with_newlines : string -> string list
val lines_with_nl_either : string -> (string, unit) either list
val n_space : int -> string
val indent_string : int -> string -> string
val cat : filename -> string list
val cat_orig : filename -> string list
val cat_array : filename -> string array
val cat_excerpts : filename -> int list -> string list
val uncat : string list -> filename -> unit
val interpolate : string -> string list
val echo : string -> string
val usleep : int -> unit
exception CmdError of Unix.process_status * string
val cmd_to_list_and_status : ?verbose:bool -> string -> string list * Unix.process_status
val process_output_to_list : ?verbose:bool -> string -> string list
val cmd_to_list : ?verbose:bool -> string -> string list
val process_output_to_list2 : ?verbose:bool -> string -> string list * Unix.process_status
val command2 : string -> unit
val _batch_mode : bool ref
val command_safe : ?verbose:bool -> filename -> string list -> int
val y_or_no : string -> bool
val command2_y_or_no : string -> bool
val command2_y_or_no_exit_if_no : string -> unit
val do_in_fork : (unit -> unit) -> int
val mkdir : ?mode:Unix.file_perm -> string -> unit
val read_file : filename -> string
val write_file : file:filename -> string -> unit
val nblines_file : filename -> int
val filesize : filename -> int
val filemtime : filename -> float
val lfile_exists : filename -> bool
val is_directory : path -> bool
val is_file : path -> bool
val is_executable : filename -> bool
val unix_lstat_eff : filename -> Unix.stats
val unix_stat_eff : filename -> Unix.stats
val filesize_eff : filename -> int
val filemtime_eff : filename -> float
val lfile_exists_eff : filename -> bool
val is_directory_eff : path -> bool
val is_file_eff : path -> bool
val is_executable_eff : filename -> bool
val capsule_unix : ('a -> unit) -> 'a -> unit
val readdir_to_kind_list : string -> Unix.file_kind -> string list
val readdir_to_dir_list : string -> dirname list
val readdir_to_file_list : string -> filename list
val readdir_to_dir_size_list : string -> (string * int) list
val unixname : unit -> string
val glob : string -> filename list
val files_of_dir_or_files : string -> string list -> filename list
val files_of_dir_or_files_no_vcs : string -> string list -> filename list
val files_of_dir_or_files_no_vcs_post_filter : string -> string list -> filename list
val files_of_dir_or_files_no_vcs_nofilter : string list -> filename list
val dirs_of_dir : dirname -> dirname list
val common_prefix_of_files_or_dirs : path list -> dirname
val sanity_check_files_and_adjust : string -> string list -> filename list
type rwx = [ `R | `W | `X ] list
val file_perm_of : u:rwx -> g:rwx -> o:rwx -> Unix.file_perm
val has_env : string -> bool
val with_open_outfile_append : filename -> (((string -> unit) * out_channel) -> 'a) -> 'a
val with_open_stringbuf : (((string -> unit) * Buffer.t) -> unit) -> string
val with_tmp_file : str:string -> ext:string -> (filename -> 'a) -> 'a
val register_tmp_file_cleanup_hook : (string -> unit) -> unit
val with_tmp_dir : (dirname -> 'a) -> 'a
exception UnixExit of int
val exn_to_real_unixexit : (unit -> 'a) -> 'a
val hd_opt : 'a list -> 'a option
val map_eff_rev : ('a -> 'b) -> 'a list -> 'b list
val acc_map : ('a -> 'b) -> 'a list -> 'b list
val zip : 'a list -> 'b list -> ('a * 'b) list
val zip_safe : 'a list -> 'b list -> ('a * 'b) list
val unzip : ('a * 'b) list -> 'a list * 'b list
val unzip3 : ('a * 'b * 'c) list -> 'a list * 'b list * 'c list
val unzip4 : ('a * 'b * 'c * 'd) list -> 'a list * 'b list * 'c list * 'd list
val take : int -> 'a list -> 'a list
val take_safe : int -> 'a list -> 'a list
val take_until : ('a -> bool) -> 'a list -> 'a list
val take_while : ('a -> bool) -> 'a list -> 'a list
val drop : int -> 'a list -> 'a list
val drop_while : ('a -> bool) -> 'a list -> 'a list
val drop_until : ('a -> bool) -> 'a list -> 'a list
val span : ('a -> bool) -> 'a list -> 'a list * 'a list
val span_tail_call : ('a -> bool) -> 'a list -> 'a list * 'a list
val skip_until : ('a list -> bool) -> 'a list -> 'a list
val skipfirst : 'a -> 'a list -> 'a list
val fpartition : ('a -> 'b option) -> 'a list -> 'b list * 'a list
val groupBy : ('a -> 'a -> bool) -> 'a list -> 'a list list
val exclude_but_keep_attached : ('a -> bool) -> 'a list -> ('a * 'a list) list
val group_by_post : ('a -> bool) -> 'a list -> ('a list * 'a) list * 'a list
val group_by_pre : ('a -> bool) -> 'a list -> 'a list * ('a * 'a list) list
val group_by_mapped_key : ('a -> 'b) -> 'a list -> ('b * 'a list) list
val group_and_count : 'a list -> ('a * int) list
val group_assoc_bykey_eff : ('a * 'b) list -> ('a * 'b list) list
val splitAt : int -> 'a list -> 'a list * 'a list
val split_when : ('a -> bool) -> 'a list -> 'a list * 'a * 'a list
val split_gen_when : ('a list -> 'a list option) -> 'a list -> 'a list list
val pack : int -> 'a list -> 'a list list
val pack_safe : int -> 'a list -> 'a list list
val chunks : int -> 'a list -> 'a list list
val enum : int -> int -> int list
val enum_safe : int -> int -> int list
val repeat : 'a -> int -> 'a list
val generate : int -> 'a -> 'a list
val index_list : 'a list -> ('a * int) list
val index_list_0 : 'a list -> ('a * int) list
val index_list_1 : 'a list -> ('a * int) list
val index_list_and_total : 'a list -> ('a * int * int) list
val iter_index : ('a -> int -> unit) -> 'a list -> unit
val map_index : ('a -> int -> 'b) -> 'a list -> 'b list
val filter_index : (int -> 'a -> bool) -> 'a list -> 'a list
val fold_left_with_index : ('a -> 'b -> int -> 'a) -> 'a -> 'b list -> 'a
val nth : 'a list -> int -> 'a
val rang : 'a -> 'a list -> int
val last_n : int -> 'a list -> 'a list
val snoc : 'a -> 'a list -> 'a list
val cons : 'a -> 'a list -> 'a list
val uncons : 'a list -> 'a * 'a list
val safe_tl : 'a list -> 'a list
val head_middle_tail : 'a list -> 'a * 'a list * 'a
val list_last : 'a list -> 'a
val list_init : 'a list -> 'a list
val removelast : 'a list -> 'a list
val inits : 'a list -> 'a list list
val tails : 'a list -> 'a list list
val (++) : 'a list -> 'a list -> 'a list
val foldl1 : ('a -> 'a -> 'a) -> 'a list -> 'a
val fold_k : ('a -> 'b -> ('a -> 'a) -> 'a) -> ('a -> 'a) -> 'a -> 'b list -> 'a
val fold_right1 : ('a -> 'a -> 'a) -> 'a list -> 'a
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val join_gen : 'a -> 'a list -> 'a list
val do_withenv : (('a -> 'b) -> 'c -> 'd) -> ('e -> 'a -> 'b * 'e) -> 'e -> 'c -> 'd * 'e
val map_withenv : ('a -> 'b -> 'c * 'a) -> 'a -> 'b list -> 'c list * 'a
val map_withkeep : ('a -> 'b) -> 'a list -> ('b * 'a) list
val collect_accu : ('a -> 'b list) -> 'b list -> 'a list -> 'b list
val collect : ('a -> 'b list) -> 'a list -> 'b list
val remove : 'a -> 'a list -> 'a list
val remove_first : 'a -> 'a list -> 'a list
val exclude : ('a -> bool) -> 'a list -> 'a list
val uniq : 'a list -> 'a list
val uniq_eff : 'a list -> 'a list
val big_union_eff : 'a list list -> 'a list
val has_no_duplicate : 'a list -> bool
val is_set_as_list : 'a list -> bool
val get_duplicates : 'a list -> 'a list
val doublon : 'a list -> bool
val reverse : 'a list -> 'a list
val rev : 'a list -> 'a list
val rotate : 'a list -> 'a list
val map_flatten : ('a -> 'b list) -> 'a list -> 'b list
val map2 : ('a -> 'b) -> 'a list -> 'b list
val map3 : ('a -> 'b) -> 'a list -> 'b list
val maximum : 'a list -> 'a
val minimum : 'a list -> 'a
val most_recurring_element : 'a list -> 'a
val count_elements_sorted_highfirst : 'a list -> ('a * int) list
val min_with : ('a -> 'b) -> 'a list -> 'a
val two_mins_with : ('a -> 'b) -> 'a list -> 'a * 'a
val all_assoc : 'a -> ('a * 'b) list -> 'b list
val prepare_want_all_assoc : ('a * 'b) list -> ('a * 'b list) list
val or_list : bool list -> bool
val and_list : bool list -> bool
val sum_float : float list -> float
val sum_int : int list -> int
val avg_list : int list -> float
val return_when : ('a -> 'b option) -> 'a list -> 'b
val grep_with_previous : ('a -> 'a -> bool) -> 'a list -> 'a list
val iter_with_previous : ('a -> 'a -> unit) -> 'a list -> unit
val iter_with_previous_opt : ('a option -> 'a -> unit) -> 'a list -> unit
val iter_with_before_after : ('a list -> 'a -> 'a list -> unit) -> 'a list -> unit
val get_pair : 'a list -> ('a * 'a) list
val permutation : 'a list -> 'a list list
val remove_elem_pos : int -> 'a list -> 'a list
val insert_elem_pos : ('a * int) -> 'a list -> 'a list
val uncons_permut : 'a list -> (('a * int) * 'a list) list
val uncons_permut_lazy : 'a list -> (('a * int) * 'a list Lazy.t) list
val pack_sorted : ('a -> 'a -> bool) -> 'a list -> 'a list list
val keep_best : (('a * 'a) -> 'a option) -> 'a list -> 'a list
val sorted_keep_best : ('a -> 'a -> 'a option) -> 'a list -> 'a list
val cartesian_product : 'a list -> 'b list -> ('a * 'b) list
val surEnsemble : 'a list -> 'a list list -> 'a list list
val realCombinaison : 'a list -> 'a list list
val combinaison : 'a list -> ('a * 'a) list
val insere : 'a -> 'a list list -> 'a list list
val insereListeContenant : 'a list -> 'a -> 'a list list -> 'a list list
val fusionneListeContenant : ('a * 'a) -> 'a list list -> 'a list list
val array_find_index : (int -> bool) -> 'a array -> int
val array_find_index_via_elem : ('a -> bool) -> 'a array -> int
type idx =
  1. | Idx of int
val next_idx : idx -> idx
val int_of_idx : idx -> int
val array_find_index_typed : (idx -> bool) -> 'a array -> idx
type 'a matrix = 'a array array
val map_matrix : ('a -> 'b) -> 'a matrix -> 'b matrix
val make_matrix_init : nrow:int -> ncolumn:int -> (int -> int -> 'a) -> 'a matrix
val iter_matrix : (int -> int -> 'a -> unit) -> 'a matrix -> unit
val nb_rows_matrix : 'a matrix -> int
val nb_columns_matrix : 'a matrix -> int
val rows_of_matrix : 'a matrix -> 'a list list
val columns_of_matrix : 'a matrix -> 'a list list
val all_elems_matrix_by_row : 'a matrix -> 'a list
type 'a set = 'a list
val empty_set : 'a set
val insert_set : 'a -> 'a set -> 'a set
val single_set : 'a -> 'a set
val set : 'a list -> 'a set
val is_set : 'a list -> bool
val exists_set : ('a -> bool) -> 'a set -> bool
val forall_set : ('a -> bool) -> 'a set -> bool
val filter_set : ('a -> bool) -> 'a set -> 'a set
val fold_set : ('a -> 'b -> 'a) -> 'a -> 'b set -> 'a
val map_set : ('a -> 'b) -> 'a set -> 'b set
val member_set : 'a -> 'a set -> bool
val find_set : ('a -> bool) -> 'a list -> 'a
val sort_set : ('a -> 'a -> int) -> 'a list -> 'a list
val iter_set : ('a -> unit) -> 'a list -> unit
val top_set : 'a set -> 'a
val inter_set : 'a set -> 'a set -> 'a set
val union_set : 'a set -> 'a set -> 'a set
val minus_set : 'a set -> 'a set -> 'a set
val union_all : 'a set list -> 'a set
val big_union_set : ('a -> 'b set) -> 'a set -> 'b set
val card_set : 'a set -> int
val include_set : 'a set -> 'a set -> bool
val equal_set : 'a set -> 'a set -> bool
val include_set_strict : 'a set -> 'a set -> bool
val ($*$) : 'a set -> 'a set -> 'a set
val ($+$) : 'a set -> 'a set -> 'a set
val ($-$) : 'a set -> 'a set -> 'a set
val ($?$) : 'a -> 'a set -> bool
val ($<$) : 'a set -> 'a set -> bool
val ($<=$) : 'a set -> 'a set -> bool
val ($=$) : 'a set -> 'a set -> bool
val ($@$) : 'a list -> 'a list -> 'a list
val nub : 'a list -> 'a list
val diff_set_eff : 'a list -> 'a list -> 'a list * 'a list * 'a list
module StringSet : sig ... end
type ('a, 'b) assoc = ('a * 'b) list
val assoc_to_function : ('a, 'b) assoc -> 'a -> 'b
val empty_assoc : ('a, 'b) assoc
val fold_assoc : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val insert_assoc : 'a -> 'a list -> 'a list
val map_assoc : ('a -> 'b) -> 'a list -> 'b list
val filter_assoc : ('a -> bool) -> 'a list -> 'a list
val assoc : 'a -> ('a * 'b) list -> 'b
val keys : ('a * 'b) list -> 'a list
val lookup : 'a -> ('a * 'b) list -> 'b
val del_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val replace_assoc : ('a * 'b) -> ('a * 'b) list -> ('a * 'b) list
val apply_assoc : 'a -> ('b -> 'b) -> ('a * 'b) list -> ('a * 'b) list
val big_union_assoc : ('a -> 'b set) -> 'a list -> 'b set
val assoc_reverse : ('a * 'b) list -> ('b * 'a) list
val assoc_map : ('a * 'b) list -> ('a * 'b) list -> ('a * 'a) list
val lookup_list : 'a -> ('a, 'b) assoc list -> 'b
val lookup_list2 : 'a -> ('a, 'b) assoc list -> 'b * int
val assoc_opt : 'a -> ('a, 'b) assoc -> 'b option
val assoc_with_err_msg : 'a -> ('a, 'b) assoc -> 'b
type order =
  1. | HighFirst
  2. | LowFirst
val compare_order : order -> 'a -> 'a -> int
val sort_by_val_lowfirst : ('a, 'b) assoc -> ('a * 'b) list
val sort_by_val_highfirst : ('a, 'b) assoc -> ('a * 'b) list
val sort_by_key_lowfirst : ('a, 'b) assoc -> ('a * 'b) list
val sort_by_key_highfirst : ('a, 'b) assoc -> ('a * 'b) list
val sortgen_by_key_lowfirst : ('a, 'b) assoc -> ('a * 'b) list
val sortgen_by_key_highfirst : ('a, 'b) assoc -> ('a * 'b) list
module IntMap : sig ... end
val intmap_to_list : 'a IntMap.t -> (IntMap.key * 'a) list
val intmap_string_of_t : 'a -> 'b -> string
module IntIntMap : sig ... end
val intintmap_to_list : 'a IntIntMap.t -> (IntIntMap.key * 'a) list
val intintmap_string_of_t : 'a -> 'b -> string
val hcreate : unit -> ('a, 'b) Hashtbl.t
val hadd : ('a * 'b) -> ('a, 'b) Hashtbl.t -> unit
val hmem : 'a -> ('a, 'b) Hashtbl.t -> bool
val hfind : 'a -> ('a, 'b) Hashtbl.t -> 'b
val hreplace : ('a * 'b) -> ('a, 'b) Hashtbl.t -> unit
val hiter : ('a -> 'b -> unit) -> ('a, 'b) Hashtbl.t -> unit
val hfold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) Hashtbl.t -> 'c -> 'c
val hremove : 'a -> ('a, 'b) Hashtbl.t -> unit
val hfind_default : 'a -> (unit -> 'b) -> ('a, 'b) Hashtbl.t -> 'b
val hfind_option : 'a -> ('a, 'b) Hashtbl.t -> 'b option
val hupdate_default : 'a -> update:('b -> 'b) -> default:(unit -> 'b) -> ('a, 'b) Hashtbl.t -> unit
val add1 : int -> int
val cst_zero : unit -> int
val hash_to_list : ('a, 'b) Hashtbl.t -> ('a * 'b) list
val hash_to_list_unsorted : ('a, 'b) Hashtbl.t -> ('a * 'b) list
val hash_of_list : ('a * 'b) list -> ('a, 'b) Hashtbl.t
val hkeys : ('a, 'b) Hashtbl.t -> 'a list
val hunion : ('a, 'b) Hashtbl.t -> ('a, 'b) Hashtbl.t -> unit
type 'a hashset = ('a, bool) Hashtbl.t
val hash_hashset_add : 'a -> 'b -> ('a, 'b hashset) Hashtbl.t -> unit
val hashset_union : 'a hashset -> 'a hashset -> unit
val hashset_inter : 'a hashset -> 'a hashset -> unit
val hashset_to_set : < fromlist : 'a list -> 'c.. > -> ('a, 'b) Hashtbl.t -> 'c
val hashset_to_list : 'a hashset -> 'a list
val hashset_of_list : 'a list -> 'a hashset
type ('a, 'b) hash_with_default = < add : 'a -> 'b -> unit ; to_list : ('a * 'b) list ; to_h : ('a, 'b) Hashtbl.t ; update : 'a -> ('b -> 'b) -> unit ; assoc : 'a -> 'b >
val hash_with_default : (unit -> 'b) -> < add : 'a -> 'b -> unit ; to_list : ('a * 'b) list ; to_h : ('a, 'b) Hashtbl.t ; update : 'a -> ('b -> 'b) -> unit ; assoc : 'a -> 'b >
type 'a stack = 'a list
val empty_stack : 'a stack
val top : 'a stack -> 'a
val pop : 'a stack -> 'a stack
val top_option : 'a stack -> 'a option
val push : 'a -> 'a stack ref -> unit
val pop2 : 'a stack ref -> 'a
type 'a undo_stack = 'a list * 'a list
val empty_undo_stack : 'a undo_stack
val push_undo : 'a -> 'a undo_stack -> 'a undo_stack
val top_undo : 'a undo_stack -> 'a
val pop_undo : 'a undo_stack -> 'a undo_stack
val redo_undo : 'a undo_stack -> 'a undo_stack
val undo_pop : 'a undo_stack -> 'a undo_stack
val top_undo_option : 'a undo_stack -> 'a option
type 'a tree2 =
  1. | Tree of 'a * 'a tree2 list
val tree2_iter : ('a -> unit) -> 'a tree2 -> unit
type ('a, 'b) tree =
  1. | Node of 'a * ('a, 'b) tree list
  2. | Leaf of 'b
val map_tree : fnode:('a -> 'abis) -> fleaf:('b -> 'bbis) -> ('a, 'b) tree -> ('abis, 'bbis) tree
val dirs_and_base_of_file : path -> string list * string
val tree_of_files : filename list -> (dirname, string * filename) tree
type 'a treeref =
  1. | NodeRef of 'a * 'a treeref list ref
val treeref_node_iter : (('a * 'a treeref list ref) -> unit) -> 'a treeref -> unit
val treeref_node_iter_with_parents : (('a * 'a treeref list ref) -> 'a list -> unit) -> 'a treeref -> unit
val find_treeref : (('a * 'a treeref list ref) -> bool) -> 'a treeref -> 'a treeref
val treeref_children_ref : 'a treeref -> 'a treeref list ref
val find_treeref_with_parents_some : (('a * 'a treeref list ref) -> 'a list -> 'c option) -> 'a treeref -> 'c
val find_multi_treeref_with_parents_some : (('a * 'a treeref list ref) -> 'a list -> 'c option) -> 'a treeref -> 'c list
type ('a, 'b) treeref2 =
  1. | NodeRef2 of 'a * ('a, 'b) treeref2 list ref
  2. | LeafRef2 of 'b
val find_treeref2 : (('a * ('a, 'b) treeref2 list ref) -> bool) -> ('a, 'b) treeref2 -> ('a, 'b) treeref2
val treeref_node_iter_with_parents2 : (('a * ('a, 'b) treeref2 list ref) -> 'a list -> unit) -> ('a, 'b) treeref2 -> unit
val treeref_node_iter2 : (('a * ('a, 'b) treeref2 list ref) -> unit) -> ('a, 'b) treeref2 -> unit
type 'a graph = 'a set * ('a * 'a) set
val add_node : 'a -> 'a graph -> 'a graph
val del_node : 'a -> 'a graph -> 'a graph
val add_arc : ('a * 'a) -> 'a graph -> 'a graph
val del_arc : ('a * 'a) -> 'a graph -> 'a graph
val successors : 'a -> 'a graph -> 'a set
val predecessors : 'a -> 'a graph -> 'a set
val nodes : 'a graph -> 'a set
val fold_upward : ('a -> 'b -> 'a) -> 'b set -> 'a -> 'b graph -> 'a
val empty_graph : 'a list * 'b list
val map : ('a -> 'b) -> 'a list -> 'b list
val filter : ('a -> bool) -> 'a list -> 'a list
val fold : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val member : 'a -> 'a list -> bool
val iter : ('a -> unit) -> 'a list -> unit
val find : ('a -> bool) -> 'a list -> 'a
val exists : ('a -> bool) -> 'a list -> bool
val forall : ('a -> bool) -> 'a list -> bool
val big_union : ('a -> 'b set) -> 'a list -> 'b set
val empty_list : 'a list
val sort : 'a list -> 'a list
val length : 'a list -> int
val null : 'a list -> bool
val head : 'a list -> 'a
val tail : 'a list -> 'a list
val is_singleton : 'a list -> bool
type vector = float * float * float
type point = vector
type color = vector
val dotproduct : (vector * vector) -> float
val vector_length : vector -> float
val minus_point : (point * point) -> vector
val distance : (point * point) -> float
val normalise : vector -> vector
val mult_coeff : vector -> float -> vector
val add_vector : vector -> vector -> vector
val mult_vector : vector -> vector -> vector
val sum_vector : vector list -> vector
type pixel = int * int * int
val write_ppm : int -> int -> pixel list -> filename -> unit
val test_ppm1 : unit -> unit
type diff =
  1. | Match
  2. | BnotinA
  3. | AnotinB
val diff : (int -> int -> diff -> unit) -> (string list * string list) -> unit
val diff2 : (int -> int -> diff -> unit) -> (string * string) -> unit
val contain_any_token_with_egrep : string list -> filename -> bool
val parserCommon : Lexing.lexbuf -> ('a -> Lexing.lexbuf -> 'b) -> 'a -> 'b
val getDoubleParser : ('a -> Lexing.lexbuf -> 'b) -> 'a -> (string -> 'b) * (string -> 'b)
type ('a, 'b) scoped_env = ('a, 'b) assoc list
val lookup_env : 'a -> ('a, 'b) scoped_env -> 'b
val member_env_key : 'a -> ('a, 'b) scoped_env -> bool
val new_scope : ('a, 'b) scoped_env ref -> unit
val del_scope : ('a, 'b) scoped_env ref -> unit
val do_in_new_scope : ('a, 'b) scoped_env ref -> (unit -> unit) -> unit
val add_in_scope : ('a, 'b) scoped_env ref -> ('a * 'b) -> unit
type ('a, 'b) scoped_h_env = {
  1. scoped_h : ('a, 'b) Hashtbl.t;
  2. scoped_list : ('a, 'b) assoc list;
}
val empty_scoped_h_env : unit -> ('a, 'b) scoped_h_env
val clone_scoped_h_env : ('a, 'b) scoped_h_env -> ('a, 'b) scoped_h_env
val lookup_h_env : 'a -> ('a, 'b) scoped_h_env -> 'b
val member_h_env_key : 'a -> ('a, 'b) scoped_h_env -> bool
val new_scope_h : ('a, 'b) scoped_h_env ref -> unit
val del_scope_h : ('a, 'b) scoped_h_env ref -> unit
val do_in_new_scope_h : ('a, 'b) scoped_h_env ref -> (unit -> unit) -> unit
val add_in_scope_h : ('a, 'b) scoped_h_env ref -> ('a * 'b) -> unit
type 'a cached = 'a serialized_maybe ref
and 'a serialized_maybe =
  1. | Serial of string
  2. | Unfold of 'a
val serial : 'a -> 'a cached
val unserial : 'a cached -> 'a
val cmdline_flags_devel : unit -> Arg_helpers.cmdline_options
val cmdline_flags_verbose : unit -> Arg_helpers.cmdline_options
val cmdline_flags_other : unit -> Arg_helpers.cmdline_options
val cmdline_actions : unit -> Arg_helpers.cmdline_actions
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