Module Misc

module Misc: sig .. end

edit_distance a b cutoff computes the edit distance between strings a and b. To help efficiency, it uses a cutoff: if the distance d is smaller than cutoff, it returns Some d, else None.

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.

val fatal_error : string -> 'a

exception Fatal_error

val try_finally : (unit -> 'a) -> (unit -> unit) -> 'a

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

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

val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool

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

val list_remove : 'a -> 'a list -> 'a list

val split_last : 'a list -> 'a list * 'a

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

val may : ('a -> unit) -> 'a option -> unit

val may_map : ('a -> 'b) -> 'a option -> 'b option

val find_in_path : string list -> string -> string

val find_in_path_uncap : string list -> string -> string

val remove_file : string -> unit

val expand_directory : string -> string -> string

val create_hashtable : int -> ('a * 'b) list -> ('a, 'b) Hashtbl.t

val copy_file : in_channel -> out_channel -> unit

val copy_file_chunk : in_channel -> out_channel -> int -> unit

val string_of_file : in_channel -> string

val log2 : int -> int

val align : int -> int -> int

val no_overflow_add : int -> int -> bool

val no_overflow_sub : int -> int -> bool

val no_overflow_lsl : int -> bool

val chop_extension_if_any : string -> string

val chop_extensions : string -> string

val search_substring : string -> string -> int -> int

val rev_split_words : string -> string list

val get_ref : 'a list ref -> 'a list

val fst3 : 'a * 'b * 'c -> 'a

val snd3 : 'a * 'b * 'c -> 'b

val thd3 : 'a * 'b * 'c -> 'c

val fst4 : 'a * 'b * 'c * 'd -> 'a

val snd4 : 'a * 'b * 'c * 'd -> 'b

val thd4 : 'a * 'b * 'c * 'd -> 'c

val for4 : 'a * 'b * 'c * 'd -> 'd

module LongString: sig .. end

val edit_distance : string -> string -> int -> int option

val split : string -> char -> string list

String.split string char splits the string string at every char char, and returns the list of sub-strings between the chars. String.concat (String.make 1 c) (String.split s c) is the identity.
Since 4.01

val cut_at : string -> char -> string * string

String.cut_at s c returns a pair containing the sub-string before the first occurrence of c in s, and the sub-string after the first occurrence of c in s.

let (before, after) = String.cut_at s c in
    before ^ String.make 1 c ^ after

is the identity if s contains c.

Raise Not_found if the character does not appear in the string
Since 4.01