1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
|
(**************************************************************************)
(* *)
(* Menhir *)
(* *)
(* Franois Pottier and Yann Rgis-Gianas, INRIA Rocquencourt *)
(* *)
(* Copyright 2005 Institut National de Recherche en Informatique et *)
(* en Automatique. All rights reserved. This file is distributed *)
(* under the terms of the Q Public License version 1.0, with the *)
(* change described in file LICENSE. *)
(* *)
(**************************************************************************)
(* TEMPORARY tidy up, comment, remove dead code *)
(* Converting an option to a string, with [None] converted
to the empty string. *)
val o2s: 'a option -> ('a -> string) -> string
(* Projection out of a singleton list. *)
val single: 'a list -> 'a
(* A variant of [List.map] where [f] returns a pair of elements,
to be flattened into the new list. *)
val mapd: ('a -> 'b * 'b) -> 'a list -> 'b list
(* Tabulating a function using an internal array. [tabulateb n f]
returns a function that is extensionally equal to [f], but relies
on an internal array. Arguments to [f] are of type [int] and are
supposed to lie in the range [0..n). The result type of [f] is
assumed to be of type [bool]. [tabulateb] also returns the number
of points where [f] is [true]. *)
val tabulateb: int -> (int -> bool) -> (int -> bool) * int
(* [tabulateo number fold n f] returns a function that is
extensionally equal to [f], but relies on an internal
array. Arguments to [f] are of type ['a] and are mapped by [number]
into the range [0..n). [fold] allows folding over the domain of
[f]. The result type of [f] is an option type, and [tabulateo] also
returns the number of points where [f] is [Some _]. *)
val tabulateo: ('a -> int) -> ((unit -> 'a -> unit) -> unit -> unit) -> int -> ('a -> 'b option) -> ('a -> 'b option) * int
(* Truncature of a list. *)
val truncate: int -> 'a list -> 'a list
(* Reverse function application. *)
val ( $$ ) : 'a -> ('a -> 'b) -> 'b
(* Sets of strings and maps over strings. *)
module IntSet : Set.S with type elt = int
(* [separated_list_to_string printer sep l] converts [l] into a string
representation built using [printer] on each element and [sep] as
a separator. *)
val separated_list_to_string: ('a -> string) -> string -> 'a list -> string
(* [index_map f] returns a triple (indexed_f, domain_indexation, domain_array).
[indexed_f] is a mapping from [0..n-1] to the elements of the map [f]
([n] being the size of the image of [f]).
[domain_indexation] is a mapping from the domain of the map [f] to indexes.
[domain_array] is a mapping from the indexes to the domain of [f].
The indexation implements [f] ie:
- forall x in domain(m), indexed_f (domain_indexation x) = f (x).
- forall x in domain(m), domain_array (domain_indexation x) = x. *)
val index_map
: 'a StringMap.t -> (int -> 'a) * (string -> int) * (int -> string)
(* [support_assoc l x] returns the second component of the first couple
in [l] whose first component is [x]. If it does not exist, it returns
[x]. *)
val support_assoc : ('a * 'a) list -> 'a -> 'a
(* [index] indexes a list of (distinct) strings, that is, assigns an
integer index to each string and builds mappings both ways between
strings and indices. *)
val index: string list -> int * string array * int StringMap.t
(* Turning an implicit list, stored using pointers through a hash
table, into an explicit list. The head of the implicit list is
not included in the explicit list. *)
val materialize: ('a, 'a option) Hashtbl.t -> 'a -> 'a list
(* [iteri] implements a [for] loop over integers, from 0 to
[n-1]. *)
val iteri: int -> (int -> unit) -> unit
(* [foldi] implements a [for] loop over integers, from 0 to [n-1],
with an accumulator. [foldij] implements a [for] loop over
integers, from [start] to [n-1], with an accumulator. *)
val foldi: int -> (int -> 'a -> 'a) -> 'a -> 'a
val foldij: int -> int -> (int -> 'a -> 'a) -> 'a -> 'a
(* [qfold f accu q] repeatedly takes an element [x] off the queue [q]
and applies [f] to the accumulator and to [x], until [q] becomes
empty. Of course, [f] can add elements to [q] as a side-effect. *)
val qfold: ('a -> 'b -> 'a) -> 'a -> 'b Queue.t -> 'a
(* [qiter f q] repeatedly takes an element [x] off the queue [q] and
applies [f] to [x], until [q] becomes empty. Of course, [f] can add
elements to [q] as a side-effect. *)
val qiter: ('b -> unit) -> 'b Queue.t -> unit
(* [smap] has the same semantics as [List.map], but attempts to
physically return the input list when [f] is the identity. *)
val smap: ('a -> 'a) -> 'a list -> 'a list
(* [normalize s] returns a copy of [s] where parentheses and commas
are replaced with underscores. *)
val normalize: string -> string
(* [postincrement r] increments [r] and returns its original value. *)
val postincrement: int ref -> int
(* [gcp] returns the greatest common prefix of two strings. *)
val gcp: string -> string -> string
(* [gcps] returns the greatest common prefix of a nonempty list of strings. *)
val gcps : string list -> string
|