https://github.com/EasyCrypt/easycrypt
Tip revision: a79f9aeb6de046ca12210d26317fab59c175d0dd authored by Pierre-Yves Strub on 08 July 2014, 09:43:21 UTC
Fix bug w.r.t. _tools presence detection.
Fix bug w.r.t. _tools presence detection.
Tip revision: a79f9ae
ecUtils.mli
(* Copyright (c) - 2012-2014 - IMDEA Software Institute and INRIA
* Distributed under the terms of the CeCILL-B license *)
(* -------------------------------------------------------------------- *)
exception Unexpected
val unexpected : unit -> 'a
(* -------------------------------------------------------------------- *)
val tryexn : (exn -> bool) -> (unit -> 'a) -> 'a option
val try_nf : (unit -> 'a) -> 'a option
val try_finally : (unit -> 'a) -> (unit -> unit) -> 'a
(* -------------------------------------------------------------------- *)
val identity : 'a -> 'a
val (^~) : ('a -> 'b -> 'c) -> ('b -> 'a -> 'c)
val (-|) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val (|-) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b
val (|>) : 'a -> ('a -> 'b) -> 'b
val (<|) : ('a -> 'b) -> 'a -> 'b
val curry : ('a1 -> 'a2 -> 'b) -> 'a1 * 'a2 -> 'b
val uncurry : ('a1 * 'a2 -> 'b) -> 'a1 -> 'a2 -> 'b
val curry3 : ('a1 -> 'a2 -> 'a3 -> 'b) -> 'a1 * 'a2 * 'a3 -> 'b
val uncurry3 : ('a1 * 'a2 * 'a3 -> 'b) -> 'a1 -> 'a2 -> 'a3 -> 'b
(* -------------------------------------------------------------------- *)
val clamp : min:int -> max:int -> int -> int
(* -------------------------------------------------------------------- *)
val copy : 'a -> 'a
(* -------------------------------------------------------------------- *)
val reffold : ('a -> 'b * 'a) -> 'a ref -> 'b
val postincr : int ref -> int
(* -------------------------------------------------------------------- *)
type 'a tuple0 = unit
type 'a tuple1 = 'a
type 'a tuple2 = 'a * 'a
type 'a tuple3 = 'a * 'a * 'a
type 'a tuple4 = 'a * 'a * 'a * 'a
type 'a tuple5 = 'a * 'a * 'a * 'a * 'a
type 'a tuple6 = 'a * 'a * 'a * 'a * 'a * 'a
type 'a tuple7 = 'a * 'a * 'a * 'a * 'a * 'a * 'a
type 'a tuple8 = 'a * 'a * 'a * 'a * 'a * 'a * 'a * 'a
type 'a tuple9 = 'a * 'a * 'a * 'a * 'a * 'a * 'a * 'a * 'a
type 'a pair = 'a tuple2
(* -------------------------------------------------------------------- *)
val as_seq0 : 'a list -> 'a tuple0
val as_seq1 : 'a list -> 'a tuple1
val as_seq2 : 'a list -> 'a tuple2
val as_seq3 : 'a list -> 'a tuple3
val as_seq4 : 'a list -> 'a tuple4
val as_seq5 : 'a list -> 'a tuple5
val as_seq6 : 'a list -> 'a tuple6
val as_seq7 : 'a list -> 'a tuple7
(* -------------------------------------------------------------------- *)
val int_of_bool : bool -> int
(* -------------------------------------------------------------------- *)
val proj3_1 : 'a * 'b * 'c -> 'a
val proj3_2 : 'a * 'b * 'c -> 'b
val proj3_3 : 'a * 'b * 'c -> 'c
val proj4_1 : 'a * 'b * 'c * 'd -> 'a
val proj4_2 : 'a * 'b * 'c * 'd -> 'b
val proj4_3 : 'a * 'b * 'c * 'd -> 'c
val proj4_4 : 'a * 'b * 'c * 'd -> 'd
val fst_map : ('a -> 'c) -> 'a * 'b -> 'c * 'b
val snd_map : ('b -> 'c) -> 'a * 'b -> 'a * 'c
val swap: 'a * 'b -> 'b * 'a
(* -------------------------------------------------------------------- *)
type 'a eq = 'a -> 'a -> bool
type 'a cmp = 'a -> 'a -> int
val pair_equal : 'a eq -> 'b eq -> ('a * 'b) eq
val opt_equal : 'a eq -> 'a option eq
(* -------------------------------------------------------------------- *)
val compare_tag : 'a cmp
val compare2: int lazy_t -> int lazy_t -> int
val compare3: int lazy_t -> int lazy_t -> int lazy_t -> int
(* -------------------------------------------------------------------- *)
val none : 'a option
val some : 'a -> 'a option
val is_none : 'a option -> bool
val is_some : 'a option -> bool
val funnone : 'a -> 'b option
(* -------------------------------------------------------------------- *)
val oiter : ('a -> unit) -> 'a option -> unit
val obind : ('a -> 'b option) -> 'a option -> 'b option
val ofold : ('a -> 'b -> 'b) -> 'b -> 'a option -> 'b
val omap : ('a -> 'b) -> 'a option -> 'b option
val odfl : 'a -> 'a option -> 'a
val ofdfl : (unit -> 'a) -> 'a option -> 'a
val oget : 'a option -> 'a
val oall2 : ('a -> 'b -> bool) -> 'a option -> 'b option -> bool
val otolist : 'a option -> 'a list
val ocompare : 'a cmp -> 'a option cmp
val omap_dfl : ('a -> 'b) -> 'b -> 'a option -> 'b
module OSmart : sig
val omap : ('a -> 'a) -> 'a option -> 'a option
val omap_fold : ('a -> 'b -> 'a * 'b) -> 'a -> 'b option -> 'a * 'b option
end
(* -------------------------------------------------------------------- *)
type ('a, 'b) tagged = Tagged of ('a * 'b option)
val tg_val : ('a, 'b) tagged -> 'a
val tg_tag : ('a, 'b) tagged -> 'b option
val tg_map : ('a -> 'b) -> ('a, 'c) tagged -> ('b, 'c) tagged
val notag : 'a -> ('a, 'b) tagged
(* -------------------------------------------------------------------- *)
module Counter : sig
type t
val create : unit -> t
val next : t -> int
end
(* -------------------------------------------------------------------- *)
module Disposable : sig
type 'a t
exception Disposed
val create : ?cb:('a -> unit) -> 'a -> 'a t
val get : 'a t -> 'a
val dispose : 'a t -> unit
end
(* -------------------------------------------------------------------- *)
module List : sig
include module type of List
val compare : 'a cmp -> 'a list cmp
val ocons : 'a option -> 'a list -> 'a list
val isempty : 'a list -> bool
val ohead : 'a list -> 'a option
val otail : 'a list -> 'a list option
val last : 'a list -> 'a
val olast : 'a list -> 'a option
val iteri : (int -> 'a -> 'b) -> 'a list -> unit
val iter2i : (int -> 'a -> 'b -> 'c) -> 'a list -> 'b list -> unit
val fusion : ('a -> 'a -> 'a) -> 'a list -> 'a list -> 'a list
val iter2o : ('a option -> 'b option -> 'c) -> 'a list -> 'b list -> unit
val findopt : ('a -> bool) -> 'a list -> 'a option
val findex : ('a -> bool) -> 'a list -> int option
val index : 'a -> 'a list -> int option
val uniqf : ('a -> 'a -> bool) -> 'a list -> bool
val uniq : 'a list -> bool
val take : int -> 'a list -> 'a list
val split_n : int -> 'a list -> 'a list * 'a * 'a list
val fold_lefti : (int -> 'a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val filter2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> 'a list * 'b list
val create : int -> 'a -> 'a list
val init : int -> (int -> 'a) -> 'a list
val find_split : ('a -> bool) -> 'a list -> 'a list * 'a * 'a list
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
val map_fold : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list
val map_combine : ('a -> 'c) -> ('b -> 'd) -> 'a list -> 'b list -> ('c * 'd) list
val take_n : int -> 'a list -> 'a list * 'a list
val all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val hd2 : 'a list -> 'a * 'a
val pick : ('a -> 'b option) -> 'a list -> 'b option
val fpick : (unit -> 'a option) list -> 'a option
val assoc_eq : ('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b
val tryassoc_eq : ('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b option
val tryassoc : 'a -> ('a * 'b) list -> 'b option
val find_map : ('a -> 'b option) -> 'a list -> 'b
val pmap : ('a -> 'b option) -> 'a list -> 'b list
val prmap : ('a -> 'b option) -> 'a list -> 'b list
val sum : int list -> int
val min : 'a -> 'a list -> 'a
val max : 'a -> 'a list -> 'a
val rotate : [`Left|`Right] -> int -> 'a list -> int * 'a list
module Smart : sig
val map : ('a -> 'a) -> 'a list -> 'a list
val map_fold : ('a -> 'b -> 'a * 'b) -> 'a -> 'b list -> 'a * 'b list
end
end
(* -------------------------------------------------------------------- *)
module Stream : sig
include module type of Stream with type 'a t = 'a Stream.t
val next_opt : 'a Stream.t -> 'a option
end
(* -------------------------------------------------------------------- *)
module String : sig
include module type of String
val map : (char -> char) -> string -> string
val startswith : string -> string -> bool
val endswith : string -> string -> bool
val slice : ?first:int -> ?last:int -> string -> string
val split : char -> string -> string list
val splitlines : string -> string list
val strip : string -> string
end
(* -------------------------------------------------------------------- *)
module Parray : sig
type 'a t
val empty : 'a t
val get : 'a t -> int -> 'a
val length : 'a t -> int
val of_list : 'a list -> 'a t
val to_list : 'a t -> 'a list
val of_array : 'a array -> 'a t
val init : int -> (int -> 'a) -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val fmap : ('a -> 'b) -> 'a list -> 'b t
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
val fold_right : ('b -> 'a -> 'a) -> 'b t -> 'a -> 'a
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b t -> 'c t -> 'a
val iter : ('a -> unit) -> 'a t -> unit
val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit
val split : ('a * 'b) t -> ('a t * 'b t)
val exists : ('a -> bool) -> 'a t -> bool
val for_all : ('a -> bool) -> 'a t -> bool
end
(* -------------------------------------------------------------------- *)
module Os : sig
val listdir : string -> string list
end