~npalix/coccinelle/upstream

« back to all changes in this revision

Viewing changes to bundles/stdcompat/stdcompat-current/interfaces/4.04/moreLabels.mli

  • Committer: Thierry Martinez
  • Date: 2019-08-20 13:37:04 UTC
  • Revision ID: git-v1:0214afad4a32c95349c2c5a38e37cea407c455d0
Update bundles

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
module Hashtbl :
 
2
sig
 
3
  type ('a, 'b) t = ('a, 'b) Hashtbl.t
 
4
  val create : ?random:bool -> int -> ('a, 'b) t
 
5
  val clear : ('a, 'b) t -> unit
 
6
  val reset : ('a, 'b) t -> unit
 
7
  val copy : ('a, 'b) t -> ('a, 'b) t
 
8
  val add : ('a, 'b) t -> key:'a -> data:'b -> unit
 
9
  val find : ('a, 'b) t -> 'a -> 'b
 
10
  val find_all : ('a, 'b) t -> 'a -> 'b list
 
11
  val mem : ('a, 'b) t -> 'a -> bool
 
12
  val remove : ('a, 'b) t -> 'a -> unit
 
13
  val replace : ('a, 'b) t -> key:'a -> data:'b -> unit
 
14
  val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit
 
15
  val filter_map_inplace :
 
