@nodef/extra-array.web 0.0.0-stage → 4.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.d.ts ADDED
@@ -0,0 +1,1421 @@
1
+ /** Entries is an array of index-value pairs, with unique indices. */ export type Entries<T> = [number, T][];
2
+ /** IEntries is a list of index-value pairs, with unique indices. */ export type IEntries<T> = Iterable<[number, T]>;
3
+ /** Lists is a pair of index array and value array, with unique indices. */ export type Lists<T> = [number[], T[]];
4
+ /** ILists is a pair of index iterable list and value iterable list, with unique indices. */ export type ILists<T> = [Iterable<number>, Iterable<T>];
5
+ /**
6
+ * Handle reading of a single value.
7
+ * @returns value
8
+ */ export type ReadFunction<T> = () => T;
9
+ /**
10
+ * Handle combining of two values.
11
+ * @param a a value
12
+ * @param b another value
13
+ * @returns combined value
14
+ */ export type CombineFunction<T> = (a: T, b: T) => T;
15
+ /**
16
+ * Handle comparison of two values.
17
+ * @param a a value
18
+ * @param b another value
19
+ * @returns a<b: -ve, a=b: 0, a>b: +ve
20
+ */ export type CompareFunction<T> = (a: T, b: T) => number;
21
+ /**
22
+ * Handle processing of values in an array.
23
+ * @param v value in array
24
+ * @param i index of value in array
25
+ * @param x array containing the value
26
+ */ export type ProcessFunction<T> = (v: T, i: number, x: T[] | null) => void;
27
+ /**
28
+ * Handle selection of values in an array.
29
+ * @param v value in array
30
+ * @param i index of value in array
31
+ * @param x array containing the value
32
+ * @returns selected?
33
+ */ export type TestFunction<T> = (v: T, i: number, x: T[] | null) => boolean;
34
+ /**
35
+ * Handle transformation of a value to another.
36
+ * @param v value in array
37
+ * @param i index of value in array
38
+ * @param x array containing the value
39
+ * @returns transformed value
40
+ */ export type MapFunction<T, U> = (v: T, i: number, x: T[] | null) => U;
41
+ /**
42
+ * Handle reduction of multiple values into a single value.
43
+ * @param acc accumulator (temporary result)
44
+ * @param v value in array
45
+ * @param i index of value in array
46
+ * @param x array containing the value
47
+ * @returns reduced value
48
+ */ export type ReduceFunction<T, U> = (acc: U, v: T, i: number, x: T[] | null) => U;
49
+ /**
50
+ * Handle ending of a combined array.
51
+ * @param dones iᵗʰ array done?
52
+ * @returns combined array done?
53
+ */ export type EndFunction = (dones: boolean[]) => boolean;
54
+ /**
55
+ * Handle swapping of two values in an array.
56
+ * @param x an array (updated!)
57
+ * @param i an index
58
+ * @param j another index
59
+ * @returns x | x[i] ⇔ x[j]
60
+ */ export type SwapFunction<T> = (x: T[], i: number, j: number) => T[];
61
+ /**
62
+ * Generate array from given number range.
63
+ * @param v start number
64
+ * @param V end number, excluding
65
+ * @param dv step size [1]
66
+ * @returns [v, v+dv, v+2dv, ...]
67
+ */ export declare function fromRange(v: number, V: number, dv?: number): number[];
68
+ /**
69
+ * Generate array from repeated function invocation.
70
+ * @param fn function
71
+ * @param n number of values
72
+ * @returns [fn(), fn(), ...]
73
+ */ export declare function fromInvocation<T>(fn: () => T, n: number): T[];
74
+ export { fromInvocation as fromCall };
75
+ /**
76
+ * Generate array from repeated function application.
77
+ * @param fm map function (v, i)
78
+ * @param v start value
79
+ * @param n number of values
80
+ * @returns [v, fm(v), fm(fm(v)), ...]
81
+ */ export declare function fromApplication<T>(fm: MapFunction<T, T>, v: T, n: number): T[];
82
+ export { fromApplication as fromApply };
83
+ /**
84
+ * Convert an iterable to array.
85
+ * @param x an iterable
86
+ * @returns x as array
87
+ */ export declare function fromIterable<T>(x: Iterable<T>): T[];
88
+ export { fromIterable as from };
89
+ /**
90
+ * Convert an iterable to array!
91
+ * @param x an iterable (updatable if array!)
92
+ * @returns x as array
93
+ */ export declare function fromIterable$<T>(x: Iterable<T>): T[];
94
+ export { fromIterable$ as from$ };
95
+ /**
96
+ * Shallow clone an array.
97
+ * @param x an array
98
+ * @returns shallow clone of x
99
+ */ export declare function shallowClone<T>(x: T[]): T[];
100
+ export { shallowClone as clone };
101
+ /**
102
+ * Deep clone an array.
103
+ * @param x an array
104
+ * @returns deep clone of x
105
+ */ export declare function deepClone<T>(x: T[]): T[];
106
+ /**
107
+ * Check if value is an array.
108
+ * @param v a value
109
+ * @returns v is an array?
110
+ */ export declare function is(v: unknown): v is unknown[];
111
+ /**
112
+ * Obtain all indices.
113
+ * @param x an array
114
+ * @returns [0, 1, ..., |x|-1]
115
+ */ export declare function keys<T>(x: T[]): number[];
116
+ /**
117
+ * List all indices.
118
+ * @param x an array
119
+ * @returns 0, 1, ..., |x|-1
120
+ */ export declare function ikeys<T>(x: T[]): IterableIterator<number>;
121
+ /**
122
+ * Get all values.
123
+ * @param x an array
124
+ * @returns [v₀, v₁, ...] | vᵢ = x[i]
125
+ */ export declare function values<T>(x: T[]): T[];
126
+ /**
127
+ * List all values.
128
+ * @param x an array
129
+ * @returns v₀, v₁, ... | vᵢ = x[i]
130
+ */ export declare function ivalues<T>(x: T[]): IterableIterator<T>;
131
+ /**
132
+ * Obtain all index-value pairs.
133
+ * @param x an array
134
+ * @returns [[0, v₀], [1, v₁], ...] | vᵢ = x[i]
135
+ */ export declare function entries<T>(x: T[]): Entries<T>;
136
+ /**
137
+ * List all index-value pairs.
138
+ * @param x an array
139
+ * @returns [0, v₀], [1, v₁], ... | vᵢ = x[i]
140
+ */ export declare function ientries<T>(x: T[]): IEntries<T>;
141
+ /**
142
+ * Get zero-based index for an element in array.
143
+ * @param x an array
144
+ * @param i ±index
145
+ * @returns i' | x[i'] = x[i]; i' ∈ [0, |x|]
146
+ */ export declare function index<T>(x: T[], i: number): number;
147
+ /**
148
+ * Get zero-based index range for part of array.
149
+ * @param x an array
150
+ * @param i begin ±index [0]
151
+ * @param I end ±index (exclusive) [|x|]
152
+ * @returns [i', I'] | i' ≤ I'; i', I' ∈ [0, |x|]
153
+ */ export declare function indexRange<T>(x: T[], i?: number, I?: number): [number, number];
154
+ /**
155
+ * Check if an array is empty.
156
+ * @param x an array
157
+ * @returns |x| = 0?
158
+ */ export declare function isEmpty<T>(x: T[]): boolean;
159
+ /**
160
+ * Find the length of an array.
161
+ * @param x an array
162
+ * @param i begin ±index [0]
163
+ * @param I end ±index (exclusive) [X]
164
+ * @returns |x[i..I]|
165
+ */ export declare function length<T>(x: T[], i?: number, I?: number): number;
166
+ export { length as size };
167
+ /**
168
+ * Resize an array to given length!
169
+ * @param x an array
170
+ * @param n new length
171
+ * @param vd default value
172
+ * @returns resized x
173
+ */ export declare function resize$<T>(x: T[], n: number, vd: T): T[];
174
+ /**
175
+ * Remove all elements from an array!
176
+ * @param x an array (updated!)
177
+ * @returns cleared x
178
+ */ export declare function clear$<T>(x: T[]): T[];
179
+ /**
180
+ * Get value at index.
181
+ * @param x an array
182
+ * @param i index
183
+ * @returns x[i]
184
+ */ export declare function get<T>(x: T[], i: number): T;
185
+ export { get as at };
186
+ /**
187
+ * Get values at indices.
188
+ * @param x an array
189
+ * @param is indices
190
+ * @returns [x[i₀], x[i₁], ...] | [i₀, i₁, ...] = is
191
+ */ export declare function getAll<T>(x: T[], is: number[]): T[];
192
+ /**
193
+ * Get value at path in a nested array.
194
+ * @param x a nested array
195
+ * @param p path
196
+ * @returns x[i₀][i₁][...] | [i₀, i₁, ...] = p
197
+ */ export declare function getPath(x: unknown[], p: number[]): unknown;
198
+ /**
199
+ * Check if nested array has a path.
200
+ * @param x a nested array
201
+ * @param p path
202
+ * @returns x[i₀][i₁][...] exists? | [i₀, i₁, ...] = p
203
+ */ export declare function hasPath(x: unknown[], p: number[]): boolean;
204
+ /**
205
+ * Set value at index.
206
+ * @param x an array
207
+ * @param i index
208
+ * @param v value
209
+ * @returns x' | x' = x; x'[i] = v
210
+ */ export declare function set<T>(x: T[], i: number, v: T): T[];
211
+ export { set as with };
212
+ /**
213
+ * Set value at index!
214
+ * @param x an array (updated!)
215
+ * @param i index
216
+ * @param v value
217
+ * @returns x | x[i] = v
218
+ */ export declare function set$<T>(x: T[], i: number, v: T): T[];
219
+ /**
220
+ * Set value at path in a nested array!
221
+ * @param x a nested array (updated!)
222
+ * @param p path
223
+ * @param v value
224
+ * @returns x | x[i₀][i₁][...] = v; [i₀, i₁, ...] = p
225
+ */ export declare function setPath$(x: unknown[], p: number[], v: unknown): unknown[];
226
+ /**
227
+ * Exchange two values.
228
+ * @param x an array
229
+ * @param i an index
230
+ * @param j another index
231
+ * @returns x' | x' = x; x'[i] = x[j]; x'[j] = x[i]
232
+ */ export declare function swap<T>(x: T[], i: number, j: number): T[];
233
+ /**
234
+ * Exchange two values!
235
+ * @param x an array (updated!)
236
+ * @param i an index
237
+ * @param j another index
238
+ * @returns x | x[i] ⇔ x[j]
239
+ */ export declare function swap$<T>(x: T[], i: number, j: number): T[];
240
+ /**
241
+ * Exchange two ranges of values.
242
+ * @param x an array
243
+ * @param i begin index of first range
244
+ * @param I end index of first range (exclusive)
245
+ * @param j begin index of second range
246
+ * @param J end index of second range (exclusive)
247
+ * @returns x' | x' = x; x'[i..I] = x[j..J]; x'[j..J] = x[i..I]
248
+ */ export declare function swapRanges<T>(x: T[], i: number, I: number, j: number, J: number): T[];
249
+ /**
250
+ * Exchange two ranges of values!
251
+ * @param x an array (updated!)
252
+ * @param i begin index of first range
253
+ * @param I end index of first range (exclusive)
254
+ * @param j begin index of second range
255
+ * @param J end index of second range (exclusive)
256
+ * @returns x | x[i..I] ⇔ x[j..J]
257
+ */ export declare function swapRanges$<T>(x: T[], i: number, I: number, j: number, J: number): T[];
258
+ /**
259
+ * Remove value at index.
260
+ * @param x an array
261
+ * @param i index
262
+ * @returns x[0..i] ⧺ x[i+1..]
263
+ */ export declare function remove<T>(x: T[], i: number): T[];
264
+ /**
265
+ * Remove value at index!
266
+ * @param x an array (updated!)
267
+ * @param i index
268
+ * @returns x \\: [i]
269
+ */ export declare function remove$<T>(x: T[], i: number): T[];
270
+ /**
271
+ * Remove value at path in a nested array!
272
+ * @param x a nested array (updated!)
273
+ * @param p path
274
+ * @returns x \\: [i₀][i₁][...] | [i₀, i₁, ...] = p
275
+ */ export declare function removePath$(x: unknown[], p: number[]): unknown[];
276
+ /**
277
+ * Examine if array is sorted.
278
+ * @param x an array
279
+ * @param fc compare function (a, b)
280
+ * @param fm map function (v, i, x)
281
+ * @returns x is sorted?
282
+ */ export declare function isSorted<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
283
+ /**
284
+ * Examine if array has an unsorted value.
285
+ * @param x an array
286
+ * @param fc compare function (a, b)
287
+ * @param fm map function (v, i, x)
288
+ * @returns x is not sorted?
289
+ */ export declare function hasUnsortedValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
290
+ /**
291
+ * Find first index of an unsorted value.
292
+ * @param x an array
293
+ * @param fc compare function (a, b)
294
+ * @param fm map function (v, i, x)
295
+ * @returns index of first unsorted value, -1 if sorted
296
+ */ export declare function searchUnsortedValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
297
+ /**
298
+ * Arrange values in order.
299
+ * @param x an array
300
+ * @param fc compare function (a, b)
301
+ * @param fm map function (v, i, x)
302
+ * @param fs swap function (x, i, j)
303
+ * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
304
+ */ export declare function sort<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
305
+ export { sort as toSorted };
306
+ /**
307
+ * Arrange values in order!
308
+ * @param x an array (updated!)
309
+ * @param fc compare function (a, b)
310
+ * @param fm map function (v, i, x)
311
+ * @param fs swap function (x, i, j)
312
+ * @returns x | x[i] ≤ x[j] ∀ i ≤ j
313
+ */ export declare function sort$<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
314
+ /**
315
+ * Arrange a range of values in order.
316
+ * @param x an array
317
+ * @param i begin index
318
+ * @param I end index (exclusive)
319
+ * @param fc compare function (a, b)
320
+ * @param fm map function (v, i, x)
321
+ * @param fs swap function (x, i, j)
322
+ * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
323
+ */ export declare function rangedSort<T, U = T>(x: T[], i: number, I: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
324
+ /**
325
+ * Arrange a range of values in order!
326
+ * @param x an array (updated!)
327
+ * @param i begin index
328
+ * @param I end index (exclusive)
329
+ * @param fc compare function (a, b)
330
+ * @param fm map function (v, i, x)
331
+ * @param fs swap function (x, i, j)
332
+ * @returns x | x[i] ≤ x[j] ∀ i ≤ j
333
+ */ export declare function rangedSort$<T, U = T>(x: T[], i: number, I: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
334
+ /**
335
+ * Partially arrange values in order.
336
+ * @param x an array
337
+ * @param n minimum number of values to sort
338
+ * @param fc compare function (a, b)
339
+ * @param fm map function (v, i, x)
340
+ * @param fs swap function (x, i, j)
341
+ * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
342
+ */ export declare function partialSort<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
343
+ /**
344
+ * Partially arrange values in order!
345
+ * @param x an array (updated!)
346
+ * @param n minimum number of values to sort
347
+ * @param fc compare function (a, b)
348
+ * @param fm map function (v, i, x)
349
+ * @param fs swap function (x, i, j)
350
+ * @returns x | x[i] ≤ x[j] ∀ i ≤ j
351
+ */ export declare function partialSort$<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
352
+ /**
353
+ * Partially arrange a range of values in order.
354
+ * @param x an array
355
+ * @param i begin index
356
+ * @param I end index (exclusive)
357
+ * @param n minimum number of values to sort
358
+ * @param fc compare function (a, b)
359
+ * @param fm map function (v, i, x)
360
+ * @param fs swap function (x, i, j)
361
+ * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j
362
+ */ export declare function rangedPartialSort<T, U = T>(x: T[], i: number, I: number, n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
363
+ /**
364
+ * Partially arrange a range of values in order!
365
+ * @param x an array (updated!)
366
+ * @param i begin index
367
+ * @param I end index (exclusive)
368
+ * @param n minimum number of values to sort
369
+ * @param fc compare function (a, b)
370
+ * @param fm map function (v, i, x)
371
+ * @param fs swap function (x, i, j)
372
+ * @returns x | x[i] ≤ x[j] ∀ i ≤ j
373
+ */ export declare function rangedPartialSort$<T, U = T>(x: T[], i: number, I: number, n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | null): T[];
374
+ /**
375
+ * Find first smallest value.
376
+ * @param x an array
377
+ * @param fc compare function (a, b)
378
+ * @param fm map function (v, i, x)
379
+ * @returns v | v ≤ vᵢ; vᵢ ∈ x
380
+ */ export declare function minimum<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T;
381
+ export { minimum as min };
382
+ /**
383
+ * Find first smallest entry.
384
+ * @param x an array
385
+ * @param fc compare function (a, b)
386
+ * @param fm map function (v, i, x)
387
+ * @returns [min_index, min_value]
388
+ */ export declare function minimumEntry<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T];
389
+ export { minimumEntry as minEntry };
390
+ /**
391
+ * Find first largest value.
392
+ * @param x an array
393
+ * @param fc compare function (a, b)
394
+ * @param fm map function (v, i, x)
395
+ * @returns v | v ≥ vᵢ; vᵢ ∈ x
396
+ */ export declare function maximum<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T;
397
+ export { maximum as max };
398
+ /**
399
+ * Find first largest entry.
400
+ * @param x an array
401
+ * @param fc compare function (a, b)
402
+ * @param fm map function (v, i, x)
403
+ * @returns [max_index, max_value]
404
+ */ export declare function maximumEntry<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T];
405
+ export { maximumEntry as maxEntry };
406
+ /**
407
+ * Find smallest and largest values.
408
+ * @param x an array
409
+ * @param fc compare function (a, b)
410
+ * @param fm map function (v, i, x)
411
+ * @returns [min_value, max_value]
412
+ */ export declare function range<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [T | undefined, T | undefined];
413
+ /**
414
+ * Find smallest and largest entries.
415
+ * @param x an array
416
+ * @param fc compare function (a, b)
417
+ * @param fm map function (v, i, x)
418
+ * @returns [min_entry, max_entry]
419
+ */ export declare function rangeEntries<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [[number, T | undefined], [number, T | undefined]];
420
+ /**
421
+ * Find smallest values.
422
+ * @param x an array
423
+ * @param n number of values
424
+ * @param fc compare function (a, b)
425
+ * @param fm map function (v, i, x)
426
+ * @returns n smallest values in ascending order
427
+ */ export declare function minimums<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
428
+ /**
429
+ * Find smallest entries.
430
+ * @param x an array
431
+ * @param n number of values
432
+ * @param fc compare function (a, b)
433
+ * @param fm map function (v, i, x)
434
+ * @returns n smallest entries in ascending order
435
+ */ export declare function minimumEntries<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T][];
436
+ /**
437
+ * Find largest values.
438
+ * @param x an array
439
+ * @param n number of values
440
+ * @param fc compare function (a, b)
441
+ * @param fm map function (v, i, x)
442
+ * @returns n largest values in descending order
443
+ */ export declare function maximums<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
444
+ /**
445
+ * Find largest entries.
446
+ * @param x an array
447
+ * @param n number of values
448
+ * @param fc compare function (a, b)
449
+ * @param fm map function (v, i, x)
450
+ * @returns n largest entries in descending order
451
+ */ export declare function maximumEntries<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T][];
452
+ /**
453
+ * Find first index of minimum value.
454
+ * @param x an array
455
+ * @param fc compare function (a, b)
456
+ * @param fm map function (v, i, x)
457
+ * @returns first index of minimum value, -1 if empty
458
+ */ export declare function searchMinimumValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
459
+ /**
460
+ * Find first index of maximum value.
461
+ * @param x an array
462
+ * @param fc compare function (a, b)
463
+ * @param fm map function (v, i, x)
464
+ * @returns first index of maximum value, -1 if empty
465
+ */ export declare function searchMaximumValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
466
+ /**
467
+ * Find indices of minimum values.
468
+ * @param x an array
469
+ * @param n number of values
470
+ * @param fc compare function (a, b)
471
+ * @param fm map function (v, i, x)
472
+ * @returns indices of minimum values in ascending order
473
+ */ export declare function searchMinimumValues<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
474
+ /**
475
+ * Find indices of maximum values.
476
+ * @param x an array
477
+ * @param n number of values
478
+ * @param fc compare function (a, b)
479
+ * @param fm map function (v, i, x)
480
+ * @returns indices of maximum values in descending order
481
+ */ export declare function searchMaximumValues<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
482
+ /**
483
+ * Examine if two arrays are equal.
484
+ * @param x an array
485
+ * @param y another array
486
+ * @param fc compare function (a, b)
487
+ * @param fm map function (v, i, x)
488
+ * @returns x = y?
489
+ */ export declare function isEqual<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
490
+ /**
491
+ * Compare two arrays (lexicographically).
492
+ * @param x an array
493
+ * @param y another array
494
+ * @param fc compare function (a, b)
495
+ * @param fm map function (v, i, x)
496
+ * @returns x<y: -ve, x=y: 0, x>y: +ve
497
+ */ export declare function compare<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
498
+ /**
499
+ * Get first value.
500
+ * @param x an array
501
+ * @param vd default value
502
+ * @returns x[0] || vd
503
+ */ export declare function head<T>(x: T[], vd?: T): T | undefined;
504
+ export { head as front };
505
+ export { head as first };
506
+ /**
507
+ * Get values except first.
508
+ * @param x an array
509
+ * @returns x[1..|x|]
510
+ */ export declare function tail<T>(x: T[]): T[];
511
+ /**
512
+ * Get values except last.
513
+ * @param x an array
514
+ * @returns x[0..|x|-1]
515
+ */ export declare function init<T>(x: T[]): T[];
516
+ /**
517
+ * Get last value.
518
+ * @param x an array
519
+ * @param vd default value
520
+ * @returns x[|x|-1] || vd
521
+ */ export declare function last<T>(x: T[], vd?: T): T | undefined;
522
+ export { last as back };
523
+ /**
524
+ * Get values from middle.
525
+ * @param x an array
526
+ * @param i begin index
527
+ * @param n number of values [1]
528
+ * @returns x[i..i+n]
529
+ */ export declare function middle<T>(x: T[], i: number, n?: number): T[];
530
+ /**
531
+ * Get part of an array.
532
+ * @param x an array
533
+ * @param i begin index [0]
534
+ * @param I end index [|x|]
535
+ * @returns x[i..I]
536
+ */ export declare function slice<T>(x: T[], i?: number, I?: number): T[];
537
+ /**
538
+ * Get part of an array!
539
+ * @param x an array (updated!)
540
+ * @param i begin index [0]
541
+ * @param I end index [|x|]
542
+ * @returns x = x[i..I]
543
+ */ export declare function slice$<T>(x: T[], i?: number, I?: number): T[];
544
+ /**
545
+ * Check if array has a value.
546
+ * @param x an array
547
+ * @param v search value
548
+ * @param i begin index [0]
549
+ * @returns v ∈ x[i..]?
550
+ */ export declare function includes<T>(x: T[], v: T, i?: number): boolean;
551
+ /**
552
+ * Examine if array has a value.
553
+ * @param x an array
554
+ * @param v search value
555
+ * @param fc compare function (a, b)
556
+ * @param fm map function (v, i, x)
557
+ * @returns v ∈ x?
558
+ */ export declare function hasValue<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
559
+ /**
560
+ * Find first index of a value.
561
+ * @param x an array
562
+ * @param v search value
563
+ * @param fc compare function (a, b)
564
+ * @param fm map function (v, i, x)
565
+ * @returns first index of value, -1 if not found
566
+ */ export declare function searchValue<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
567
+ /**
568
+ * Find last index of a value.
569
+ * @param x an array
570
+ * @param v search value
571
+ * @param fc compare function (a, b)
572
+ * @param fm map function (v, i, x)
573
+ * @returns last index of value, -1 if not found
574
+ */ export declare function searchValueRight<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
575
+ /**
576
+ * Find indices of value.
577
+ * @param x an array
578
+ * @param v search value
579
+ * @param fc compare function (a, b)
580
+ * @param fm map function (v, i, x)
581
+ * @returns indices of value
582
+ */ export declare function searchValueAll<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
583
+ /**
584
+ * Find first index of an adjacent duplicate value.
585
+ * @param x an array
586
+ * @param fc compare function (a, b)
587
+ * @param fm map function (v, i, x)
588
+ * @returns index of first adjacent duplicate value, -1 if none
589
+ */ export declare function searchAdjacentDuplicateValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
590
+ export { searchAdjacentDuplicateValue as searchAdjacentDuplicate };
591
+ /**
592
+ * Find first index where two arrays differ.
593
+ * @param x an array
594
+ * @param y another array
595
+ * @param fc compare function (a, b)
596
+ * @param fm map function (v, i, x)
597
+ * @returns first index where x[i] ≠ y[i], or -1
598
+ */ export declare function searchMismatchedValue<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
599
+ export { searchMismatchedValue as searchMismatch };
600
+ /**
601
+ * Examine if array starts with a prefix.
602
+ * @param x an array
603
+ * @param y search prefix
604
+ * @param fc compare function (a, b)
605
+ * @param fm map function (v, i, x)
606
+ * @returns x[0..|y|] = y?
607
+ */ export declare function hasPrefix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
608
+ export { hasPrefix as startsWith };
609
+ /**
610
+ * Examine if array ends with a suffix.
611
+ * @param x an array
612
+ * @param y search suffix
613
+ * @param fc compare function (a, b)
614
+ * @param fm map function (v, i, x)
615
+ * @returns x[|x|-|y|..] = y?
616
+ */ export declare function hasSuffix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
617
+ export { hasSuffix as endsWith };
618
+ /**
619
+ * Examine if array contains an infix.
620
+ * @param x an array
621
+ * @param y search infix
622
+ * @param fc compare function (a, b)
623
+ * @param fm map function (v, i, x)
624
+ * @returns x[i..I] = y for some i, I?
625
+ */ export declare function hasInfix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
626
+ /**
627
+ * Examine if array has a subsequence.
628
+ * @param x an array
629
+ * @param y search subsequence
630
+ * @param fc compare function (a, b)
631
+ * @param fm map function (v, i, x)
632
+ * @returns x[i₀] ⧺ x[i₁] ⧺ ... = y, for some i₀, i₁, ...? | i₀ < i₁ < ...
633
+ */ export declare function hasSubsequence<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
634
+ /**
635
+ * Examine if array has a permutation.
636
+ * @param x an array
637
+ * @param y search permutation
638
+ * @param fc map function (v, i, x)
639
+ * @param fm compare function (a, b)
640
+ * @returns x contains a shuffled version of y?
641
+ */ export declare function hasPermutation<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
642
+ /**
643
+ * Obtain all possible prefixes.
644
+ * @param x an array
645
+ * @param n number of values [-1 ⇒ any]
646
+ * @returns [[], x[..1], x[..2], ...] if n<0; [x[..n]] otherwise
647
+ */ export declare function prefixes<T>(x: T[], n?: number): T[][];
648
+ /**
649
+ * List all possible prefixes.
650
+ * @param x an array
651
+ * @param n number of values [-1 ⇒ any]
652
+ * @returns [], x[..1], x[..2], ... if n<0; x[..n] otherwise
653
+ */ export declare function iprefixes<T>(x: T[], n?: number): IterableIterator<T[]>;
654
+ /**
655
+ * Obtain all possible suffixes.
656
+ * @param x an array
657
+ * @param n number of values [-1 ⇒ any]
658
+ * @returns [x[0..], x[1..], x[2..], ...] if n<0; [x[-n..]] otherwise
659
+ */ export declare function suffixes<T>(x: T[], n?: number): T[][];
660
+ /**
661
+ * List all possible suffixes.
662
+ * @param x an array
663
+ * @param n number of values [-1 ⇒ any]
664
+ * @returns x[0..], x[1..], x[2..], ... if n<0; x[-n..] otherwise
665
+ */ export declare function isuffixes<T>(x: T[], n?: number): IterableIterator<T[]>;
666
+ /**
667
+ * Obtain all possible infixes.
668
+ * @param x an array
669
+ * @param n number of values [-1 ⇒ any]
670
+ * @returns [[], x[0..1], x[0..2], ..., x[1..2], ...] if n<0; [only of length n] otherwise
671
+ */ export declare function infixes<T>(x: T[], n?: number): T[][];
672
+ /**
673
+ * List all possible infixes.
674
+ * @param x an array
675
+ * @param n number of values [-1 ⇒ any]
676
+ * @returns [], x[0..1], x[0..2], ..., x[1..2], ... if n<0; only of length n otherwise
677
+ */ export declare function iinfixes<T>(x: T[], n?: number): IterableIterator<T[]>;
678
+ /**
679
+ * Obtain all possible subsequences.
680
+ * @param x an array
681
+ * @param n number of values [-1 ⇒ any]
682
+ * @returns [elements selected by bit from 0..2^|x|] if n<0; [only of length n] otherwise
683
+ */ export declare function subsequences<T>(x: T[], n?: number): T[][];
684
+ /**
685
+ * List all possible subsequences.
686
+ * @param x an array
687
+ * @param n number of values [-1 ⇒ any]
688
+ * @returns elements selected by bit from 0..2^|x| if n<0; only of length n otherwise
689
+ */ export declare function isubsequences<T>(x: T[], n?: number): IterableIterator<T[]>;
690
+ /**
691
+ * Obtain all possible permutations.
692
+ * @param x an array
693
+ * @param n number of values [-1 ⇒ any]
694
+ * @returns [[], arrangements of length 1, of length 2, ...] if n<0; [only of length n] otherwise
695
+ */ export declare function permutations<T>(x: T[], n?: number): T[][];
696
+ /**
697
+ * List all possible permutations.
698
+ * @param x an array
699
+ * @param n number of values [-1 ⇒ any]
700
+ * @returns [], arrangements of length 1, of length 2, ... if n<0; only of length n otherwise
701
+ */ export declare function ipermutations<T>(x: T[], n?: number): IterableIterator<T[]>;
702
+ /**
703
+ * Find first index of an infix.
704
+ * @param x an array
705
+ * @param y search infix
706
+ * @param fc compare function (a, b)
707
+ * @param fm map function (v, i, x)
708
+ * @returns first i | x[i..i+|y|] = y else -1
709
+ */ export declare function searchInfix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
710
+ /**
711
+ * Find last index of an infix.
712
+ * @param x an array
713
+ * @param y search infix
714
+ * @param fc compare function (a, b)
715
+ * @param fm map function (v, i, x)
716
+ * @returns first i | x[i..i+|y|] = y else -1
717
+ */ export declare function searchInfixRight<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
718
+ /**
719
+ * Find indices of an infix.
720
+ * @param x an array
721
+ * @param y search infix
722
+ * @param fc compare function (a, b)
723
+ * @param fm map function (v, i, x)
724
+ * @returns i₀, i₁, ... | x[j..j+|y|] = y; j ∈ [i₀, i₁, ...]
725
+ */ export declare function searchInfixAll<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
726
+ /**
727
+ * Find first index of a subsequence.
728
+ * @param x an array
729
+ * @param y search subsequence
730
+ * @param fc compare function (a, b)
731
+ * @param fm map function (v, i, x)
732
+ * @returns begin index of subsequence, -1 if not found
733
+ */ export declare function searchSubsequence<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
734
+ /**
735
+ * Pick an arbitrary value.
736
+ * @param x an array
737
+ * @param fr random number generator ([0, 1))
738
+ * @returns x[i] | i ∈ 0..|x|
739
+ */ export declare function randomValue<T>(x: T[], fr?: ReadFunction<number> | null): T;
740
+ export { randomValue as value };
741
+ /**
742
+ * Pick an arbitrary prefix.
743
+ * @param x an array
744
+ * @param n number of values [-1 ⇒ any]
745
+ * @param fr random number generator ([0, 1))
746
+ * @returns x[..i] if n<0; x[..n] otherwise | i ∈ 0..|x|
747
+ */ export declare function randomPrefix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
748
+ export { randomPrefix as prefix };
749
+ /**
750
+ * Pick an arbitrary suffix.
751
+ * @param x an array
752
+ * @param n number of values [-1 ⇒ any]
753
+ * @param fr random number generator ([0, 1))
754
+ * @returns x[|x|-i..] if n<0; x[|x|-n..] otherwise | i ∈ 0..|x|
755
+ */ export declare function randomSuffix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
756
+ export { randomSuffix as suffix };
757
+ /**
758
+ * Pick an arbitrary infix.
759
+ * @param x an array
760
+ * @param n number of values [-1 ⇒ any]
761
+ * @param fr random number generator ([0, 1))
762
+ * @returns x[i..j] if n<0; x[i..i+n] otherwise | i, j ∈ 0..|x|
763
+ */ export declare function randomInfix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
764
+ export { randomInfix as infix };
765
+ /**
766
+ * Pick an arbitrary subsequence.
767
+ * @param x an array
768
+ * @param n number of values [-1 ⇒ any]
769
+ * @param fr random number generator ([0, 1))
770
+ * @returns x[i, j, ...] | [i, j, ...] = is; |is| = |x| if n<0 else n
771
+ */ export declare function randomSubsequence<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
772
+ export { randomSubsequence as subsequence };
773
+ /**
774
+ * Pick an arbitrary permutation.
775
+ * @param x an array
776
+ * @param n number of values [-1 ⇒ any]
777
+ * @param fr random number generator ([0, 1))
778
+ * @returns x' | x' = x; values are randomly shuffled
779
+ */ export declare function randomPermutation<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[] | null;
780
+ export { randomPermutation as permutation };
781
+ /**
782
+ * Pick an arbitrary permutation!
783
+ * @param x an array (updated!)
784
+ * @param n number of values [-1 ⇒ any]
785
+ * @param fr random number generator ([0, 1))
786
+ * @returns x | values are randomly shuffled
787
+ */ export declare function randomPermutation$<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];
788
+ export { randomPermutation$ as permutation$ };
789
+ export { randomPermutation$ as permute$ };
790
+ export { randomPermutation$ as shuffle$ };
791
+ /**
792
+ * Find first value passing a test.
793
+ * @param x an array
794
+ * @param ft test function (v, i, x)
795
+ * @returns first v | ft(v) = true; v ∈ x
796
+ */ export declare function find<T>(x: T[], ft: TestFunction<T>): T;
797
+ /**
798
+ * Find last value passing a test.
799
+ * @param x an array
800
+ * @param ft test function (v, i, x)
801
+ * @returns last v | ft(v) = true; v ∈ x
802
+ */ export declare function findRight<T>(x: T[], ft: TestFunction<T>): T;
803
+ /**
804
+ * Keep first n values only.
805
+ * @param x an array
806
+ * @param n number of values [1]
807
+ * @returns x[0..n]
808
+ */ export declare function take<T>(x: T[], n?: number): T[];
809
+ export { take as left };
810
+ /**
811
+ * Keep last n values only.
812
+ * @param x an array
813
+ * @param n number of values [1]
814
+ * @returns x[0..n]
815
+ */ export declare function takeRight<T>(x: T[], n?: number): T[];
816
+ export { takeRight as right };
817
+ /**
818
+ * Keep values from left, while a test passes.
819
+ * @param x an array
820
+ * @param ft test function (v, i, x)
821
+ * @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false
822
+ */ export declare function takeWhile<T>(x: T[], ft: TestFunction<T>): T[];
823
+ /**
824
+ * Keep values from right, while a test passes.
825
+ * @param x an array
826
+ * @param ft test function (v, i, x)
827
+ * @returns x[T..] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false
828
+ */ export declare function takeWhileRight<T>(x: T[], ft: TestFunction<T>): T[];
829
+ /**
830
+ * Discard first n values only.
831
+ * @param x an array
832
+ * @param n number of values [1]
833
+ * @returns x[n..]
834
+ */ export declare function drop<T>(x: T[], n?: number): T[];
835
+ /**
836
+ * Discard last n values only.
837
+ * @param x an array
838
+ * @param n number of values [1]
839
+ * @returns x[0..-n]
840
+ */ export declare function dropRight<T>(x: T[], n?: number): T[];
841
+ /**
842
+ * Discard values from left, while a test passes.
843
+ * @param x an array
844
+ * @param ft test function (v, i, x)
845
+ * @returns x[T..] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false
846
+ */ export declare function dropWhile<T>(x: T[], ft: TestFunction<T>): T[];
847
+ /**
848
+ * Discard values from right, while a test passes.
849
+ * @param x an array
850
+ * @param ft test function (v, i, x)
851
+ * @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false
852
+ */ export declare function dropWhileRight<T>(x: T[], ft: TestFunction<T>): T[];
853
+ /**
854
+ * Scan from left, while a test passes.
855
+ * @param x an array
856
+ * @param ft test function (v, i, x)
857
+ * @returns first index where test fails
858
+ */ export declare function scanWhile<T>(x: T[], ft: TestFunction<T>): number;
859
+ /**
860
+ * Scan from right, while a test passes.
861
+ * @param x an array
862
+ * @param ft test function (v, i, x)
863
+ * @returns first index where test passes till end
864
+ */ export declare function scanWhileRight<T>(x: T[], ft: TestFunction<T>): number;
865
+ /**
866
+ * Scan from left, until a test passes.
867
+ * @param x an array
868
+ * @param ft test function (v, i, x)
869
+ * @returns first index where test passes
870
+ */ export declare function scanUntil<T>(x: T[], ft: TestFunction<T>): number;
871
+ /**
872
+ * Scan from right, until a test passes.
873
+ * @param x an array
874
+ * @param ft test function (v, i, x)
875
+ * @returns first index where test fails till end
876
+ */ export declare function scanUntilRight<T>(x: T[], ft: TestFunction<T>): number;
877
+ /**
878
+ * Find first index of a value.
879
+ * @param x an array
880
+ * @param v search value
881
+ * @param i begin index [0]
882
+ * @returns index of v in x[i..] if found else -1
883
+ */ export declare function indexOf<T>(x: T[], v: T, i?: number): number;
884
+ /**
885
+ * Find last index of a value.
886
+ * @param x an array
887
+ * @param v search value
888
+ * @param i begin index [|x|-1]
889
+ * @returns last index of v in x[0..i] if found else -1
890
+ */ export declare function lastIndexOf<T>(x: T[], v: T, i?: number): number;
891
+ /**
892
+ * Find index of first value passing a test.
893
+ * @param x an array
894
+ * @param ft test function (v, i, x)
895
+ * @returns first index of value, -1 if not found
896
+ */ export declare function search<T>(x: T[], ft: TestFunction<T>): number;
897
+ export { search as findIndex };
898
+ /**
899
+ * Find index of last value passing a test.
900
+ * @param x an array
901
+ * @param ft test function (v, i, x)
902
+ * @returns last index of value, -1 if not found
903
+ */ export declare function searchRight<T>(x: T[], ft: TestFunction<T>): number;
904
+ export { searchRight as findLastIndex };
905
+ /**
906
+ * Find indices of values passing a test.
907
+ * @param x an array
908
+ * @param ft test function (v, i, x)
909
+ * @returns indices of value
910
+ */ export declare function searchAll<T>(x: T[], ft: TestFunction<T>): number[];
911
+ /**
912
+ * Call a function for each value.
913
+ * @param x an array
914
+ * @param fp process function (v, i, x)
915
+ */ export declare function forEach<T>(x: T[], fp: ProcessFunction<T>): void;
916
+ /**
917
+ * Examine if any value satisfies a test.
918
+ * @param x an array
919
+ * @param ft test function (v, i, x)
920
+ * @returns true if ft(vᵢ) = true for some vᵢ ∈ x
921
+ */ export declare function some<T>(x: T[], ft?: TestFunction<T> | null): boolean;
922
+ export { some as anyOf };
923
+ /**
924
+ * Examine if all values satisfy a test.
925
+ * @param x an array
926
+ * @param ft test function (v, i, x)
927
+ * @returns true if ft(vᵢ) = true for all vᵢ ∈ x
928
+ */ export declare function every<T>(x: T[], ft?: TestFunction<T> | null): boolean;
929
+ export { every as allOf };
930
+ /**
931
+ * Transform values of an array.
932
+ * @param x an array
933
+ * @param fm map function (v, i, x)
934
+ * @returns [fm(v₀), fm(v₁), ...] | vᵢ ∈ x
935
+ */ export declare function map<T, U = T>(x: T[], fm: MapFunction<T, T | U>): (T | U)[];
936
+ /**
937
+ * Transform values of an array!
938
+ * @param x an array (updated!)
939
+ * @param fm map function (v, i, x)
940
+ * @returns x = [fm(v₀), fm(v₁), ...]; vᵢ ∈ x
941
+ */ export declare function map$<T>(x: T[], fm: MapFunction<T, T>): T[];
942
+ /**
943
+ * Reduce values of array to a single value.
944
+ * @param x an array
945
+ * @param fr reduce function (acc, v, i, x)
946
+ * @param acc initial value
947
+ * @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given
948
+ */ export declare function reduce<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): T | U;
949
+ /**
950
+ * Reduce values from right, to a single value.
951
+ * @param x an array
952
+ * @param fr reduce function (acc, v, i, x)
953
+ * @param acc initial value
954
+ * @returns fr(fr(acc, vₓ₋₀), vₓ₋₁)... | fr(acc, vₓ₋₀) = vₓ₋₀ if acc not given
955
+ */ export declare function reduceRight<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): T | U;
956
+ /**
957
+ * Keep values which pass a test.
958
+ * @param x an array
959
+ * @param ft test function (v, i, x)
960
+ * @returns [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x
961
+ */ export declare function filter<T>(x: T[], ft: TestFunction<T>): T[];
962
+ export { filter as findAll };
963
+ /**
964
+ * Keep values which pass a test!
965
+ * @param x an array (updated!)
966
+ * @param ft test function (v, i, x)
967
+ * @returns x = [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x
968
+ */ export declare function filter$<T>(x: T[], ft: TestFunction<T>): T[];
969
+ /**
970
+ * Keep values at given indices.
971
+ * @param x an array
972
+ * @param is indices
973
+ * @returns v₀, v₁, ... | vᵢ = x[i]; i ∈ is
974
+ */ export declare function filterAt<T>(x: T[], is: number[]): T[];
975
+ /**
976
+ * Discard values which pass a test.
977
+ * @param x an array
978
+ * @param ft test function (v, i, x)
979
+ * @returns [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x
980
+ */ export declare function reject<T>(x: T[], ft: TestFunction<T>): T[];
981
+ /**
982
+ * Discard values which pass a test!
983
+ * @param x an array (updated!)
984
+ * @param ft test function (v, i, x)
985
+ * @returns x = [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x
986
+ */ export declare function reject$<T>(x: T[], ft: TestFunction<T>): T[];
987
+ /**
988
+ * Discard values at given indices.
989
+ * @param x an array
990
+ * @param is indices
991
+ * @returns [v₀, v₁, ...] | vᵢ = x[i]; i ∉ is
992
+ */ export declare function rejectAt<T>(x: T[], is: number[]): T[];
993
+ /**
994
+ * Flatten nested array to given depth.
995
+ * @param x a nested array
996
+ * @param n maximum depth [-1 ⇒ all]
997
+ * @param fm map function (v, i, x)
998
+ * @param ft flatten test function (v, i, x) [is]
999
+ * @returns flat iterable
1000
+ */ export declare function flat(x: unknown[], n?: number, fm?: MapFunction<unknown, unknown> | null, ft?: TestFunction<unknown> | null): unknown[];
1001
+ /**
1002
+ * Flatten nested array, based on map function.
1003
+ * @param x an array
1004
+ * @param fm map function (v, i, x)
1005
+ * @param ft flatten test function (v, i, x) [is]
1006
+ * @returns flat iterable
1007
+ */ export declare function flatMap(x: unknown[], fm?: MapFunction<unknown, unknown> | null, ft?: TestFunction<unknown> | null): unknown[];
1008
+ /**
1009
+ * Perform exclusive prefix scan from left to right.
1010
+ * @param x an array
1011
+ * @param fr reduce function (acc, v, i, x)
1012
+ * @param acc initial value
1013
+ * @returns [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
1014
+ */ export declare function exclusiveScan<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc: T | U): (T | U)[];
1015
+ /**
1016
+ * Perform exclusive prefix scan from left to right!
1017
+ * @param x an array (updated!)
1018
+ * @param fr reduce function (acc, v, i, x)
1019
+ * @param acc initial value
1020
+ * @returns x = [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
1021
+ */ export declare function exclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[];
1022
+ /**
1023
+ * Perform inclusive prefix scan from left to right.
1024
+ * @param x an array
1025
+ * @param fr reduce function (acc, v, i, x)
1026
+ * @param acc initial value
1027
+ * @returns [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
1028
+ */ export declare function inclusiveScan<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): (T | U)[];
1029
+ export { inclusiveScan as accumulate };
1030
+ /**
1031
+ * Perform inclusive prefix scan from left to right!
1032
+ * @param x an array (updated!)
1033
+ * @param fr reduce function (acc, v, i, x)
1034
+ * @param acc initial value
1035
+ * @returns x = [fr(acc, v₀), fr(fr(acc, v₀), v₁)...]
1036
+ */ export declare function inclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[];
1037
+ /**
1038
+ * Combine adjacent values of an array.
1039
+ * @param x an array
1040
+ * @param fc combine function (u, v)
1041
+ * @param acc initial value
1042
+ * @returns [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x
1043
+ */ export declare function adjacentCombine<T>(x: T[], fc: CombineFunction<T>, acc: T): T[];
1044
+ /**
1045
+ * Combine adjacent values of an array!
1046
+ * @param x an array (updated!)
1047
+ * @param fc combine function (u, v)
1048
+ * @param acc initial value
1049
+ * @returns x = [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x
1050
+ */ export declare function adjacentCombine$<T>(x: T[], fc: CombineFunction<T>, acc: T): T[];
1051
+ /**
1052
+ * Place a separator between every value.
1053
+ * @param x an array
1054
+ * @param v separator
1055
+ * @returns [x[0], v, x[1], v, ..., x[|x|-1]]
1056
+ */ export declare function intersperse<T>(x: T[], v: T): T[];
1057
+ /**
1058
+ * Estimate new values between existing ones.
1059
+ * @param x an array
1060
+ * @param fc combine function (a, b)
1061
+ * @returns [x[0], fc(x[0], x[1]), x[1], fc(x[1], x[2]), ..., x[|x|-1]]
1062
+ */ export declare function interpolate<T>(x: T[], fc: CombineFunction<T>): T[];
1063
+ /**
1064
+ * Place values of an array between another.
1065
+ * @param x an array
1066
+ * @param y another array
1067
+ * @param m number of values from x [1]
1068
+ * @param n number of values from y [1]
1069
+ * @param s step size for x [m]
1070
+ * @param t step size for y [n]
1071
+ * @returns x[0..m] ⧺ y[0..n] ⧺ x[s..s+m] ⧺ y[t..t+n] ⧺ ... ⧺ x[k*s..|x|-1] | k ∈ W
1072
+ */ export declare function intermix<T>(x: T[], y: T[], m?: number, n?: number, s?: number, t?: number): T[];
1073
+ /**
1074
+ * Place values from iterables alternately.
1075
+ * @param xs arrays
1076
+ * @returns [x₀[0], x₁[0], ..., x₀[1], x₁[0], ...] | [x₀, x₁, ...] = xs
1077
+ */ export declare function interleave<T>(xs: T[][]): T[];
1078
+ /**
1079
+ * Combine values from arrays.
1080
+ * @param xs arrays
1081
+ * @param fm map function (vs, i)
1082
+ * @param fe end function (dones) [some]
1083
+ * @param vd default value
1084
+ * @returns [fm([x₀[0], x₁[0], ...]), fm([x₀[1], x₁[1], ...]), ...]
1085
+ */ export declare function zip<T, U = T[]>(xs: T[][], fm?: MapFunction<T[], T[] | U> | null, fe?: EndFunction | null, vd?: T): (T[] | U)[];
1086
+ /**
1087
+ * Fill with given value.
1088
+ * @param x an array
1089
+ * @param v value
1090
+ * @param i begin index [0]
1091
+ * @param I end index [|x|]
1092
+ * @returns x' | x' = x; x'[i..I] = v
1093
+ */ export declare function fill<T>(x: T[], v: T, i?: number, I?: number): T[];
1094
+ /**
1095
+ * Fill with given value!
1096
+ * @param x an array (updated!)
1097
+ * @param v value
1098
+ * @param i begin index [0]
1099
+ * @param I end index [|x|]
1100
+ * @returns x | x[i..I] = v
1101
+ */ export declare function fill$<T>(x: T[], v: T, i?: number, I?: number): T[];
1102
+ /**
1103
+ * Add value to the end.
1104
+ * @param x an array
1105
+ * @param vs values to add
1106
+ * @returns x ⧺ vs
1107
+ */ export declare function push<T>(x: T[], ...vs: T[]): T[];
1108
+ export { push as pushBack };
1109
+ export { push as append };
1110
+ /**
1111
+ * Add values to the end!
1112
+ * @param x an array (updated!)
1113
+ * @param vs values to add
1114
+ * @returns x = x ⧺ vs
1115
+ */ export declare function push$<T>(x: T[], ...vs: T[]): T[];
1116
+ export { push$ as pushBack$ };
1117
+ export { push$ as append$ };
1118
+ /**
1119
+ * Remove last value.
1120
+ * @param x an array
1121
+ * @returns x[0..|x|-1]
1122
+ */ export declare function pop<T>(x: T[]): T[];
1123
+ export { pop as popBack };
1124
+ /**
1125
+ * Remove last value!
1126
+ * @param x an array (updated!)
1127
+ * @returns x = x[0..|x|-1]
1128
+ */ export declare function pop$<T>(x: T[]): T[];
1129
+ export { pop as popBack$ };
1130
+ /**
1131
+ * Remove first value.
1132
+ * @param x an array
1133
+ * @returns x[1..]
1134
+ */ export declare function shift<T>(x: T[]): T[];
1135
+ export { shift as popFront };
1136
+ /**
1137
+ * Remove first value!
1138
+ * @param x an array (updated!)
1139
+ * @returns x = x[1..]
1140
+ */ export declare function shift$<T>(x: T[]): T[];
1141
+ export { shift$ as popFront$ };
1142
+ /**
1143
+ * Add values to the start.
1144
+ * @param x an array
1145
+ * @param vs values to add
1146
+ * @returns vs ⧺ x
1147
+ */ export declare function unshift<T>(x: Iterable<T>, ...vs: T[]): T[];
1148
+ export { unshift as pushFront };
1149
+ export { unshift as prepend };
1150
+ /**
1151
+ * Add values to the start!
1152
+ * @param x an array (updated!)
1153
+ * @param vs values to add
1154
+ * @returns x = vs ⧺ x
1155
+ */ export declare function unshift$<T>(x: T[], ...vs: T[]): T[];
1156
+ export { unshift$ as pushFront$ };
1157
+ export { unshift$ as prepend$ };
1158
+ /**
1159
+ * Copy part of array to another.
1160
+ * @param x target array
1161
+ * @param y source array
1162
+ * @param j write index [0]
1163
+ * @param i read begin index [0]
1164
+ * @param I read end index [|x|]
1165
+ * @returns x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]
1166
+ */ export declare function copy<T>(x: T[], y: T[], j?: number, i?: number, I?: number): T[];
1167
+ /**
1168
+ * Copy part of array to another!
1169
+ * @param x target array (updated!)
1170
+ * @param y source array
1171
+ * @param j write index [0]
1172
+ * @param i read begin index [0]
1173
+ * @param I read end index [|x|]
1174
+ * @returns x = x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]
1175
+ */ export declare function copy$<T>(x: T[], y: T[], j?: number, i?: number, I?: number): T[];
1176
+ /**
1177
+ * Copy part of array within.
1178
+ * @param x an array
1179
+ * @param j write index [0]
1180
+ * @param i read begin index [0]
1181
+ * @param I read end index [|x|]
1182
+ * @returns x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]
1183
+ */ export declare function copyWithin<T>(x: T[], j?: number, i?: number, I?: number): T[];
1184
+ /**
1185
+ * Copy part of array within!
1186
+ * @param x an array (updated!)
1187
+ * @param j write index [0]
1188
+ * @param i read begin index [0]
1189
+ * @param I read end index [|x|]
1190
+ * @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]
1191
+ */ export declare function copyWithin$<T>(x: T[], j?: number, i?: number, I?: number): T[];
1192
+ /**
1193
+ * Move part of array within.
1194
+ * @param x an array
1195
+ * @param j write index [0]
1196
+ * @param i read begin index [0]
1197
+ * @param I read end index [|x|]
1198
+ * @returns x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..]
1199
+ */ export declare function moveWithin<T>(x: T[], j?: number, i?: number, I?: number): T[];
1200
+ /**
1201
+ * Move part of array within!
1202
+ * @param x an array (updated!)
1203
+ * @param j write ±index [0]
1204
+ * @param i read begin ±index [0]
1205
+ * @param I read end ±index [|x|]
1206
+ * @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..]
1207
+ */ export declare function moveWithin$<T>(x: T[], j?: number, i?: number, I?: number): T[];
1208
+ /**
1209
+ * Remove or replace existing values.
1210
+ * @param x an array
1211
+ * @param i remove ±index
1212
+ * @param n number of values to remove [rest]
1213
+ * @param vs values to insert
1214
+ * @returns x[0..i] ⧺ vs ⧺ x[i+n..]
1215
+ */ export declare function splice<T>(x: T[], i: number, n?: number, ...vs: T[]): T[];
1216
+ export { splice as toSpliced };
1217
+ /**
1218
+ * Remove or replace existing values!
1219
+ * @param x an array (updated!)
1220
+ * @param i remove ±index
1221
+ * @param n number of values to remove [rest]
1222
+ * @param vs values to insert
1223
+ * @returns x = x[0..i] ⧺ vs ⧺ x[i+n..]
1224
+ */ export declare function splice$<T>(x: T[], i: number, n?: number, ...vs: T[]): T[];
1225
+ /**
1226
+ * Count values which satisfy a test.
1227
+ * @param x an array
1228
+ * @param ft test function (v, i, x)
1229
+ * @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x
1230
+ */ export declare function count<T>(x: T[], ft: TestFunction<T>): number;
1231
+ /**
1232
+ * Count occurrences of each distinct value.
1233
+ * @param x an array
1234
+ * @param fm map function (v, i, x)
1235
+ * @returns Map \{value ⇒ count\}
1236
+ */ export declare function countEach<T, U = T>(x: T[], fm?: MapFunction<T, T | U> | null): Map<T | U, number>;
1237
+ export { countEach as countAs };
1238
+ /**
1239
+ * Segregate values by test result.
1240
+ * @param x an array
1241
+ * @param ft test function (v, i, x)
1242
+ * @returns [satisfies, doesnt]
1243
+ */ export declare function partition<T>(x: T[], ft: TestFunction<T>): [T[], T[]];
1244
+ /**
1245
+ * Segregate each distinct value.
1246
+ * @param x an array
1247
+ * @param fm map function (v, i, x)
1248
+ * @returns Map \{key ⇒ values\}
1249
+ */ export declare function partitionEach<T, U = T>(x: T[], fm?: MapFunction<T, T | U> | null): Map<T | U, T[]>;
1250
+ export { partitionEach as groupToMap };
1251
+ export { partitionEach as partitionAs };
1252
+ /**
1253
+ * Break array considering test as separator.
1254
+ * @param x an array
1255
+ * @param ft test function (v, i, x)
1256
+ * @returns [x[j..k], x[l..m], ...] | ft(x[i]) = true; i = 0..j / k..l / ...
1257
+ */ export declare function split<T>(x: T[], ft: TestFunction<T>): T[][];
1258
+ /**
1259
+ * Break array considering indices as separator.
1260
+ * @param x an array
1261
+ * @param is indices (sorted)
1262
+ * @returns [x[j..k], x[l..m], ...] | ft(x[i]) = true; i = 0..j / k..l / ...; i ∈ is
1263
+ */ export declare function splitAt<T>(x: T[], is: number[]): T[][];
1264
+ /**
1265
+ * Break array when test passes.
1266
+ * @param x an array
1267
+ * @param ft test function (v, i, x)
1268
+ * @returns [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...
1269
+ */ export declare function cut<T>(x: T[], ft: TestFunction<T>): T[][];
1270
+ /**
1271
+ * Break array after test passes.
1272
+ * @param x an array
1273
+ * @param ft test function (v, i, x)
1274
+ * @returns [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...
1275
+ */ export declare function cutRight<T>(x: T[], ft: TestFunction<T>): T[][];
1276
+ /**
1277
+ * Break array at given indices.
1278
+ * @param x an array
1279
+ * @param is split ±indices (left to right)
1280
+ * @returns [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is
1281
+ */ export declare function cutAt<T>(x: T[], is: number[]): T[][];
1282
+ /**
1283
+ * Break array after given indices.
1284
+ * @param x an array
1285
+ * @param is split ±indices (left to right)
1286
+ * @returns [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is
1287
+ */ export declare function cutAtRight<T>(x: T[], is: number[]): T[][];
1288
+ /**
1289
+ * Keep similar values together and in order.
1290
+ * @param x an array
1291
+ * @param fc compare function (a, b)
1292
+ * @param fm map function (v, i, x)
1293
+ * @returns [x[0..k], x[k..l], ...] | fc(x[i], x[j]) = 0; i, j = 0..k / k..l / ...
1294
+ */ export declare function group<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[][];
1295
+ /**
1296
+ * Break array into chunks of given size.
1297
+ * @param x an array
1298
+ * @param n chunk size [1]
1299
+ * @param s chunk step [n]
1300
+ * @returns x[0..n] ⧺ x[s..s+n] ⧺ x[2s..2s+n] ⧺ ...
1301
+ */ export declare function chunk<T>(x: T[], n?: number, s?: number): T[][];
1302
+ /**
1303
+ * Append values from arrays.
1304
+ * @param xs arrays
1305
+ * @returns x₀ ⧺ x₁ ⧺ ... | [x₀, x₁, ...] = xs
1306
+ */ export declare function concat<T>(...xs: T[][]): T[];
1307
+ /**
1308
+ * Append values from arrays!
1309
+ * @param x an array (updated!)
1310
+ * @param ys arrays to append
1311
+ * @returns x = x ⧺ y₀ ⧺ y₁ ⧺ ...] | [y₀, y₁, ...] = ys
1312
+ */ export declare function concat$<T>(x: T[], ...ys: Iterable<T>[]): T[];
1313
+ /**
1314
+ * Join values together into a string.
1315
+ * @param x an array
1316
+ * @param sep separator [,]
1317
+ * @returns "$\{v₀\}$\{sep\}$\{v₁\}..." | vᵢ ∈ x
1318
+ */ export declare function join<T>(x: T[], sep?: string): string;
1319
+ /**
1320
+ * Obtain values that cycle through array.
1321
+ * @param x an array
1322
+ * @param i begin ±index [0]
1323
+ * @param n number of values [|x|]
1324
+ */ export declare function cycle<T>(x: T[], i?: number, n?: number): T[];
1325
+ /**
1326
+ * Repeat an array given times.
1327
+ * @param x an array
1328
+ * @param n times [1]
1329
+ * @returns x ⧺ x ⧺ ...(n times)
1330
+ */ export declare function repeat<T>(x: T[], n?: number): T[];
1331
+ /**
1332
+ * Reverse the values.
1333
+ * @param x an array
1334
+ * @returns [x[|x|-1], x[|x|-2], ..., x[1], x[0]]
1335
+ */ export declare function reverse<T>(x: T[]): T[];
1336
+ export { reverse as toReversed };
1337
+ /**
1338
+ * Reverse the values!
1339
+ * @param x an array (updated!)
1340
+ * @returns x = [x[|x|-1], x[|x|-2], ..., x[1], x[0]]
1341
+ */ export declare function reverse$<T>(x: T[]): T[];
1342
+ /**
1343
+ * Rotate values in array.
1344
+ * @param x an array
1345
+ * @param n rotate amount (+ve: left, -ve: right) [0]
1346
+ * @returns x[n..] ⧺ x[0..n]
1347
+ */ export declare function rotate<T>(x: T[], n?: number): T[];
1348
+ /**
1349
+ * Rotate values in array!
1350
+ * @param x an array (updated!)
1351
+ * @param n rotate amount (+ve: left, -ve: right) [0]
1352
+ * @returns x = x[n..] ⧺ x[0..n]
1353
+ */ export declare function rotate$<T>(x: T[], n?: number): T[];
1354
+ /**
1355
+ * Examine if there are no duplicate values.
1356
+ * @param x an array
1357
+ * @param fc compare function (a, b)
1358
+ * @param fm map function (v, i, x)
1359
+ * @returns ∀ vᵢ, vⱼ ∈ x, is vᵢ ≠ vⱼ?
1360
+ */ export declare function isUnique<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
1361
+ /**
1362
+ * Examine if arrays have no value in common.
1363
+ * @param x an array
1364
+ * @param y another array
1365
+ * @param fc compare function (a, b)
1366
+ * @param fm map function (v, i, x)
1367
+ * @returns x ∩ y = Φ?
1368
+ */ export declare function isDisjoint<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
1369
+ /**
1370
+ * Remove duplicate values.
1371
+ * @param x an array
1372
+ * @param fc compare function (a, b)
1373
+ * @param fm map function (v, i, x)
1374
+ * @returns v₀, v₁, ... | vᵢ ∈ x; vᵢ ≠ vⱼ ∀ i, j
1375
+ */ export declare function unique<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
1376
+ /**
1377
+ * Obtain values present in any array.
1378
+ * @param x an array
1379
+ * @param y another array
1380
+ * @param fc compare function (a, b)
1381
+ * @param fm map function (v, i, x)
1382
+ * @returns x ∪ y = \{v | v ∈ x or v ∈ y\}
1383
+ */ export declare function union<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
1384
+ /**
1385
+ * Obtain values present in any array!
1386
+ * @param x an array (updated!)
1387
+ * @param y another array
1388
+ * @param fc compare function (a, b)
1389
+ * @param fm map function (v, i, x)
1390
+ * @returns x = x ∪ y = \{v | v ∈ x or v ∈ y\}
1391
+ */ export declare function union$<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
1392
+ /**
1393
+ * Obtain values present in both arrays.
1394
+ * @param x an array
1395
+ * @param y another array
1396
+ * @param fc compare function (a, b)
1397
+ * @param fm map function (v, i, x)
1398
+ * @returns x ∩ y = \{v | v ∈ x, v ∈ y\}
1399
+ */ export declare function intersection<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
1400
+ /**
1401
+ * Obtain values not present in another array.
1402
+ * @param x an array
1403
+ * @param y another array
1404
+ * @param fc compare function (a, b)
1405
+ * @param fm map function (v, i, x)
1406
+ * @returns x - y = \{v | v ∈ x, v ∉ y\}
1407
+ */ export declare function difference<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
1408
+ /**
1409
+ * Obtain values not present in both arrays.
1410
+ * @param x an array
1411
+ * @param y another array
1412
+ * @param fc compare function (a, b)
1413
+ * @param fm map function (v, i, x)
1414
+ * @returns x-y ∪ y-x
1415
+ */ export declare function symmetricDifference<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
1416
+ /**
1417
+ * Obtain cartesian product of arrays.
1418
+ * @param xs arrays
1419
+ * @param fm map function (vs, i)
1420
+ * @returns x₀ × x₁ × ... = \{[v₀, v₁, ...] | v₀ ∈ x₀, v₁ ∈ x₁, ...] \}
1421
+ */ export declare function cartesianProduct<T, U = T>(xs: T[][], fm?: MapFunction<T[], T[] | U> | null): (T[] | U)[];