1Stdlib.ArrayLabels(3)            OCaml library           Stdlib.ArrayLabels(3)
2
3
4

NAME

6       Stdlib.ArrayLabels - no description
7

Module

9       Module   Stdlib.ArrayLabels
10

Documentation

12       Module ArrayLabels
13        : (module Stdlib__arrayLabels)
14
15
16
17
18
19
20
21       type 'a t = 'a array
22
23
24       An alias for the type of arrays.
25
26
27
28       val length : 'a array -> int
29
30       Return the length (number of elements) of the given array.
31
32
33
34       val get : 'a array -> int -> 'a
35
36
37       get  a  n  returns the element number n of array a .  The first element
38       has number 0.  The last element has number length a - 1 .  You can also
39       write a.(n) instead of get a n .
40
41
42       Raises Invalid_argument if n is outside the range 0 to (length a - 1) .
43
44
45
46       val set : 'a array -> int -> 'a -> unit
47
48
49       set  a n x modifies array a in place, replacing element number n with x
50       .  You can also write a.(n) <- x instead of set a n x .
51
52
53       Raises Invalid_argument if n is outside the range 0 to length a - 1 .
54
55
56
57       val make : int -> 'a -> 'a array
58
59
60       make n x returns a fresh array of length n , initialized with x .   All
61       the  elements of this new array are initially physically equal to x (in
62       the sense of the == predicate).  Consequently, if x is mutable,  it  is
63       shared  among all elements of the array, and modifying x through one of
64       the array entries will modify all other entries at the same time.
65
66
67       Raises Invalid_argument if n < 0 or n > Sys.max_array_length .  If  the
68       value  of  x  is a floating-point number, then the maximum size is only
69       Sys.max_array_length / 2 .
70
71
72
73       val create : int -> 'a -> 'a array
74
75       Deprecated.
76
77       create is an alias for ArrayLabels.make .
78
79
80
81       val init : int -> f:(int -> 'a) -> 'a array
82
83
84       init n ~f returns a fresh array of length n ,  with  element  number  i
85       initialized to the result of f i .  In other terms, init n ~f tabulates
86       the results of f applied to the integers 0 to n-1 .
87
88
89       Raises Invalid_argument if n < 0 or n > Sys.max_array_length .  If  the
90       return   type   of  f  is  float  ,  then  the  maximum  size  is  only
91       Sys.max_array_length / 2 .
92
93
94
95       val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
96
97
98       make_matrix ~dimx ~dimy e returns a two-dimensional array (an array  of
99       arrays)  with  first dimension dimx and second dimension dimy . All the
100       elements of this new matrix are initially physically equal to e .   The
101       element ( x,y ) of a matrix m is accessed with the notation m.(x).(y) .
102
103
104       Raises  Invalid_argument  if  dimx  or dimy is negative or greater than
105       Sys.max_array_length .  If the value of e is a  floating-point  number,
106       then the maximum size is only Sys.max_array_length / 2 .
107
108
109
110       val create_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
111
112       Deprecated.
113
114       create_matrix is an alias for ArrayLabels.make_matrix .
115
116
117
118       val append : 'a array -> 'a array -> 'a array
119
120
121       append  v1 v2 returns a fresh array containing the concatenation of the
122       arrays v1 and v2 .
123
124
125
126       val concat : 'a array list -> 'a array
127
128       Same as ArrayLabels.append , but concatenates a list of arrays.
129
130
131
132       val sub : 'a array -> pos:int -> len:int -> 'a array
133
134
135       sub a ~pos ~len returns a fresh array of length len  ,  containing  the
136       elements number pos to pos + len - 1 of array a .
137
138
139       Raises  Invalid_argument if pos and len do not designate a valid subar‐
140       ray of a ; that is, if pos < 0 , or len < 0 , or pos + len > length a .
141
142
143
144       val copy : 'a array -> 'a array
145
146
147       copy a returns a copy of a , that is, a fresh array containing the same
148       elements as a .
149
150
151
152       val fill : 'a array -> pos:int -> len:int -> 'a -> unit
153
154
155       fill a ~pos ~len x modifies the array a in place, storing x in elements
156       number pos to pos + len - 1 .
157
158
159       Raises Invalid_argument if pos and len do not designate a valid  subar‐
160       ray of a .
161
162
163
164       val  blit  : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int
165       -> len:int -> unit
166
167
168       blit ~src ~src_pos ~dst ~dst_pos ~len copies len  elements  from  array
169       src  ,  starting at element number src_pos , to array dst , starting at
170       element number dst_pos . It works correctly even if src and dst are the
171       same array, and the source and destination chunks overlap.
172
173
174       Raises  Invalid_argument  if  src_pos  and len do not designate a valid
175       subarray of src , or if dst_pos and len do not designate a valid subar‐
176       ray of dst .
177
178
179
180       val to_list : 'a array -> 'a list
181
182
183       to_list a returns the list of all the elements of a .
184
185
186
187       val of_list : 'a list -> 'a array
188
189
190       of_list l returns a fresh array containing the elements of l .
191
192
193
194       val iter : f:('a -> unit) -> 'a array -> unit
195
196
197       iter  ~f a applies function f in turn to all the elements of a .  It is
198       equivalent to f a.(0); f a.(1); ...; f a.(length a - 1); () .
199
200
201
202       val map : f:('a -> 'b) -> 'a array -> 'b array
203
204
205       map ~f a applies function f to all the elements of a ,  and  builds  an
206       array  with  the  results  returned  by f : [| f a.(0); f a.(1); ...; f
207       a.(length a - 1) |] .
208
209
210
211       val iteri : f:(int -> 'a -> unit) -> 'a array -> unit
212
213       Same as ArrayLabels.iter , but the function is applied to the index  of
214       the  element  as first argument, and the element itself as second argu‐
215       ment.
216
217
218
219       val mapi : f:(int -> 'a -> 'b) -> 'a array -> 'b array
220
221       Same as ArrayLabels.map , but the function is applied to the  index  of
222       the  element  as first argument, and the element itself as second argu‐
223       ment.
224
225
226
227       val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b array -> 'a
228
229
230       fold_left ~f ~init a computes f (... (f  (f  init  a.(0))  a.(1))  ...)
231       a.(n-1) , where n is the length of the array a .
232
233
234
235       val fold_right : f:('b -> 'a -> 'a) -> 'b array -> init:'a -> 'a
236
237
238       fold_right  ~f a ~init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init)
239       ...))  , where n is the length of the array a .
240
241
242
243
244   Iterators on two arrays
245       val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit
246
247
248       iter2 ~f a b applies function f to all the elements of a and b .
249
250
251       Since 4.05.0
252
253
254       Raises Invalid_argument if the arrays are not the same size.
255
256
257
258       val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
259
260
261       map2 ~f a b applies function f to all the elements of a  and  b  ,  and
262       builds an array with the results returned by f : [| f a.(0) b.(0); ...;
263       f a.(length a - 1) b.(length b - 1)|] .
264
265
266       Since 4.05.0
267
268
269       Raises Invalid_argument if the arrays are not the same size.
270
271
272
273
274   Array scanning
275       val exists : f:('a -> bool) -> 'a array -> bool
276
277
278       exists ~f [|a1; ...; an|] checks if at least one element of  the  array
279       satisfies the predicate f . That is, it returns (f a1) || (f a2) || ...
280       || (f an) .
281
282
283       Since 4.03.0
284
285
286
287       val for_all : f:('a -> bool) -> 'a array -> bool
288
289
290       for_all ~f [|a1; ...; an|] checks if all elements of the array  satisfy
291       the predicate f . That is, it returns (f a1) && (f a2) && ... && (f an)
292       .
293
294
295       Since 4.03.0
296
297
298
299       val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool
300
301       Same as ArrayLabels.for_all , but for a two-argument predicate.
302
303
304       Since 4.11.0
305
306
307       Raises Invalid_argument if the two arrays have different lengths.
308
309
310
311       val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool
312
313       Same as ArrayLabels.exists , but for a two-argument predicate.
314
315
316       Since 4.11.0
317
318
319       Raises Invalid_argument if the two arrays have different lengths.
320
321
322
323       val mem : 'a -> set:'a array -> bool
324
325
326       mem x ~set is true if and only if x is equal to an element of set .
327
328
329       Since 4.03.0
330
331
332
333       val memq : 'a -> set:'a array -> bool
334
335       Same as ArrayLabels.mem , but uses physical equality instead of  struc‐
336       tural equality to compare list elements.
337
338
339       Since 4.03.0
340
341
342
343       val create_float : int -> float array
344
345
346       create_float  n  returns  a fresh float array of length n , with unini‐
347       tialized data.
348
349
350       Since 4.03
351
352
353
354       val make_float : int -> float array
355
356       Deprecated.
357
358       ArrayLabels.make_float is an alias for ArrayLabels.create_float .
359
360
361
362
363   Sorting
364       val sort : cmp:('a -> 'a -> int) -> 'a array -> unit
365
366       Sort an array in increasing order according to a  comparison  function.
367       The  comparison  function  must  return  0  if its arguments compare as
368       equal, a positive integer if the first is greater, and a negative inte‐
369       ger  if  the first is smaller (see below for a complete specification).
370       For example, compare is a suitable comparison function, provided  there
371       are no floating-point NaN values in the data.  After calling sort , the
372       array is sorted in place in increasing order.  sort  is  guaranteed  to
373       run in constant heap space and (at most) logarithmic stack space.
374
375       The  current  implementation uses Heap Sort.  It runs in constant stack
376       space.
377
378       Specification of the comparison function: Let a be the  array  and  cmp
379       the comparison function.  The following must be true for all x, y, z in
380       a :
381
382       - cmp x y > 0 if and only if cmp y x < 0
383
384       -  if cmp x y >= 0 and cmp y z >= 0 then cmp x z >= 0
385
386       When sort returns, a contains the same elements as before, reordered in
387       such a way that for all i and j valid indices of a :
388
389       - cmp a.(i) a.(j) >= 0 if and only if i >= j
390
391
392
393
394       val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
395
396       Same  as  ArrayLabels.sort  , but the sorting algorithm is stable (i.e.
397       elements that compare equal are kept in their original order)  and  not
398       guaranteed to run in constant heap space.
399
400       The  current  implementation uses Merge Sort. It uses n/2 words of heap
401       space, where n is the length of the array.  It is usually  faster  than
402       the current implementation of ArrayLabels.sort .
403
404
405
406       val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
407
408       Same  as  ArrayLabels.sort  or  ArrayLabels.stable_sort  , whichever is
409       faster on typical input.
410
411
412
413
414   Iterators
415       val to_seq : 'a array -> 'a Seq.t
416
417       Iterate on the array, in increasing order
418
419
420       Since 4.07
421
422
423
424       val to_seqi : 'a array -> (int * 'a) Seq.t
425
426       Iterate on the array, in increasing order, yielding indices along  ele‐
427       ments
428
429
430       Since 4.07
431
432
433
434       val of_seq : 'a Seq.t -> 'a array
435
436       Create an array from the generator
437
438
439       Since 4.07
440
441
442
443
444
445OCamldoc                          2020-09-01             Stdlib.ArrayLabels(3)