heptagon/compiler/utilities/misc.mli

113 lines
4.3 KiB
OCaml
Raw Normal View History

2010-06-15 10:49:03 +02:00
(**************************************************************************)
(* *)
(* Heptagon *)
(* *)
(* Author : Marc Pouzet *)
(* Organization : Demons, LRI, University of Paris-Sud, Orsay *)
(* *)
(**************************************************************************)
(* Misc. functions *)
val optional : ('a -> 'b) -> 'a option -> 'b option
2010-07-08 17:41:00 +02:00
(** Optional with accumulator *)
val optional_wacc : ('a -> 'b -> 'c*'a) -> 'a -> 'b option -> ('c option * 'a)
2010-06-15 10:49:03 +02:00
val optunit : ('a -> unit) -> 'a option -> unit
2011-04-29 14:13:54 +02:00
(** [split_string s c] splits the string [s] according to the separator
[c] into a list of string without [c] *)
val split_string : string -> string -> string list
2010-06-15 10:49:03 +02:00
(* Generation of unique names. Mandatory call of reset_symbol between
set_min_symbol and gen_symbol *)
(*val set_min_symbol : int -> unit*)
val gen_symbol : unit -> string
val reset_symbol : unit -> unit
(** [unique l] returns the [l] list without duplicates. O([length l]). *)
val unique : 'a list -> 'a list
2010-12-14 18:31:09 +01:00
(** [map_butlast f l] applies f to all the elements of
l except the last element. *)
val map_butlast : ('a -> 'a) -> 'a list -> 'a list
2010-06-15 10:49:03 +02:00
(** [map_butnlast f l] applies f to all the elements of
l except the n last element. *)
val map_butnlast : int -> ('a -> 'a) -> 'a list -> 'a list
2010-06-15 10:49:03 +02:00
(** [last_element l] returns the last element of the list l.*)
val last_element : 'a list -> 'a
2010-06-15 10:49:03 +02:00
(** [split_last l] returns the list l without its last element
2010-06-15 10:49:03 +02:00
and the last element of the list .*)
val split_last : 'a list -> ('a list * 'a)
2010-06-15 10:49:03 +02:00
(** [split_nlast l] returns the list l without its n last elements
and the last element of the list .*)
val split_nlast : int -> 'a list -> ('a list * 'a list)
exception List_too_short
(** [split_at n l] splits [l] in two after the [n]th value.
Raises List_too_short exception if the list is too short. *)
val split_at : int -> 'a list -> 'a list * 'a list
2010-06-15 10:49:03 +02:00
(** [remove x l] removes all occurrences of x from list l.*)
val remove : 'a -> 'a list -> 'a list
(** [is_empty l] returns whether the list l is empty.*)
val is_empty : 'a list -> bool
(** [repeat_list v n] returns a list with n times the value v. *)
val repeat_list : 'a -> int -> 'a list
(** Same as List.mem_assoc but using the value instead of the key. *)
val memd_assoc : 'b -> ('a * 'b) list -> bool
(** Same as List.assoc but searching for a data and returning the key. *)
val assocd : 'b -> ('a * 'b) list -> 'a
(** [list_compare c l1 l2] compares the lists [l1] and [l2] according to
lexicographical order induced by [c]. *)
val list_compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int
val option_compare : ('a -> 'a -> int) -> 'a option -> 'a option -> int
(** Mapfold *)
2011-04-29 14:13:54 +02:00
val mapfold: ('acc -> 'b -> 'c * 'acc) -> 'acc -> 'b list -> 'c list * 'acc
2010-07-19 17:19:02 +02:00
(** Mapfold, right version. *)
val mapfold_right
: ('a -> 'acc -> 'acc * 'b) -> 'a list -> 'acc -> 'acc * 'b list
(** Mapi *)
val mapi: (int -> 'a -> 'b) -> 'a list -> 'b list
val mapi2: (int -> 'a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val mapi3: (int -> 'a -> 'b -> 'c -> 'd) ->
'a list -> 'b list -> 'c list -> 'd list
val fold_righti : (int -> 'a -> 'b -> 'b) -> 'a list -> 'b -> 'b
(** Functions to decompose a list into a tuple *)
val assert_empty : 'a list -> unit
val assert_1 : 'a list -> 'a
val assert_1min : 'a list -> 'a * 'a list
val assert_2 : 'a list -> 'a * 'a
val assert_2min : 'a list -> 'a * 'a * 'a list
val assert_3 : 'a list -> 'a * 'a * 'a
(** Print to string *)
val print_pp_to_string : (Format.formatter -> 'a -> unit) -> 'a -> string
(** Replace all non [a-z A-Z 0-9] character of a string by [_] *)
val sanitize_string : string -> string
(** Pipe a value to a function *)
val (|>) : 'a -> ('a -> 'b) -> 'b
(** Return the extension of a filename string *)
val file_extension : string -> string
2011-01-24 16:07:26 +01:00
(** Internal error : Is used when an assertion wrong *)
2011-05-23 09:24:57 +02:00
val internal_error : string -> 'a
2011-01-24 16:07:26 +01:00
(** Unsupported : Is used when something should work but is not currently supported *)
2011-05-23 09:24:57 +02:00
val unsupported : string -> 'a