Module Common

module Common: sig .. end

Common definitions and utilities

type 'a formatter = Format.formatter -> 'a -> unit

short-hand for user-defined formatter

val get : ('a, 'b) Hashtbl.t -> 'a -> 'b option

wrapper around Hashtbl.find

module type QUEUE = sig .. end

signature for queues

module IntSet: Sets.T

efficient implementation of sets of integers

type int_set = IntSet.t

type 'a hval = 'a Hashcons.hash_consed

hash-consed values, ans sets of such values

type 'a hset = 'a Hset.t

module Set: sig .. end

(not so efficient) implementation of polymorphic sets

type 'a set = 'a Set.t

type ('v, 'k) gstring_ = ('v * ('k * bool) list) list

unterminated guarded strings (for counter-examples)

guarded strings

type ('v, 'k) gstring = ('k * bool) list * ('v, 'k) gstring_

val print_gstring : 'v formatter ->
       'k formatter -> ('v, 'k) gstring formatter

pretty-printing for guarded strings

val paren : int ->
       int ->
       ('b, 'c, 'd, 'e, 'f, 'g) Pervasives.format6 ->
       ('b, 'c, 'd, 'e, 'f, 'g) Pervasives.format6

utility for formatting parenthesised expressions

module Span: sig .. end

spans: sparse polymorphic maps indexed by 'v these maps are used to represent explicit part of the transitions of guarded string automata

type ('v, 's) span = ('v, 's) Span.t

val time : ('a -> 'b) -> 'a -> float * 'b

simple timing function

val memo_rec : ?n:int -> (('a -> 'b) -> 'a -> 'b) -> 'a -> 'b

memoisation utilities

val memo_rec1 : (('a hval -> 'b) -> 'a hval -> 'b) -> 'a hval -> 'b

val memo_rec2 : (('a hval -> 'b hval -> 'c) ->
        'a hval -> 'b hval -> 'c) ->
       'a hval -> 'b hval -> 'c

val next_line : Lexing.lexbuf -> unit

Utilities for lexing/parsing

val unexpected_char : Lexing.lexbuf -> 'a

val parse : ?msg:string -> ('a -> Lexing.lexbuf -> 'b) -> 'a -> Lexing.lexbuf -> 'b