val try_finally : ?always:( unit -> unit ) -> ?exceptionally:( unit -> unit ) -> ( unit -> 'a ) -> 'a
try_finally work ~always ~exceptionally is designed to run code in
work that may fail with an exception, and has two kind of cleanup routines:
always, that must be run after any execution of the function (typically, freeing system resources), and
exceptionally, that should be run only if
always failed with an exception (typically, undoing user-visible state changes that would only make sense if the function completes correctly). For example:
let objfile = outputprefix ^ ".cmo" in let oc = open_out_bin objfile in Misc.try_finally (fun () -> bytecode ++ Timings.(accumulate_time (Generate sourcefile)) (Emitcode.to_file oc modulename objfile); Warnings.check_fatal ()) ~always:(fun () -> close_out oc) ~exceptionally:(fun _exn -> remove_file objfile);
exceptionally fail with an exception, it is propagated as usual.
exceptionally use exceptions internally for control-flow but do not raise, then
try_finally is careful to preserve any exception backtrace coming from
always for easier debugging.
reraise_preserving_backtrace e f is (f (); raise e) except that the current backtrace is preserved, even if
f uses exceptions internally.
val protect_refs : ref_and_value list -> ( unit -> 'a ) -> 'a
protect_refs l f temporarily sets
v for each
R (r, v) in
l while executing
f. The previous contents of the references is restored even if
f raises an exception, without altering the exception backtrace.
module Stdlib : sig ... end
val create_hashtable : int -> ('a * 'b) list -> ( 'a, 'b ) Hashtbl.t
val string_of_file : in_channel -> string
val protect_writing_to_file : filename:string -> f:( out_channel -> 'a ) -> 'a
Open the given
filename for writing (in binary mode), pass the
out_channel to the given function, then close the channel. If the function raises an exception then
filename will be removed.
module Int_literal_converter : sig ... end
val get_ref : 'a list ref -> 'a list
val set_or_ignore : ( 'a -> 'b option ) -> 'b option ref -> 'a -> unit
module LongString : sig ... end
edit_distance a b cutoff computes the edit distance between strings
b. To help efficiency, it uses a cutoff: if the distance
d is smaller than
cutoff, it returns
Some d, else
The distance algorithm currently used is Damerau-Levenshtein: it computes the number of insertion, deletion, substitution of letters, or swapping of adjacent letters to go from one word to the other. The particular algorithm may change in the future.
spellcheck env name takes a list of names
env that exist in the current environment and an erroneous
name, and returns a list of suggestions taken from
env, that are close enough to
name that it may be a typo for one of them.
val did_you_mean : Format.formatter -> ( unit -> string list ) -> unit
did_you_mean ppf get_choices hints that the user may have meant one of the option returned by calling
get_choices. It does nothing if the returned list is empty.
unit -> ... thunking is meant to delay any potentially-slow computation (typically computing edit-distance with many things from the current environment) to when the hint message is to be printed. You should print an understandable error message before calling
did_you_mean, so that users get a clear notification of the failure even if producing the hint is slow.
String.cut_at s c returns a pair containing the sub-string before the first occurrence of
s, and the sub-string after the first occurrence of
let (before, after) = String.cut_at s c in
before ^ String.make 1 c ^ after is the identity if
Not_found if the character does not appear in the string
module Color : sig ... end
module Error_style : sig ... end
normalise_eol s returns a fresh copy of
s with any '\r' characters removed. Intended for pre-processing text which will subsequently be printed on a channel which performs EOL transformations (i.e. Windows)
delete_eol_spaces s returns a fresh copy of
s with any end of line spaces removed. Intended to normalize the output of the toplevel for tests.
val pp_two_columns : ?sep:string -> ?max_lines:int -> Format.formatter -> (string * string) list -> unit
pp_two_columns ?sep ?max_lines ppf l prints the lines in
l as two columns separated by
sep ("|" by default).
max_lines can be used to indicate a maximum number of lines to print -- an ellipsis gets inserted at the middle if the input has too many lines.
pp_two_columns ~max_lines:3 Format.std_formatter [ "abc", "hello"; "def", "zzz"; "a" , "bllbl"; "bb" , "dddddd"; ]
abc | hello ... bb | dddddd
val get_build_path_prefix_map : unit -> Build_path_prefix_map.map option
Returns the map encoded in the
BUILD_PATH_PREFIX_MAP environment variable.
Returns the list of
--debug-prefix-map flags to be passed to the assembler, built from the
BUILD_PATH_PREFIX_MAP environment variable.
print_if ppf flag fmt x prints
b is true.
type alerts = string Stdlib.String.Map.t
module EnvLazy : sig ... end
module Magic_number : sig ... end
a typical magic number is "Caml1999I011"; it is formed of an alphanumeric prefix, here Caml1990I, followed by a version, here 011. The prefix identifies the kind of the versioned data: here the I indicates that it is the magic number for .cmi files.