16
    f:(key:'a -> data:'b -> 'b option) -> ('a, 'b) t -> unit
 
17
  val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c
 
18
  val length : ('a, 'b) t -> int
 
19
  val randomize : unit -> unit
 
20
  type statistics = Hashtbl.statistics
 
21
  val stats : ('a, 'b) t -> statistics
 
22
  module type HashedType  = Hashtbl.HashedType
 
23
  module type SeededHashedType  = Hashtbl.SeededHashedType
 
24
  module type S  =
 
25
    sig
 
26
      type key
 
27
      and 'a t
 
28
      val create : int -> 'a t
 
29
      val clear : 'a t -> unit
 
30
      val reset : 'a t -> unit
 
31
      val copy : 'a t -> 'a t
 
32
      val add : 'a t -> key:key -> data:'a -> unit
 
33
      val remove : 'a t -> key -> unit
 
34
      val find : 'a t -> key -> 'a
 
35
      val find_all : 'a t -> key -> 'a list
 
36
      val replace : 'a t -> key:key -> data:'a -> unit
 
37
      val mem : 'a t -> key -> bool
 
38
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
39
      val filter_map_inplace :
 
40
        f:(key:key -> data:'a -> 'a option) -> 'a t -> unit
 
41
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
42
      val length : 'a t -> int
 
43
      val stats : 'a t -> statistics
 
44
    end
 
45
  module type SeededS  =
 
46
    sig
 
47
      type key
 
48
      and 'a t
 
49
      val create : ?random:bool -> int -> 'a t
 
50
      val clear : 'a t -> unit
 
51
      val reset : 'a t -> unit
 
52
      val copy : 'a t -> 'a t
 
53
      val add : 'a t -> key:key -> data:'a -> unit
 
54
      val remove : 'a t -> key -> unit
 
55
      val find : 'a t -> key -> 'a
 
56
      val find_all : 'a t -> key -> 'a list
 
57
      val replace : 'a t -> key:key -> data:'a -> unit
 
58
      val mem : 'a t -> key -> bool
 
59
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
60
      val filter_map_inplace :
 
61
        f:(key:key -> data:'a -> 'a option) -> 'a t -> unit
 
62
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
63
      val length : 'a t -> int
 
64
      val stats : 'a t -> statistics
 
65
    end
 
66
  module Make :
 
67
  functor (H : HashedType) ->
 
68
    sig
 
69
      type key = H.t
 
70
      and 'a t
 
71
      val create : int -> 'a t
 
72
      val clear : 'a t -> unit
 
73
      val reset : 'a t -> unit
 
74
      val copy : 'a t -> 'a t
 
75
      val add : 'a t -> key:key -> data:'a -> unit
 
76
      val remove : 'a t -> key -> unit
 
77
      val find : 'a t -> key -> 'a
 
78
      val find_all : 'a t -> key -> 'a list
 
79
      val replace : 'a t -> key:key -> data:'a -> unit
 
80
      val mem : 'a t -> key -> bool
 
81
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
82
      val filter_map_inplace :
 
83
        f:(key:key -> data:'a -> 'a option) -> 'a t -> unit
 
84
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
85
      val length : 'a t -> int
 
86
      val stats : 'a t -> statistics
 
87
    end
 
88
  module MakeSeeded :
 
89
  functor (H : SeededHashedType) ->
 
90
    sig
 
91
      type key = H.t
 
92
      and 'a t
 
93
      val create : ?random:bool -> int -> 'a t
 
94
      val clear : 'a t -> unit
 
95
      val reset : 'a t -> unit
 
96
      val copy : 'a t -> 'a t
 
97
      val add : 'a t -> key:key -> data:'a -> unit
 
98
      val remove : 'a t -> key -> unit
 
99
      val find : 'a t -> key -> 'a
 
100
      val find_all : 'a t -> key -> 'a list
 
101
      val replace : 'a t -> key:key -> data:'a -> unit
 
102
      val mem : 'a t -> key -> bool
 
103
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
104
      val filter_map_inplace :
 
105
        f:(key:key -> data:'a -> 'a option) -> 'a t -> unit
 
106
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
107
      val length : 'a t -> int
 
108
      val stats : 'a t -> statistics
 
109
    end
 
110
  val hash : 'a -> int
 
111
  val seeded_hash : int -> 'a -> int
 
112
  val hash_param : int -> int -> 'a -> int
 
113
  val seeded_hash_param : int -> int -> int -> 'a -> int
 
114
end
 
115
module Map :
 
116
sig
 
117
  module type OrderedType  = Map.OrderedType
 
118
  module type S  =
 
119
    sig
 
120
      type key
 
121
      and +'a t
 
122
      val empty : 'a t
 
123
      val is_empty : 'a t -> bool
 
124
      val mem : key -> 'a t -> bool
 
125
      val add : key:key -> data:'a -> 'a t -> 'a t
 
126
      val singleton : key -> 'a -> 'a t
 
127
      val remove : key -> 'a t -> 'a t
 
128
      val merge :
 
129
        f:(key -> 'a option -> 'b option -> 'c option) ->
 
130
          'a t -> 'b t -> 'c t
 
131
      val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
 
132
      val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
 
133
      val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 
134
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
135
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
136
      val for_all : f:(key -> 'a -> bool) -> 'a t -> bool
 
137
      val exists : f:(key -> 'a -> bool) -> 'a t -> bool
 
138
      val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t
 
139
      val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t)
 
140
      val cardinal : 'a t -> int
 
141
      val bindings : 'a t -> (key * 'a) list
 
142
      val min_binding : 'a t -> (key * 'a)
 
143
      val max_binding : 'a t -> (key * 'a)
 
144
      val choose : 'a t -> (key * 'a)
 
145
      val split : key -> 'a t -> ('a t * 'a option * 'a t)
 
146
      val find : key -> 'a t -> 'a
 
147
      val map : f:('a -> 'b) -> 'a t -> 'b t
 
148
      val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
 
149
    end
 
150
  module Make :
 
151
  functor (Ord : OrderedType) ->
 
152
    sig
 
153
      type key = Ord.t
 
154
      and +'a t
 
155
      val empty : 'a t
 
156
      val is_empty : 'a t -> bool
 
157
      val mem : key -> 'a t -> bool
 
158
      val add : key:key -> data:'a -> 'a t -> 'a t
 
159
      val singleton : key -> 'a -> 'a t
 
160
      val remove : key -> 'a t -> 'a t
 
161
      val merge :
 
