Module Tools

module Tools: sig .. end

module Descriptor: UnionFind.Desc

type ('a, 'b) case =

`\|`	`A of 'a`
`\|`	`B of 'b`

val comp_to_list : ('a -> 'b -> int) -> 'a list -> 'b list -> int

val comp_to_array : ('a -> 'b -> int) -> int -> 'a array -> 'b array -> int

val comp_to_pair : ('a -> 'b -> int) -> ('c -> 'd -> int) -> 'a * 'c -> 'b * 'd -> int

val comp_to_pair2 : ('a -> 'b -> int) -> ('c -> 'd -> int) -> 'a * 'c -> 'b * 'd -> int

val comp_to_tripl : ('a -> 'b -> int) ->
       ('c -> 'd -> int) -> ('e -> 'f -> int) -> 'a * 'c * 'e -> 'b * 'd * 'f -> int

val comp_to_option : ('a -> 'b -> int) -> 'a option -> 'b option -> int

module type Base = sig .. end

module CaseB: functor (B1 : Base) -> functor (B2 : Base) -> sig .. end

module ListB: functor (B : Base) -> sig .. end

module ArrayB: functor (B : Base) -> sig .. end

module PairB: functor (B1 : Base) -> functor (B2 : Base) -> sig .. end

module Pair2B: functor (B1 : Base) -> functor (B2 : Base) -> sig .. end

module OptionB: functor (B : Base) -> sig .. end

module ToItem: functor (B : Base) -> UnionFind.Item

module MakeUF: functor (B1 : Base) -> functor (B2 : Base) -> sig .. end

type ('a, 'b) bij = ('a -> 'b) * ('b -> 'a)

val mem : ('a -> 'b -> int) -> 'a -> 'b list -> bool

val mem2 : ('a -> 'b -> int) -> 'a -> ('b * 'c) list -> bool

val inser : ('a -> 'a -> int) -> 'a -> 'a list -> 'a list

val inserb : ('a -> 'a -> int) -> 'a -> 'a list -> 'a list option

val inter : ('a -> 'b -> int) -> 'a list -> 'b list -> bool

val makebij : 'a list -> ('a, int) bij

val conc : ('a -> 'a -> int) -> 'a list list -> 'a list

val (@@) : 'a list -> 'a list -> 'a list

val bind : ('a -> 'a -> int) -> ('b -> 'a list) -> 'b list -> 'a list

val assoc : ('a -> 'a -> int) -> 'a -> ('a * 'b) list -> 'b

val assoc2 : ('a -> 'a -> int) -> 'a -> ('a * 'b) list -> 'b list

val makefuncnd : (module Tools.Base with type t = 'a) ->
       (module Tools.Base with type t = 'b) ->
       ('a * 'b * 'a) list -> 'a -> 'b -> 'a list

val makefuncd : (module Tools.Base with type t = 'a) ->
       (module Tools.Base with type t = 'b) ->
       ('a * 'b * 'a) list -> 'a -> 'b -> 'a option

val mappairs : ('a -> 'a -> int) ->
       ('b -> 'a * 'c) -> 'c list -> 'b list -> 'a list * 'c list

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

val (^^) : 'a list -> 'a list -> 'a list

val remove : ('a -> 'a -> int) -> 'a -> 'a list -> 'a list

val chrono : ('a -> 'b) -> 'a -> 'b

val fold_lefti : (int -> 'a -> 'b -> 'a) -> 'a -> 'b array -> 'a