← Back to branch summary

~npalix/coccinelle/upstream

« back to all changes in this revision

Viewing changes to bundles/stdcompat/stdcompat-current/interfaces/3.10/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:
bundles/stdcompat/stdcompat-current/interfaces/3.10/moreLabels.mli
 
1
module Hashtbl :
 
2
sig
 
3
  type ('a, 'b) t = ('a, 'b) Hashtbl.t
 
4
  val create : int -> ('a, 'b) t
 
5
  val clear : ('a, 'b) t -> unit
 
6
  val add : ('a, 'b) t -> key:'a -> data:'b -> unit
 
7
  val copy : ('a, 'b) t -> ('a, 'b) t
 
8
  val find : ('a, 'b) t -> 'a -> 'b
 
9
  val find_all : ('a, 'b) t -> 'a -> 'b list
 
10
  val mem : ('a, 'b) t -> 'a -> bool
 
11
  val remove : ('a, 'b) t -> 'a -> unit
 
12
  val replace : ('a, 'b) t -> key:'a -> data:'b -> unit
 
13
  val iter : f:(key:'a -> data:'b -> unit) -> ('a, 'b) t -> unit
 
14
  val fold : f:(key:'a -> data:'b -> 'c -> 'c) -> ('a, 'b) t -> init:'c -> 'c
 
15
  val length : ('a, 'b) t -> int
 
16
  module type HashedType  = Hashtbl.HashedType
 
17
  module type S  =
 
18
    sig
 
19
      type key
 
20
      and 'a t
 
21
      val create : int -> 'a t
 
22
      val clear : 'a t -> unit
 
23
      val copy : 'a t -> 'a t
 
24
      val add : 'a t -> key:key -> data:'a -> unit
 
25
      val remove : 'a t -> key -> unit
 
26
      val find : 'a t -> key -> 'a
 
27
      val find_all : 'a t -> key -> 'a list
 
28
      val replace : 'a t -> key:key -> data:'a -> unit
 
29
      val mem : 'a t -> key -> bool
 
30
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
31
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
32
      val length : 'a t -> int
 
33
    end
 
34
  module Make :
 
35
  functor (H : HashedType) ->
 
36
    sig
 
37
      type key = H.t
 
38
      and 'a t
 
39
      val create : int -> 'a t
 
40
      val clear : 'a t -> unit
 
41
      val copy : 'a t -> 'a t
 
42
      val add : 'a t -> key:key -> data:'a -> unit
 
43
      val remove : 'a t -> key -> unit
 
44
      val find : 'a t -> key -> 'a
 
45
      val find_all : 'a t -> key -> 'a list
 
46
      val replace : 'a t -> key:key -> data:'a -> unit
 
47
      val mem : 'a t -> key -> bool
 
48
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
49
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
50
      val length : 'a t -> int
 
51
    end
 
52
  val hash : 'a -> int
 
53
  external hash_param :
 
54
    int -> int -> 'a -> int = "caml_hash_univ_param" "noalloc"
 
55
end
 
56
module Map :
 
57
sig
 
58
  module type OrderedType  = Map.OrderedType
 
59
  module type S  =
 
60
    sig
 
61
      type key
 
62
      and +'a t
 
63
      val empty : 'a t
 
64
      val is_empty : 'a t -> bool
 
65
      val add : key:key -> data:'a -> 'a t -> 'a t
 
66
      val find : key -> 'a t -> 'a
 
67
      val remove : key -> 'a t -> 'a t
 
68
      val mem : key -> 'a t -> bool
 
69
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
70
      val map : f:('a -> 'b) -> 'a t -> 'b t
 
71
      val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
 
72
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
73
      val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
 
74
      val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 
75
    end
 
76
  module Make :
 
77
  functor (Ord : OrderedType) ->
 
78
    sig
 
79
      type key = Ord.t
 
80
      and 'a t
 
81
      val empty : 'a t
 
82
      val is_empty : 'a t -> bool
 
83
      val add : key:key -> data:'a -> 'a t -> 'a t
 
84
      val find : key -> 'a t -> 'a
 
85
      val remove : key -> 'a t -> 'a t
 
86
      val mem : key -> 'a t -> bool
 
87
      val iter : f:(key:key -> data:'a -> unit) -> 'a t -> unit
 
88
      val map : f:('a -> 'b) -> 'a t -> 'b t
 
89
      val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t
 
90
      val fold : f:(key:key -> data:'a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
 
91
      val compare : cmp:('a -> 'a -> int) -> 'a t -> 'a t -> int
 
92
      val equal : cmp:('a -> 'a -> bool) -> 'a t -> 'a t -> bool
 
93
    end
 
94
end
 
95
module Set :
 
96
sig
 
97
  module type OrderedType  = Set.OrderedType
 
98
  module type S  =
 
99
    sig
 
100
      type elt
 
101
      and t
 
102
      val empty : t
 
103
      val is_empty : t -> bool
 
104
      val mem : elt -> t -> bool
 
105
      val add : elt -> t -> t
 
106
      val singleton : elt -> t
 
107
      val remove : elt -> t -> t
 
108
      val union : t -> t -> t
 
109
      val inter : t -> t -> t
 
110
      val diff : t -> t -> t
 
111
      val compare : t -> t -> int
 
112
      val equal : t -> t -> bool
 
113
      val subset : t -> t -> bool
 
114
      val iter : f:(elt -> unit) -> t -> unit
 
115
      val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
 
116
      val for_all : f:(elt -> bool) -> t -> bool
 
117
      val exists : f:(elt -> bool) -> t -> bool
 
118
      val filter : f:(elt -> bool) -> t -> t
 
119
      val partition : f:(elt -> bool) -> t -> (t * t)
 
120
      val cardinal : t -> int
 
121
      val elements : t -> elt list
 
122
      val min_elt : t -> elt
 
123
      val max_elt : t -> elt
 
124
      val choose : t -> elt
 
125
      val split : elt -> t -> (t * bool * t)
 
126
    end
 
127
  module Make :
 
128
  functor (Ord : OrderedType) ->
 
129
    sig
 
130
      type elt = Ord.t
 
131
      and t
 
132
      val empty : t
 
133
      val is_empty : t -> bool
 
134
      val mem : elt -> t -> bool
 
135
      val add : elt -> t -> t
 
136
      val singleton : elt -> t
 
137
      val remove : elt -> t -> t
 
138
      val union : t -> t -> t
 
139
      val inter : t -> t -> t
 
140
      val diff : t -> t -> t
 
141
      val compare : t -> t -> int
 
142
      val equal : t -> t -> bool
 
143
      val subset : t -> t -> bool
 
144
      val iter : f:(elt -> unit) -> t -> unit
 
145
      val fold : f:(elt -> 'a -> 'a) -> t -> init:'a -> 'a
 
146
      val for_all : f:(elt -> bool) -> t -> bool
 
147
      val exists : f:(elt -> bool) -> t -> bool
 
148
      val filter : f:(elt -> bool) -> t -> t
 
149
      val partition : f:(elt -> bool) -> t -> (t * t)
 
150
      val cardinal : t -> int
 
151
      val elements : t -> elt list
 
152
      val min_elt : t -> elt
 
153
      val max_elt : t -> elt
 
154
      val choose : t -> elt
 
155
      val split : elt -> t -> (t * bool * t)
 
156
    end
 
157
end