package pfff

  1. Overview
  2. Docs
Tools and APIs for program analysis, code visualization, refactoring

Install 

dune-project
 Dependency

github.com Edit opam file Versions (8)

Authors

  1. Y
    Yoann Padioleau <yoann.padioleau@gmail.com>

Maintainers

  1. Y
    yoann.padioleau@gmail.com

Sources

0.37.1.tar.gz
sha256=d5be49a8ee9d26bff98b902533e0bde59cf1613a6e8f15651492205434f35c0e
md5=637a4f055de86bf02ad372b45e5567a9

doc/lib/Common2/index.html

Module Common2

val verbose_level : int Stdlib.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 Stdlib.ref
val indent_do : (unit -> 'a) -> 'a
val reset_pr_indent : unit -> unit
val _prefix_pr : string Stdlib.ref
val pr : string -> unit
val pr_no_nl : string -> unit
val pr_xxxxxxxxxxxxxxxxx : unit -> unit
val _chan_pr2 : Stdlib.out_channel option Stdlib.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 Stdlib.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) Stdlib.format -> 'a
val _chan : Stdlib.out_channel Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref
val _count2 : int Stdlib.ref
val _count3 : int Stdlib.ref
val _count4 : int Stdlib.ref
val _count5 : int Stdlib.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 Stdlib.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) Stdlib.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 -> Stdlib.Marshal.extern_flags list -> string
val marshal__from_string : string -> int -> 'a
val _counter : int Stdlib.ref
val _counter2 : int Stdlib.ref
val _counter3 : int Stdlib.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 -> 'b) -> 'a option -> unit
val print_list : ('a -> 'b) -> '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 -> ('a -> 'b) -> 'b
val (|>) : 'a -> ('a -> 'b) -> 'b
val (+!>) : 'a Stdlib.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) Stdlib.ref -> ('a -> ('a -> 'b) -> 'b) -> unit
val add_hook_action : ('a -> unit) -> ('a -> unit) list Stdlib.ref -> unit
val run_hooks_action : 'a -> ('a -> unit) list Stdlib.ref -> unit
type 'a mylazy = unit -> 'a
val save_excursion : 'a Stdlib.ref -> 'a -> (unit -> 'b) -> 'b
val save_excursion_and_disable : bool Stdlib.ref -> (unit -> 'b) -> 'b
val save_excursion_and_enable : bool Stdlib.ref -> (unit -> 'b) -> 'b
val memoized : ?use_cache:bool -> ('a, 'b) Stdlib.Hashtbl.t -> 'a -> (unit -> 'b) -> 'b
val cache_in_ref : 'a option Stdlib.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 Stdlib.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 Stdlib.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 Stdlib.ref -> int -> unit
val (-=) : int Stdlib.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 Stdlib.ref * 'a Stdlib.ref
val update_max_with_elem : 'a max_with_elem -> is_better:(int -> int Stdlib.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 Stdlib.ref -> (unit -> 'a) -> unit
val (>>=) : 'a option -> ('a -> 'b option) -> 'b option
val (|?) : 'a option -> 'a Stdlib.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) Stdlib.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) Stdlib.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 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 command2 : string -> unit
val _batch_mode : bool Stdlib.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) * Stdlib.out_channel) -> 'a) -> 'a
val with_open_stringbuf : (((string -> unit) * Stdlib.Buffer.t) -> unit) -> string
exception Timeout
val timeout_function : ?verbose:bool -> int -> (unit -> 'a) -> 'a
val timeout_function_opt : int option -> (unit -> 'a) -> 'a
val with_tmp_file : str:string -> ext:string -> (filename -> 'a) -> 'a
val with_tmp_dir : (dirname -> 'a) -> 'a
exception UnixExit of int
val exn_to_real_unixexit : (unit -> 'a) -> 'a
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 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 -> 'b) -> '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 -> 'b) -> 'a list -> unit
val iter_with_previous_opt : ('a option -> 'a -> 'b) -> '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 Stdlib.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) Stdlib.Hashtbl.t
val hadd : ('a * 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> unit
val hmem : 'a -> ('a, 'b) Stdlib.Hashtbl.t -> bool
val hfind : 'a -> ('a, 'b) Stdlib.Hashtbl.t -> 'b
val hreplace : ('a * 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> unit
val hiter : ('a -> 'b -> unit) -> ('a, 'b) Stdlib.Hashtbl.t -> unit
val hfold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c -> 'c
val hremove : 'a -> ('a, 'b) Stdlib.Hashtbl.t -> unit
val hfind_default : 'a -> (unit -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> 'b
val hfind_option : 'a -> ('a, 'b) Stdlib.Hashtbl.t -> 'b option
val hupdate_default : 'a -> update:('b -> 'b) -> default:(unit -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> unit
val add1 : int -> int
val cst_zero : unit -> int
val hash_to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
val hash_to_list_unsorted : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
val hash_of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
val hkeys : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
val hunion : ('a, 'b) Stdlib.Hashtbl.t -> ('a, 'b) Stdlib.Hashtbl.t -> unit
type 'a hashset = ('a, bool) Stdlib.Hashtbl.t
val hash_hashset_add : 'a -> 'b -> ('a, 'b hashset) Stdlib.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) Stdlib.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) Stdlib.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) Stdlib.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 Stdlib.ref -> unit
val pop2 : 'a stack Stdlib.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 Stdlib.ref
val treeref_node_iter : (('a * 'a treeref list Stdlib.ref) -> unit) -> 'a treeref -> unit
val treeref_node_iter_with_parents : (('a * 'a treeref list Stdlib.ref) -> 'a list -> unit) -> 'a treeref -> unit
val find_treeref : (('a * 'a treeref list Stdlib.ref) -> bool) -> 'a treeref -> 'a treeref
val treeref_children_ref : 'a treeref -> 'a treeref list Stdlib.ref
val find_treeref_with_parents_some : (('a * 'a treeref list Stdlib.ref) -> 'a list -> 'c option) -> 'a treeref -> 'c
val find_multi_treeref_with_parents_some : (('a * 'a treeref list Stdlib.ref) -> 'a list -> 'c option) -> 'a treeref -> 'c list
type ('a, 'b) treeref2 =
  1. | NodeRef2 of 'a * ('a, 'b) treeref2 list Stdlib.ref
  2. | LeafRef2 of 'b
val find_treeref2 : (('a * ('a, 'b) treeref2 list Stdlib.ref) -> bool) -> ('a, 'b) treeref2 -> ('a, 'b) treeref2
val treeref_node_iter_with_parents2 : (('a * ('a, 'b) treeref2 list Stdlib.ref) -> 'a list -> unit) -> ('a, 'b) treeref2 -> unit
val treeref_node_iter2 : (('a * ('a, 'b) treeref2 list Stdlib.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 : Stdlib.Lexing.lexbuf -> ('a -> Stdlib.Lexing.lexbuf -> 'b) -> 'a -> 'b
val getDoubleParser : ('a -> Stdlib.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 Stdlib.ref -> unit
val del_scope : ('a, 'b) scoped_env Stdlib.ref -> unit
val do_in_new_scope : ('a, 'b) scoped_env Stdlib.ref -> (unit -> unit) -> unit
val add_in_scope : ('a, 'b) scoped_env Stdlib.ref -> ('a * 'b) -> unit
type ('a, 'b) scoped_h_env = {
  1. scoped_h : ('a, 'b) Stdlib.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 Stdlib.ref -> unit
val del_scope_h : ('a, 'b) scoped_h_env Stdlib.ref -> unit
val do_in_new_scope_h : ('a, 'b) scoped_h_env Stdlib.ref -> (unit -> unit) -> unit
val add_in_scope_h : ('a, 'b) scoped_h_env Stdlib.ref -> ('a * 'b) -> unit
type 'a cached = 'a serialized_maybe Stdlib.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 -> Common.cmdline_options
val cmdline_flags_verbose : unit -> Common.cmdline_options
val cmdline_flags_other : unit -> Common.cmdline_options
val cmdline_actions : unit -> Common.cmdline_actions