162
        f:(key -> 'a option -> 'b option -> 'c option) ->
 
163
          'a t -> 'b t -> 'c t
 
164
      val union : f:(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
 
165
      val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
 
166
      val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 
167
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
168
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
169
      val for_all : f:(key -> 'a -> bool) -> 'a t -> bool
 
170
      val exists : f:(key -> 'a -> bool) -> 'a t -> bool
 
171
      val filter : f:(key -> 'a -> bool) -> 'a t -> 'a t
 
172
      val partition : f:(key -> 'a -> bool) -> 'a t -> ('a t * 'a t)
 
173
      val cardinal : 'a t -> int
 
174
      val bindings : 'a t -> (key * 'a) list
 
175
      val min_binding : 'a t -> (key * 'a)
 
176
      val max_binding : 'a t -> (key * 'a)
 
177
      val choose : 'a t -> (key * 'a)
 
178
      val split : key -> 'a t -> ('a t * 'a option * 'a t)
 
179
      val find : key -> 'a t -> 'a
 
180
      val map : f:('a -> 'b) -> 'a t -> 'b t
 
181
      val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
 
182
    end
 
183
end
 
184
module Set :
 
185
sig
 
186
  module type OrderedType  = Set.OrderedType
 
187
  module type S  =
 
188
    sig
 
189
      type elt
 
190
      and t
 
191
      val empty : t
 
192
      val is_empty : t -> bool
 
193
      val mem : elt -> t -> bool
 
194
      val add : elt -> t -> t
 
195
      val singleton : elt -> t
 
196
      val remove : elt -> t -> t
 
197
      val union : t -> t -> t
 
198
      val inter : t -> t -> t
 
199
      val diff : t -> t -> t
 
200
      val compare : t -> t -> int
 
201
      val equal : t -> t -> bool
 
202
      val subset : t -> t -> bool
 
203
      val iter : f:(elt -> unit) -> t -> unit
 
204
      val map : f:(elt -> elt) -> t -> t
 
205
      val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
 
206
      val for_all : f:(elt -> bool) -> t -> bool
 
207
      val exists : f:(elt -> bool) -> t -> bool
 
208
      val filter : f:(elt -> bool) -> t -> t
 
209
      val partition : f:(elt -> bool) -> t -> (t * t)
 
210
      val cardinal : t -> int
 
211
      val elements : t -> elt list
 
212
      val min_elt : t -> elt
 
213
      val max_elt : t -> elt
 
214
      val choose : t -> elt
 
215
      val split : elt -> t -> (t * bool * t)
 
216
      val find : elt -> t -> elt
 
217
      val of_list : elt list -> t
 
218
    end
 
219
  module Make :
 
220
  functor (Ord : OrderedType) ->
 
221
    sig
 
222
      type elt = Ord.t
 
223
      and t
 
224
      val empty : t
 
225
      val is_empty : t -> bool
 
226
      val mem : elt -> t -> bool
 
227
      val add : elt -> t -> t
 
228
      val singleton : elt -> t
 
229
      val remove : elt -> t -> t
 
230
      val union : t -> t -> t
 
231
      val inter : t -> t -> t
 
232
      val diff : t -> t -> t
 
233
      val compare : t -> t -> int
 
234
      val equal : t -> t -> bool
 
235
      val subset : t -> t -> bool
 
236
      val iter : f:(elt -> unit) -> t -> unit
 
237
      val map : f:(elt -> elt) -> t -> t
 
238
      val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
 
239
      val for_all : f:(elt -> bool) -> t -> bool
 
240
      val exists : f:(elt -> bool) -> t -> bool
 
241
      val filter : f:(elt -> bool) -> t -> t
 
242
      val partition : f:(elt -> bool) -> t -> (t * t)
 
243
      val cardinal : t -> int
 
244
      val elements : t -> elt list
 
245
      val min_elt : t -> elt
 
246
      val max_elt : t -> elt
 
247
      val choose : t -> elt
 
248
      val split : elt -> t -> (t * bool * t)
 
249
      val find : elt -> t -> elt
 
250
      val of_list : elt list -> t
 
251
    end
 
252
end