File: refList.mli

package info (click to toggle)
extlib 1.7.7-2
  • links: PTS, VCS
  • area: main
  • in suites: bookworm, bullseye, sid
  • size: 632 kB
  • sloc: ml: 6,980; makefile: 128; sh: 42; ansic: 31
file content (201 lines) | stat: -rw-r--r-- 6,251 bytes parent folder | download
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
(*
 * RefList - List reference
 * Copyright (C) 2003 Nicolas Cannasse
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version,
 * with the special exception on linking described in file LICENSE.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *)

(** Reference on lists.

  RefList is a extended set of functions that manipulate list
  references.
*)

exception Empty_list
exception Invalid_index of int

type 'a t

val empty : unit -> 'a t
(** Returns a new empty ref list *)
  
val is_empty : 'a t -> bool
(** Return [true] if a ref list is empty *)

val clear : 'a t -> unit
(** Removes all elements *)

val length : 'a t -> int
(** Returns the number of elements - O(n) *)

val copy : dst:'a t -> src:'a t -> unit
(** Makes a copy of a ref list - O(1) *)

val copy_list : dst:'a t -> src:'a list -> unit
(** Makes a copy of a list - O(1) *)

val copy_enum : dst:'a t -> src:'a Enum.t -> unit
(** Makes a copy of a enum *)

val of_list : 'a list -> 'a t
(** Creates a ref list from a list - O(1) *)

val to_list : 'a t -> 'a list
(** Returns the current elements as a list - O(1) *)

val of_enum : 'a Enum.t -> 'a t
(** Creates a ref list from an enumeration *)

val enum : 'a t -> 'a Enum.t
(** Returns an enumeration of current elements in the ref list *)

val add : 'a t -> 'a -> unit
(** Adds an element at the end - O(n) *)

val push : 'a t -> 'a -> unit
(** Adds an element at the head - O(1) *)

val add_sort : ?cmp:('a -> 'a -> int) -> 'a t -> 'a -> unit
(** Adds an element in a sorted list, using optional comparator
    or 'compare' as default. *)

val first : 'a t -> 'a
(** Returns the first element or
    raises [Empty_list] if the ref list is empty *)

val last : 'a t -> 'a
(** Returns the last element - O(n) or
    raises Empty_list if the ref list is empty *)

val pop : 'a t -> 'a
(** Removes and returns the first element or
   raises [Empty_list] if the ref list is empty *)

val npop : 'a t -> int -> 'a list
(** Removes and returns the n first elements or
   raises [Empty_list] if the ref list does not
   contain enough elements *)

val hd : 'a t -> 'a
(** same as [first] *)

val tl : 'a t -> 'a t
(** Returns a ref list containing the same elements
    but without the first one or
    raises [Empty_list] if the ref list is empty *)

val rev : 'a t -> unit
(** Reverses the ref list - O(n) *)

(** {6 Functional Operations} *)

val iter : ('a -> unit) -> 'a t -> unit
(** Apply the given function to all elements of the
    ref list, in respect with the order of the list *)

val find : ('a -> bool) -> 'a t -> 'a
(** Find the first element matching
    the specified predicate
    raise [Not_found] if no element is found *)

val rfind : ('a -> bool) -> 'a t -> 'a
(** Find the first element in the reversed ref list matching
    the specified predicate
    raise [Not_found] if no element is found *)

val find_exc : ('a -> bool) -> exn -> 'a t -> 'a
(** Same as find but takes an exception to be raised when
    no element is found as additional parameter *)

val exists : ('a -> bool) -> 'a t -> bool
(** Return [true] if an element matches the specified
    predicate *)

val for_all : ('a -> bool) -> 'a t -> bool
(** Return [true] if all elements match the specified
    predicate *)

val map : ('a -> 'b) -> 'a t -> 'b t
(** Apply a function to all elements
    and return the ref list constructed with
    the function returned values *)

val transform : ('a -> 'a) -> 'a t -> unit
(** transform all elements in the ref list
    using a function. *)

val map_list : ('a -> 'b) -> 'a t -> 'b list
(** Apply a function to all elements
    and return the list constructed with
    the function returned values *)

val sort : ?cmp:('a -> 'a -> int) -> 'a t -> unit
(** Sort elements using the specified comparator
    or compare as default comparator *)

val filter : ('a -> bool) -> 'a t -> unit
(** Remove all elements that do not match the
    specified predicate *)

val remove : 'a t -> 'a -> unit
(** Remove an element from the ref list
    raise [Not_found] if the element is not found *)

val remove_if : ('a -> bool) -> 'a t -> unit
(** Remove the first element matching the
    specified predicate
    raise [Not_found] if no element has been removed *)

val remove_all : 'a t -> 'a -> unit
(** Remove all elements equal to the specified
    element from the ref list *)



(** Functions that operate on the [i]th element of a list.

    While it is sometimes necessary to perform these
    operations on lists (hence their inclusion here), the
    functions were moved to an inner module to prevent
    their overuse: all functions work in O(n) time. You
  might prefer to use [Array] or [DynArray] for constant
  time indexed element access.
*)
module Index : sig

  val index_of : 'a t -> 'a -> int
  (** Return the index (position : 0 starting) of an element in
      a ref list, using ( = ) for testing element equality
      raise [Not_found] if no element was found *)

  val index : ('a -> bool) -> 'a t -> int
  (** Return the index (position : 0 starting) of an element in
      a ref list, using the specified comparator
      raise [Not_found] if no element was found *)

  val at_index : 'a t -> int -> 'a
  (** Return the element of ref list at the specified index
      raise [Invalid_index] if the index is outside [0 ; length-1] *)

  val set : 'a t -> int -> 'a -> unit
  (** Change the element at the specified index
      raise [Invalid_index] if the index is outside [0 ; length-1] *)

  val remove_at : 'a t -> int -> unit
  (** Remove the element at the specified index
      raise [Invalid_index] if the index is outside [0 ; length-1] *)

end