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

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.test.ts ADDED
@@ -0,0 +1,2054 @@
1
+ import {
2
+ assert,
3
+ assertEquals,
4
+ assertLessOrEqual,
5
+ assertGreater
6
+ } from "@std/assert";
7
+ import {
8
+ is,
9
+ keys,
10
+ values,
11
+ entries,
12
+ from,
13
+ from$,
14
+ fromRange,
15
+ fromInvocation,
16
+ fromApplication,
17
+ compare,
18
+ isEqual,
19
+ index,
20
+ indexRange,
21
+ length,
22
+ isEmpty,
23
+ get,
24
+ getAll,
25
+ getPath,
26
+ hasPath,
27
+ set,
28
+ set$,
29
+ setPath$,
30
+ swap,
31
+ swap$,
32
+ remove,
33
+ remove$,
34
+ removePath$,
35
+ count,
36
+ countEach,
37
+ min,
38
+ minEntry,
39
+ max,
40
+ maxEntry,
41
+ range,
42
+ rangeEntries,
43
+ slice,
44
+ slice$,
45
+ head,
46
+ last,
47
+ tail,
48
+ init,
49
+ middle,
50
+ take,
51
+ takeRight,
52
+ takeWhile,
53
+ takeWhileRight,
54
+ drop,
55
+ dropRight,
56
+ dropWhile,
57
+ dropWhileRight,
58
+ prefixes,
59
+ suffixes,
60
+ infixes,
61
+ subsequences,
62
+ permutations,
63
+ randomValue,
64
+ randomPrefix,
65
+ randomSuffix,
66
+ randomInfix,
67
+ randomSubsequence,
68
+ randomPermutation,
69
+ randomPermutation$,
70
+ includes,
71
+ indexOf,
72
+ lastIndexOf,
73
+ find,
74
+ findRight,
75
+ scanWhile,
76
+ scanWhileRight,
77
+ scanUntil,
78
+ scanUntilRight,
79
+ search,
80
+ searchRight,
81
+ searchAll,
82
+ searchValue,
83
+ searchValueRight,
84
+ searchValueAll,
85
+ searchMinimumValues,
86
+ searchInfix,
87
+ searchInfixRight,
88
+ searchInfixAll,
89
+ searchSubsequence,
90
+ hasValue,
91
+ hasPrefix,
92
+ hasSuffix,
93
+ hasInfix,
94
+ hasSubsequence,
95
+ hasPermutation,
96
+ forEach,
97
+ some,
98
+ every,
99
+ map,
100
+ map$,
101
+ reduce,
102
+ reduceRight,
103
+ filter,
104
+ filter$,
105
+ filterAt,
106
+ reject,
107
+ reject$,
108
+ rejectAt,
109
+ inclusiveScan,
110
+ flat,
111
+ flatMap,
112
+ zip,
113
+ fill,
114
+ fill$,
115
+ sort,
116
+ sort$,
117
+ push,
118
+ push$,
119
+ pop,
120
+ pop$,
121
+ shift,
122
+ shift$,
123
+ unshift,
124
+ unshift$,
125
+ copy,
126
+ copy$,
127
+ copyWithin,
128
+ copyWithin$,
129
+ moveWithin,
130
+ moveWithin$,
131
+ splice,
132
+ splice$,
133
+ split,
134
+ splitAt,
135
+ cut,
136
+ cutRight,
137
+ cutAt,
138
+ cutAtRight,
139
+ group,
140
+ partition,
141
+ partitionEach,
142
+ chunk,
143
+ cycle,
144
+ repeat,
145
+ reverse,
146
+ reverse$,
147
+ rotate,
148
+ rotate$,
149
+ intersperse,
150
+ interpolate,
151
+ intermix,
152
+ interleave,
153
+ concat,
154
+ concat$,
155
+ join,
156
+ isUnique,
157
+ isDisjoint,
158
+ unique,
159
+ union,
160
+ union$,
161
+ intersection,
162
+ difference,
163
+ symmetricDifference,
164
+ cartesianProduct,
165
+ type EndFunction,
166
+ } from "./index.ts";
167
+
168
+
169
+
170
+
171
+ // ABOUT
172
+ // -----
173
+
174
+ Deno.test("is", () => {
175
+ let a;
176
+ a = is([1, 2]);
177
+ assertEquals(a, true);
178
+ a = is([]);
179
+ assertEquals(a, true);
180
+ a = is(new Set([1, 2]));
181
+ assertEquals(a, false);
182
+ });
183
+
184
+
185
+ Deno.test("keys", () => {
186
+ const a = keys([1, 2, 3]);
187
+ assertEquals([...a], [0, 1, 2]);
188
+ });
189
+
190
+
191
+ Deno.test("values", () => {
192
+ const a = values([1, 2, 3]);
193
+ assertEquals([...a], [1, 2, 3]);
194
+ });
195
+
196
+
197
+ Deno.test("entries", () => {
198
+ const a = entries(["A", "B", "C"]);
199
+ assertEquals([...a], [[0, "A"], [1, "B"], [2, "C"]]);
200
+ });
201
+
202
+
203
+
204
+
205
+ // GENERATE
206
+ // --------
207
+
208
+ Deno.test("from", () => {
209
+ const a = from([1, 2].values());
210
+ assertEquals(a, [1, 2]);
211
+ });
212
+
213
+
214
+ Deno.test("from$", () => {
215
+ const a = from$([1, 2].values());
216
+ assertEquals(a, [1, 2]);
217
+ });
218
+
219
+
220
+ Deno.test("fromRange", () => {
221
+ let a;
222
+ a = fromRange(0, 4);
223
+ assertEquals(a, [ 0, 1, 2, 3 ]);
224
+ a = fromRange(0, 8, 2);
225
+ assertEquals(a, [0, 2, 4, 6]);
226
+ });
227
+
228
+
229
+ Deno.test("fromInvocation", () => {
230
+ let n = 0;
231
+ const a = fromInvocation(() => ++n, 4);
232
+ assertEquals(a, [1, 2, 3, 4]);
233
+ });
234
+
235
+
236
+ Deno.test("fromApplication", () => {
237
+ let a;
238
+ a = fromApplication(v => v+2, 2, 4);
239
+ assertEquals(a, [2, 4, 6, 8]);
240
+ a = fromApplication(v => v*2, 2, 4);
241
+ assertEquals(a, [2, 4, 8, 16]);
242
+ });
243
+
244
+
245
+
246
+
247
+ // COMPARE
248
+ // -------
249
+
250
+ Deno.test("compare", () => {
251
+ let a;
252
+ const x = [1, 2];
253
+ let y = [1, 2, 3];
254
+ a = compare(x, y);
255
+ assertLessOrEqual(a, 0);
256
+ y = [1, 2];
257
+ a = compare(x, y);
258
+ assertEquals(a, 0);
259
+ y = [1, -2];
260
+ a = compare(x, y);
261
+ assertGreater(a, 0);
262
+ a = compare(x, y, (a, b) => Math.abs(a) - Math.abs(b));
263
+ assertEquals(a, 0);
264
+ a = compare(x, y, null, v => Math.abs(v));
265
+ assertEquals(a, 0);
266
+ });
267
+
268
+
269
+ Deno.test("isEqual", () => {
270
+ let a;
271
+ const x = [1, 2];
272
+ a = isEqual(x, [1, 2]);
273
+ assertEquals(a, true);
274
+ a = isEqual(x, [11, 12]);
275
+ assertEquals(a, false);
276
+ a = isEqual(x, [11, 12], (a, b) => (a % 10) - (b % 10));
277
+ assertEquals(a, true);
278
+ a = isEqual(x, [11, 12], null, v => v % 10);
279
+ assertEquals(a, true);
280
+ });
281
+
282
+
283
+
284
+
285
+ // LENGTH
286
+ // ------
287
+
288
+ Deno.test("index", () => {
289
+ let a;
290
+ const x = [2, 4, 6, 8];
291
+ a = index(x, 1);
292
+ assertEquals(a, 1);
293
+ a = index(x, -1);
294
+ assertEquals(a, 3);
295
+ a = index(x, -10);
296
+ assertEquals(a, 0);
297
+ });
298
+
299
+
300
+ Deno.test("indexRange", () => {
301
+ let a;
302
+ const x = [2, 4, 6, 8];
303
+ a = indexRange(x, 1);
304
+ assertEquals(a, [1, 4]);
305
+ a = indexRange(x, 1, -1);
306
+ assertEquals(a, [1, 3]);
307
+ a = indexRange(x, 1, -10);
308
+ assertEquals(a, [1, 1]);
309
+ });
310
+
311
+
312
+ Deno.test("length", () => {
313
+ let a;
314
+ const x = [2, 4, 6, 8];
315
+ a = length(x);
316
+ assertEquals(a, 4);
317
+ a = length(x, 1);
318
+ assertEquals(a, 3);
319
+ a = length(x, 1, 3);
320
+ assertEquals(a, 2);
321
+ });
322
+
323
+
324
+ Deno.test("isEmpty", () => {
325
+ let a, x: number[];
326
+ x = [1, 2, 3];
327
+ a = isEmpty(x);
328
+ assertEquals(a, false);
329
+ x = [];
330
+ a = isEmpty(x);
331
+ assertEquals(a, true);
332
+ });
333
+
334
+
335
+
336
+
337
+ // GET/SET
338
+ // -------
339
+
340
+ Deno.test("get", () => {
341
+ let a;
342
+ const x = [2, 4, 6, 8];
343
+ a = get(x, 1);
344
+ assertEquals(a, 4);
345
+ a = get(x, 3);
346
+ assertEquals(a, 8);
347
+ });
348
+
349
+
350
+ Deno.test("getAll", () => {
351
+ let a;
352
+ const x = [2, 4, 6, 8];
353
+ a = getAll(x, [1, 2]);
354
+ assertEquals(a, [ 4, 6 ]);
355
+ a = getAll(x, [1, 3]);
356
+ assertEquals(a, [ 4, 8 ]);
357
+ });
358
+
359
+
360
+ Deno.test("getPath", () => {
361
+ let a;
362
+ const x = [[2, 4], 6, 8];
363
+ a = getPath(x, [1]);
364
+ assertEquals(a, 6);
365
+ a = getPath(x, [0, 1]);
366
+ assertEquals(a, 4);
367
+ a = getPath(x, [0, 1, 2]);
368
+ assertEquals(a, undefined);
369
+ });
370
+
371
+
372
+ Deno.test("hasPath", () => {
373
+ let a;
374
+ const x = [[2, 4], 6, 8];
375
+ a = hasPath(x, [1]);
376
+ assertEquals(a, true);
377
+ a = hasPath(x, [0, 1]);
378
+ assertEquals(a, true);
379
+ a = hasPath(x, [0, 1, 2]);
380
+ assertEquals(a, false);
381
+ });
382
+
383
+
384
+ Deno.test("set", () => {
385
+ let a;
386
+ const x = [2, 4, 6, 8];
387
+ a = set(x, 1, 40);
388
+ assertEquals(a, [2, 40, 6, 8]);
389
+ a = set(x, 3, 80);
390
+ assertEquals(a, [2, 4, 6, 80]);
391
+ });
392
+
393
+
394
+ Deno.test("set$", () => {
395
+ let a, x;
396
+ x = [2, 4, 6, 8];
397
+ a = set$(x, 1, 40);
398
+ assertEquals(a, [2, 40, 6, 8]);
399
+ assertEquals(x, [2, 40, 6, 8]);
400
+ x = [2, 4, 6, 8];
401
+ a = set$(x, 3, 80);
402
+ assertEquals(a, [2, 4, 6, 80]);
403
+ });
404
+
405
+
406
+ Deno.test("setPath$", () => {
407
+ let a;
408
+ const x = [[2, 4], 6, 8];
409
+ a = setPath$(x, [1], 60);
410
+ assertEquals(a, [[2, 4], 60, 8]);
411
+ assertEquals(x, [[2, 4], 60, 8]);
412
+ a = setPath$(x, [0, 1], 40);
413
+ assertEquals(a, [[2, 40], 60, 8]);
414
+ a = setPath$(x, [0, 1, 2], 100);
415
+ assertEquals(a, [[2, 40], 60, 8]); // (path not present, no effect)
416
+ });
417
+
418
+
419
+ Deno.test("swap", () => {
420
+ let a;
421
+ const x = [1, 2, 3, 4];
422
+ a = swap(x, 0, 1);
423
+ assertEquals(a, [2, 1, 3, 4]);
424
+ a = swap(x, 0, 3);
425
+ assertEquals(a, [4, 2, 3, 1]);
426
+ });
427
+
428
+
429
+ Deno.test("swap$", () => {
430
+ let a, x;
431
+ x = [1, 2, 3, 4];
432
+ a = swap$(x, 0, 1);
433
+ assertEquals(a, [2, 1, 3, 4]);
434
+ assertEquals(x, [2, 1, 3, 4]);
435
+ x = [1, 2, 3, 4];
436
+ a = swap$(x, 0, 3);
437
+ assertEquals(a, [4, 2, 3, 1]);
438
+ });
439
+
440
+
441
+ Deno.test("remove", () => {
442
+ const x = [1, 2, 3, 4, 5];
443
+ const a = remove(x, 2);
444
+ assertEquals(a, [ 1, 2, 4, 5 ]);
445
+ });
446
+
447
+
448
+ Deno.test("remove$", () => {
449
+ const x = [1, 2, 3, 4, 5];
450
+ const a = remove$(x, 2);
451
+ assertEquals(a, [1, 2, 4, 5]);
452
+ assertEquals(x, [1, 2, 4, 5]);
453
+ });
454
+
455
+
456
+ Deno.test("removePath$", () => {
457
+ let a;
458
+ const x = [[2, 4], 6, 8];
459
+ a = removePath$(x, [1]);
460
+ assertEquals(a, [[2, 4 ], 8]);
461
+ assertEquals(x, [[2, 4 ], 8]);
462
+ a = removePath$(x, [0, 1]);
463
+ assertEquals(a, [[2 ], 8]);
464
+ a = removePath$(x, [0, 1, 2]);
465
+ assertEquals(a, [[2 ], 8]); // (path not present, no effect)
466
+ });
467
+
468
+
469
+
470
+
471
+ // PROPERTY
472
+ // --------
473
+
474
+ Deno.test("count", () => {
475
+ let a;
476
+ const x = [1, 1, 2, 2, 4];
477
+ a = count(x, v => v % 2 === 1);
478
+ assertEquals(a, 2);
479
+ a = count(x, v => v % 2 === 0);
480
+ assertEquals(a, 3);
481
+ });
482
+
483
+
484
+ Deno.test("countEach", () => {
485
+ let a, x;
486
+ x = [1, 1, 2, 2, 4];
487
+ a = countEach(x);
488
+ assertEquals(a, new Map([[1, 2], [2, 2], [4, 1]]));
489
+ x = [1, 2, 3, 4];
490
+ a = countEach(x, v => v % 2);
491
+ assertEquals(a, new Map([[1, 2], [0, 2]]));
492
+ });
493
+
494
+
495
+ Deno.test("min", () => {
496
+ let a;
497
+ const x = [1, 2, -3, -4];
498
+ a = min(x);
499
+ assertEquals(a, -4);
500
+ a = min(x, (a, b) => Math.abs(a) - Math.abs(b));
501
+ assertEquals(a, 1);
502
+ a = min(x, null, v => Math.abs(v));
503
+ assertEquals(a, 1);
504
+ });
505
+
506
+
507
+ Deno.test("minEntry", () => {
508
+ let a;
509
+ const x = [1, 2, -3, -4];
510
+ a = minEntry(x);
511
+ assertEquals(a, [3, -4]);
512
+ a = minEntry(x, (a, b) => Math.abs(a) - Math.abs(b));
513
+ assertEquals(a, [0, 1]);
514
+ a = minEntry(x, null, v => Math.abs(v));
515
+ assertEquals(a, [0, 1]);
516
+ });
517
+
518
+
519
+ Deno.test("max", () => {
520
+ let a;
521
+ const x = [1, 2, -3, -4];
522
+ a = max(x);
523
+ assertEquals(a, 2);
524
+ a = max(x, (a, b) => Math.abs(a) - Math.abs(b));
525
+ assertEquals(a, -4);
526
+ a = max(x, null, v => Math.abs(v));
527
+ assertEquals(a, -4);
528
+ });
529
+
530
+
531
+ Deno.test("maxEntry", () => {
532
+ let a;
533
+ const x = [1, 2, -3, -4];
534
+ a = maxEntry(x);
535
+ assertEquals(a, [1, 2]);
536
+ a = maxEntry(x, (a, b) => Math.abs(a) - Math.abs(b));
537
+ assertEquals(a, [3, -4]);
538
+ a = maxEntry(x, null, v => Math.abs(v));
539
+ assertEquals(a, [3, -4]);
540
+ });
541
+
542
+
543
+ Deno.test("range", () => {
544
+ let a;
545
+ const x = [1, 2, -3, -4];
546
+ a = range(x);
547
+ assertEquals(a, [-4, 2]);
548
+ a = range(x, (a, b) => Math.abs(a) - Math.abs(b));
549
+ assertEquals(a, [1, -4]);
550
+ a = range(x, null, v => Math.abs(v));
551
+ assertEquals(a, [1, -4]);
552
+ });
553
+
554
+
555
+ Deno.test("rangeEntries", () => {
556
+ let a;
557
+ const x = [1, 2, -3, -4];
558
+ a = rangeEntries(x);
559
+ assertEquals(a, [[3, -4], [1, 2]]);
560
+ a = rangeEntries(x, (a, b) => Math.abs(a) - Math.abs(b));
561
+ assertEquals(a, [[0, 1], [3, -4]]);
562
+ a = rangeEntries(x, null, v => Math.abs(v));
563
+ assertEquals(a, [[0, 1], [3, -4]]);
564
+ });
565
+
566
+
567
+
568
+
569
+ // PART
570
+ // ----
571
+
572
+ Deno.test("slice", () => {
573
+ let a;
574
+ const x = [1, 2, 3, 4, 5];
575
+ a = slice(x, 2);
576
+ assertEquals(a, [3, 4, 5]);
577
+ a = slice(x, 2, 4);
578
+ assertEquals(a, [3, 4]);
579
+ a = slice(x, -3, -1);
580
+ assertEquals(a, [3, 4]);
581
+ });
582
+
583
+
584
+ Deno.test("slice$", () => {
585
+ let a, x;
586
+ x = [1, 2, 3, 4, 5];
587
+ a = slice$(x, 2);
588
+ assertEquals(a, [3, 4, 5]);
589
+ assertEquals(x, [3, 4, 5]);
590
+ x = [1, 2, 3, 4, 5];
591
+ a = slice$(x, 2, 4);
592
+ assertEquals(a, [3, 4]);
593
+ x = [1, 2, 3, 4, 5];
594
+ a = slice$(x, -3, -1);
595
+ assertEquals(a, [3, 4]);
596
+ });
597
+
598
+
599
+ Deno.test("head", () => {
600
+ let a;
601
+ a = head([1, 2, 3]);
602
+ assertEquals(a, 1);
603
+ a = head([], -1);
604
+ assertEquals(a, -1);
605
+ });
606
+
607
+
608
+ Deno.test("last", () => {
609
+ let a;
610
+ a = last([1, 2, 3]);
611
+ assertEquals(a, 3);
612
+ a = last([], -1);
613
+ assertEquals(a, -1);
614
+ });
615
+
616
+
617
+ Deno.test("tail", () => {
618
+ let a;
619
+ a = tail([1, 2, 3]);
620
+ assertEquals(a, [2, 3]);
621
+ a = tail([1]);
622
+ assertEquals(a, []);
623
+ });
624
+
625
+
626
+ Deno.test("init", () => {
627
+ let a;
628
+ a = init([1, 2, 3]);
629
+ assertEquals(a, [1, 2]);
630
+ a = init([1]);
631
+ assertEquals(a, []);
632
+ });
633
+
634
+
635
+ Deno.test("middle", () => {
636
+ let a;
637
+ const x = [1, 2, 3];
638
+ a = middle(x, 1, 1);
639
+ assertEquals(a, [2]);
640
+ a = middle(x, 1, 2);
641
+ assertEquals(a, [2, 3]);
642
+ });
643
+
644
+
645
+ Deno.test("take", () => {
646
+ let a;
647
+ const x = [1, 2, 3, 4, 5];
648
+ a = take(x, 2);
649
+ assertEquals(a, [1, 2]);
650
+ a = take(x, 3);
651
+ assertEquals(a, [1, 2, 3]);
652
+ });
653
+
654
+
655
+ Deno.test("takeRight", () => {
656
+ let a;
657
+ const x = [1, 2, 3, 4, 5];
658
+ a = takeRight(x, 2);
659
+ assertEquals(a, [4, 5]);
660
+ a = takeRight(x, 3);
661
+ assertEquals(a, [3, 4, 5]);
662
+ });
663
+
664
+
665
+ Deno.test("takeWhile", () => {
666
+ let a;
667
+ const x = [1, 2, 3, 4, 5];
668
+ a = takeWhile(x, v => v < 3);
669
+ assertEquals(a, [1, 2]);
670
+ a = takeWhile(x, v => v < 4);
671
+ assertEquals(a, [1, 2, 3]);
672
+ });
673
+
674
+
675
+ Deno.test("takeWhileRight", () => {
676
+ let a;
677
+ const x = [1, 2, 3, 4, 5];
678
+ a = takeWhileRight(x, v => v >= 3);
679
+ assertEquals(a, [3, 4, 5]);
680
+ a = takeWhileRight(x, v => v >= 4);
681
+ assertEquals(a, [4, 5]);
682
+ });
683
+
684
+
685
+ Deno.test("drop", () => {
686
+ let a;
687
+ const x = [1, 2, 3, 4, 5];
688
+ a = drop(x, 2);
689
+ assertEquals(a, [3, 4, 5]);
690
+ a = drop(x, 3);
691
+ assertEquals(a, [4, 5]);
692
+ });
693
+
694
+
695
+ Deno.test("dropRight", () => {
696
+ let a;
697
+ const x = [1, 2, 3, 4, 5];
698
+ a = dropRight(x, 2);
699
+ assertEquals(a, [1, 2, 3]);
700
+ a = dropRight(x, 3);
701
+ assertEquals(a, [1, 2]);
702
+ });
703
+
704
+
705
+ Deno.test("dropWhile", () => {
706
+ let a;
707
+ const x = [1, 2, 3, 4, 5];
708
+ a = dropWhile(x, v => v < 3);
709
+ assertEquals(a, [3, 4, 5]);
710
+ a = dropWhile(x, v => v < 4);
711
+ assertEquals(a, [4, 5]);
712
+ });
713
+
714
+
715
+ Deno.test("dropWhileRight", () => {
716
+ let a;
717
+ const x = [1, 2, 3, 4, 5];
718
+ a = dropWhileRight(x, v => v >= 3);
719
+ assertEquals(a, [1, 2]);
720
+ a = dropWhileRight(x, v => v >= 4);
721
+ assertEquals(a, [1, 2, 3]);
722
+ });
723
+
724
+
725
+
726
+
727
+ // ARRANGEMENTS
728
+ // ------------
729
+
730
+ Deno.test("prefixes", () => {
731
+ let a;
732
+ a = prefixes([1, 2]);
733
+ assertEquals([...a], [[], [1], [1, 2]]);
734
+ a = prefixes([1, 2, 3]);
735
+ assertEquals([...a], [[], [1], [1, 2], [1, 2, 3]]);
736
+ });
737
+
738
+
739
+ Deno.test("suffixes", () => {
740
+ let a;
741
+ a = suffixes([1, 2]);
742
+ assertEquals([...a], [[1, 2], [2], []]);
743
+ a = suffixes([1, 2, 3]);
744
+ assertEquals([...a], [[1, 2, 3], [2, 3], [3], []]);
745
+ });
746
+
747
+
748
+ Deno.test("infixes", () => {
749
+ let a;
750
+ a = infixes([1, 2]);
751
+ assertEquals([...a], [[], [1], [1, 2], [2]]);
752
+ a = infixes([1, 2, 3]);
753
+ assertEquals([...a], [[], [1], [1, 2], [1, 2, 3], [2], [2, 3], [3]]);
754
+ });
755
+
756
+
757
+ Deno.test("subsequences", () => {
758
+ let a;
759
+ a = subsequences([1, 2]);
760
+ assertEquals([...a], [[], [1], [2], [1, 2]]);
761
+ a = subsequences([1, 2, 3]);
762
+ assertEquals([...a], [
763
+ [], [1],
764
+ [2], [1, 2],
765
+ [3], [1, 3],
766
+ [2, 3], [1, 2, 3]
767
+ ]);
768
+ });
769
+
770
+
771
+ Deno.test("permutations", () => {
772
+ let a;
773
+ a = permutations([1, 2]);
774
+ assertEquals([...a], [[], [1], [2], [1, 2], [2, 1]]);
775
+ a = permutations([1, 2, 3]);
776
+ assertEquals([...a], [
777
+ [], [1],
778
+ [2], [3],
779
+ [1, 2], [1, 3],
780
+ [2, 1], [2, 3],
781
+ [3, 1], [3, 2],
782
+ [1, 2, 3], [1, 3, 2],
783
+ [2, 1, 3], [2, 3, 1],
784
+ [3, 1, 2], [3, 2, 1]
785
+ ]);
786
+ a = permutations([1, 2, 3], 2);
787
+ assertEquals([...a], [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]);
788
+ });
789
+
790
+
791
+ Deno.test("randomValue", () => {
792
+ let a;
793
+ const x = [1, 2, 3];
794
+ a = randomValue(x);
795
+ assert(includes(x, a));
796
+ a = randomValue(x);
797
+ assert(includes(x, a));
798
+ });
799
+
800
+
801
+ Deno.test("randomPrefix", () => {
802
+ let a;
803
+ const x = [1, 2, 3];
804
+ a = randomPrefix(x) as number[];
805
+ assert(hasPrefix(x, a));
806
+ a = randomPrefix(x, 1) as number[];
807
+ assert(hasPrefix(x, a));
808
+ assertEquals(a.length, 1);
809
+ a = randomPrefix(x, -1) as number[];
810
+ assert(hasPrefix(x, a));
811
+ });
812
+
813
+
814
+ Deno.test("randomSuffix", () => {
815
+ let a;
816
+ const x = [1, 2, 3];
817
+ a = randomSuffix(x) as number[];
818
+ assert(hasSuffix(x, a));
819
+ a = randomSuffix(x, 1) as number[];
820
+ assert(hasSuffix(x, a));
821
+ assertEquals(a.length, 1);
822
+ a = randomSuffix(x, -1) as number[];
823
+ assert(hasSuffix(x, a));
824
+ });
825
+
826
+
827
+ Deno.test("randomInfix", () => {
828
+ let a;
829
+ const x = [1, 2, 3];
830
+ a = randomInfix(x) as number[];
831
+ assert(hasInfix(x, a));
832
+ a = randomInfix(x, 1) as number[];
833
+ assert(hasInfix(x, a));
834
+ assertEquals(a.length, 1);
835
+ a = randomInfix(x, -1) as number[];
836
+ assert(hasInfix(x, a));
837
+ });
838
+
839
+
840
+ Deno.test("randomSubsequence", () => {
841
+ let a;
842
+ const x = [1, 2, 3, 4, 5];
843
+ a = randomSubsequence(x) as number[];
844
+ assert(hasSubsequence(x, a));
845
+ a = randomSubsequence(x, 3) as number[];
846
+ assert(hasSubsequence(x, a));
847
+ assertEquals(a.length, 3);
848
+ a = randomSubsequence(x, 2) as number[];
849
+ assert(hasSubsequence(x, a));
850
+ assertEquals(a.length, 2);
851
+ });
852
+
853
+
854
+ Deno.test("randomPermutation", () => {
855
+ let a;
856
+ const x = [1, 2, 3, 4, 5];
857
+ a = randomPermutation(x) as number[];
858
+ assert(hasPermutation(x, a));
859
+ a = randomPermutation(x, 5) as number[];
860
+ assert(hasPermutation(x, a));
861
+ assertEquals(a.length, 5);
862
+ a = randomPermutation(x, 3) as number[];
863
+ assert(hasPermutation(x, a));
864
+ assertEquals(a.length, 3);
865
+ });
866
+
867
+
868
+ Deno.test("randomPermutation$", () => {
869
+ let a, x, y;
870
+ x = [1, 2, 3, 4, 5]; y = x.slice();
871
+ a = randomPermutation$(x);
872
+ assert(hasPermutation(y, a));
873
+ assertEquals(x, a);
874
+ x = [1, 2, 3, 4, 5]; y = x.slice();
875
+ a = randomPermutation$(x, 5);
876
+ assert(hasPermutation(y, a));
877
+ assertEquals(a.length, 5);
878
+ x = [1, 2, 3, 4, 5]; y = x.slice();
879
+ a = randomPermutation$(x, 3);
880
+ assert(hasPermutation(y, a));
881
+ assertEquals(a.length, 3);
882
+ });
883
+
884
+
885
+
886
+
887
+ // FIND
888
+ // ----
889
+
890
+ Deno.test("includes", () => {
891
+ let a;
892
+ const x = [1, 2, -3];
893
+ a = includes(x, 3);
894
+ assertEquals(a, false);
895
+ a = includes(x, -3);
896
+ assertEquals(a, true);
897
+ });
898
+
899
+
900
+ Deno.test("indexOf", () => {
901
+ let a, x;
902
+ x = [1, 2, 3, 2, 5];
903
+ a = indexOf(x, 2);
904
+ assertEquals(a, 1);
905
+ x = [1, 2, 3, 2, 5];
906
+ a = indexOf(x, 2, 2);
907
+ assertEquals(a, 3);
908
+ });
909
+
910
+
911
+ Deno.test("lastIndexOf", () => {
912
+ let a, x;
913
+ x = [1, 2, 3, 2, 5];
914
+ a = lastIndexOf(x, 2);
915
+ assertEquals(a, 3);
916
+ x = [1, 2, 3, 2, 5];
917
+ a = lastIndexOf(x, 2, 2);
918
+ assertEquals(a, 1);
919
+ });
920
+
921
+
922
+ Deno.test("find", () => {
923
+ let a;
924
+ const x = [1, 2, 3, 4, 5];
925
+ a = find(x, v => v % 2 == 0);
926
+ assertEquals(a, 2);
927
+ a = find(x, v => v % 2 == 1);
928
+ assertEquals(a, 1);
929
+ });
930
+
931
+
932
+ Deno.test("findRight", () => {
933
+ let a;
934
+ const x = [1, 2, 3, 4, 5];
935
+ a = findRight(x, v => v % 2 == 0);
936
+ assertEquals(a, 4);
937
+ a = findRight(x, v => v % 2 == 1);
938
+ assertEquals(a, 5);
939
+ });
940
+
941
+
942
+ Deno.test("scanWhile", () => {
943
+ let a;
944
+ const x = [1, 1, 2, 2, 3, 3, 4, 4];
945
+ a = scanWhile(x, v => v % 2 !== 0);
946
+ assertEquals(a, 2);
947
+ a = scanWhile(x, v => v % 3 !== 0);
948
+ assertEquals(a, 4);
949
+ a = scanWhile(x, v => v % 6 !== 0);
950
+ assertEquals(a, 8);
951
+ });
952
+
953
+
954
+ Deno.test("scanWhileRight", () => {
955
+ let a;
956
+ const x = [1, 1, 2, 2, 3, 3, 4, 4];
957
+ a = scanWhileRight(x, v => v % 3 !== 0);
958
+ assertEquals(a, 6);
959
+ a = scanWhileRight(x, v => v % 2 !== 0);
960
+ assertEquals(a, 8);
961
+ a = scanWhileRight(x, v => v % 6 !== 0);
962
+ assertEquals(a, 0);
963
+ });
964
+
965
+
966
+ Deno.test("scanUntil", () => {
967
+ let a;
968
+ const x = [1, 1, 2, 2, 3, 3, 4, 4];
969
+ a = scanUntil(x, v => v % 2 === 0);
970
+ assertEquals(a, 2);
971
+ a = scanUntil(x, v => v % 3 === 0);
972
+ assertEquals(a, 4);
973
+ a = scanUntil(x, v => v % 6 === 0);
974
+ assertEquals(a, 8);
975
+ });
976
+
977
+
978
+ Deno.test("scanUntilRight", () => {
979
+ let a;
980
+ const x = [1, 1, 2, 2, 3, 3, 4, 4];
981
+ a = scanUntilRight(x, v => v % 3 === 0);
982
+ assertEquals(a, 6);
983
+ a = scanUntilRight(x, v => v % 2 === 0);
984
+ assertEquals(a, 8);
985
+ a = scanUntilRight(x, v => v % 6 === 0);
986
+ assertEquals(a, 0);
987
+ });
988
+
989
+
990
+ Deno.test("search", () => {
991
+ let a, x;
992
+ x = [1, 2, 3, 2, 5];
993
+ a = search(x, v => v === 2);
994
+ assertEquals(a, 1);
995
+ x = [1, -2, 3, 2, 5];
996
+ a = search(x, v => Math.abs(v) === 2);
997
+ assertEquals(a, 1);
998
+ });
999
+
1000
+
1001
+ Deno.test("searchRight", () => {
1002
+ let a, x;
1003
+ x = [1, 2, 3, 2, 5];
1004
+ a = searchRight(x, v => v === 2);
1005
+ assertEquals(a, 3);
1006
+ x = [1, 2, 3, -2, 5];
1007
+ a = searchRight(x, v => Math.abs(v) === 2);
1008
+ assertEquals(a, 3);
1009
+ });
1010
+
1011
+
1012
+ Deno.test("searchAll", () => {
1013
+ let a, x;
1014
+ x = [1, 2, 3, 2, 5];
1015
+ a = searchAll(x, v => v === 2);
1016
+ assertEquals(a, [1, 3]);
1017
+ x = [1, 2, 3, -2, 5];
1018
+ a = searchAll(x, v => Math.abs(v) === 2);
1019
+ assertEquals(a, [1, 3]);
1020
+ });
1021
+
1022
+
1023
+ Deno.test("searchValue", () => {
1024
+ let a, x;
1025
+ x = [1, 2, 3, 2, 5];
1026
+ a = searchValue(x, 2);
1027
+ assertEquals(a, 1);
1028
+ x = [1, -2, 3, 2, 5];
1029
+ a = searchValue(x, 2, (a, b) => Math.abs(a) - Math.abs(b));
1030
+ assertEquals(a, 1);
1031
+ x = [1, -2, 3, 2, 5];
1032
+ a = searchValue(x, 2, null, v => Math.abs(v));
1033
+ assertEquals(a, 1);
1034
+ });
1035
+
1036
+
1037
+ Deno.test("searchValueRight", () => {
1038
+ let a, x;
1039
+ x = [1, 2, 3, 2, 5];
1040
+ a = searchValueRight(x, 2);
1041
+ assertEquals(a, 3);
1042
+ x = [1, 2, 3, -2, 5];
1043
+ a = searchValueRight(x, 2, (a, b) => Math.abs(a) - Math.abs(b));
1044
+ assertEquals(a, 3);
1045
+ a = searchValueRight(x, 2, null, v => Math.abs(v));
1046
+ assertEquals(a, 3);
1047
+ });
1048
+
1049
+
1050
+ Deno.test("searchValueAll", () => {
1051
+ let a, x;
1052
+ x = [1, 2, 3, 2, 5];
1053
+ a = searchValueAll(x, 2);
1054
+ assertEquals(a, [1, 3]);
1055
+ x = [1, 2, 3, -2, 5];
1056
+ a = searchValueAll(x, 2, (a, b) => Math.abs(a) - Math.abs(b));
1057
+ assertEquals(a, [1, 3]);
1058
+ a = searchValueAll(x, 2, null, v => Math.abs(v));
1059
+ assertEquals(a, [1, 3]);
1060
+ });
1061
+
1062
+
1063
+ Deno.test("searchMinimumValues", () => {
1064
+ const x = [2, 5, 3, 1, 4];
1065
+ const a = searchMinimumValues(x, 3);
1066
+ assertEquals(a, [3, 0, 2]);
1067
+ });
1068
+
1069
+
1070
+ Deno.test("searchInfix", () => {
1071
+ let a;
1072
+ const x = [1, 2, 3, 4];
1073
+ let y = [2, 3];
1074
+ a = searchInfix(x, y);
1075
+ assertEquals(a, 1);
1076
+ y = [-2, -3];
1077
+ a = searchInfix(x, y);
1078
+ assertEquals(a, -1);
1079
+ a = searchInfix(x, y, (a, b) => Math.abs(a) - Math.abs(b));
1080
+ assertEquals(a, 1);
1081
+ a = searchInfix(x, y, null, v => Math.abs(v));
1082
+ assertEquals(a, 1);
1083
+ });
1084
+
1085
+
1086
+ Deno.test("searchInfixRight", () => {
1087
+ let a;
1088
+ const x = [1, 2, 3, 4];
1089
+ let y = [2, 3];
1090
+ a = searchInfixRight(x, y);
1091
+ assertEquals(a, 1);
1092
+ y = [-2, -3];
1093
+ a = searchInfixRight(x, y);
1094
+ assertEquals(a, -1);
1095
+ a = searchInfixRight(x, y, (a, b) => Math.abs(a) - Math.abs(b));
1096
+ assertEquals(a, 1);
1097
+ a = searchInfixRight(x, y, null, v => Math.abs(v));
1098
+ assertEquals(a, 1);
1099
+ });
1100
+
1101
+
1102
+ Deno.test("searchInfixAll", () => {
1103
+ let a;
1104
+ const x = [1, 2, 3, 4, -2, -3];
1105
+ let y = [2, 3];
1106
+ a = searchInfixAll(x, y);
1107
+ assertEquals(a, [1]);
1108
+ y = [-2, -3];
1109
+ a = searchInfixAll(x, y);
1110
+ assertEquals(a, [4]);
1111
+ a = searchInfixAll(x, y, (a, b) => Math.abs(a) - Math.abs(b));
1112
+ assertEquals(a, [1, 4]);
1113
+ a = searchInfixAll(x, y, null, v => Math.abs(v));
1114
+ assertEquals(a, [1, 4]);
1115
+ });
1116
+
1117
+
1118
+ Deno.test("searchSubsequence", () => {
1119
+ let a;
1120
+ const x = [1, 2, 3, 4];
1121
+ a = searchSubsequence(x, [2, 4]);
1122
+ assertEquals(a, 1);
1123
+ a = searchSubsequence(x, [-2, -4]);
1124
+ assertEquals(a, -1);
1125
+ a = searchSubsequence(x, [-2, -4], (a, b) => Math.abs(a) - Math.abs(b));
1126
+ assertEquals(a, 1);
1127
+ a = searchSubsequence(x, [-2, -4], null, v => Math.abs(v));
1128
+ assertEquals(a, 1);
1129
+ });
1130
+
1131
+
1132
+ Deno.test("hasValue", () => {
1133
+ let a;
1134
+ const x = [1, 2, -3];
1135
+ a = hasValue(x, 3);
1136
+ assertEquals(a, false);
1137
+ a = hasValue(x, 3, (a, b) => Math.abs(a) - Math.abs(b));
1138
+ assertEquals(a, true);
1139
+ a = hasValue(x, 3, null, v => Math.abs(v));
1140
+ assertEquals(a, true);
1141
+ });
1142
+
1143
+
1144
+ Deno.test("hasPrefix", () => {
1145
+ let a;
1146
+ const x = [1, 2, 3, 4];
1147
+ a = hasPrefix(x, [1, 2]);
1148
+ assertEquals(a, true);
1149
+ a = hasPrefix(x, [-1, -2]);
1150
+ assertEquals(a, false);
1151
+ a = hasPrefix(x, [-1, -2], (a, b) => Math.abs(a) - Math.abs(b));
1152
+ assertEquals(a, true);
1153
+ a = hasPrefix(x, [-1, -2], null, v => Math.abs(v));
1154
+ assertEquals(a, true);
1155
+ });
1156
+
1157
+
1158
+ Deno.test("hasSuffix", () => {
1159
+ let a;
1160
+ const x = [1, 2, 3, 4];
1161
+ a = hasSuffix(x, [3, 4]);
1162
+ assertEquals(a, true);
1163
+ a = hasSuffix(x, [-3, -4]);
1164
+ assertEquals(a, false);
1165
+ a = hasSuffix(x, [-3, -4], (a, b) => Math.abs(a) - Math.abs(b));
1166
+ assertEquals(a, true);
1167
+ a = hasSuffix(x, [-3, -4], null, v => Math.abs(v));
1168
+ assertEquals(a, true);
1169
+ });
1170
+
1171
+
1172
+ Deno.test("hasInfix", () => {
1173
+ let a;
1174
+ const x = [1, 2, 3, 4];
1175
+ a = hasInfix(x, [2, 3]);
1176
+ assertEquals(a, true);
1177
+ a = hasInfix(x, [-2, -3]);
1178
+ assertEquals(a, false);
1179
+ a = hasInfix(x, [-2, -3], (a, b) => Math.abs(a) - Math.abs(b));
1180
+ assertEquals(a, true);
1181
+ a = hasInfix(x, [-2, -3], null, v => Math.abs(v));
1182
+ assertEquals(a, true);
1183
+ });
1184
+
1185
+
1186
+ Deno.test("hasSubsequence", () => {
1187
+ let a;
1188
+ const x = [1, 2, 3, 4];
1189
+ a = hasSubsequence(x, [2, 4]);
1190
+ assertEquals(a, true);
1191
+ a = hasSubsequence(x, [-2, -4]);
1192
+ assertEquals(a, false);
1193
+ a = hasSubsequence(x, [-2, -4], (a, b) => Math.abs(a) - Math.abs(b));
1194
+ assertEquals(a, true);
1195
+ a = hasSubsequence(x, [-2, -4], null, v => Math.abs(v));
1196
+ assertEquals(a, true);
1197
+ });
1198
+
1199
+
1200
+ Deno.test("hasPermutation", () => {
1201
+ let a;
1202
+ const x = [1, 2, 3, 4];
1203
+ a = hasPermutation(x, [4, 3, 2, 1]);
1204
+ assertEquals(a, true);
1205
+ a = hasPermutation(x, [3, -1, -2, 4]);
1206
+ assertEquals(a, false);
1207
+ a = hasPermutation(x, [3, -1, -2, 4], (a, b) => Math.abs(a) - Math.abs(b));
1208
+ assertEquals(a, true);
1209
+ a = hasPermutation(x, [3, -1, -2, 4], null, v => Math.abs(v));
1210
+ assertEquals(a, true);
1211
+ });
1212
+
1213
+
1214
+
1215
+
1216
+ // FUNCTIONAL
1217
+ // ----------
1218
+
1219
+ Deno.test("forEach", () => {
1220
+ const x = [1, 2, -3, -4];
1221
+ const a: number[] = [];
1222
+ forEach(x, v => a.push(v));
1223
+ assertEquals(a, x);
1224
+ });
1225
+
1226
+
1227
+ Deno.test("some", () => {
1228
+ let a;
1229
+ const x = [1, 2, -3, -4];
1230
+ a = some(x, v => v > 10);
1231
+ assertEquals(a, false);
1232
+ a = some(x, v => v < 0);
1233
+ assertEquals(a, true);
1234
+ });
1235
+
1236
+
1237
+ Deno.test("every", () => {
1238
+ let a;
1239
+ const x = [1, 2, -3, -4];
1240
+ a = every(x, v => v > 0);
1241
+ assertEquals(a, false);
1242
+ a = every(x, v => v > -10);
1243
+ assertEquals(a, true);
1244
+ });
1245
+
1246
+
1247
+ Deno.test("map", () => {
1248
+ const x = [1, 2, 3, 4];
1249
+ const a = map(x, v => v * 2);
1250
+ assertEquals(a, [2, 4, 6, 8]);
1251
+ });
1252
+
1253
+
1254
+ Deno.test("map$", () => {
1255
+ const x = [1, 2, 3, 4];
1256
+ const a = map$(x, v => v * 2);
1257
+ assertEquals(a, [2, 4, 6, 8]);
1258
+ assertEquals(x, [2, 4, 6, 8]);
1259
+ });
1260
+
1261
+
1262
+ Deno.test("reduce", () => {
1263
+ let a;
1264
+ const x = [1, 2, 3, 4];
1265
+ a = reduce(x, (acc, v) => acc+v);
1266
+ assertEquals(a, 10);
1267
+ a = reduce(x, (acc, v) => acc+v, 100);
1268
+ assertEquals(a, 110);
1269
+ });
1270
+
1271
+
1272
+ Deno.test("reduceRight", () => {
1273
+ let a;
1274
+ const x = [1, 2, 3, 4];
1275
+ a = reduceRight(x, (acc, v) => acc+v);
1276
+ assertEquals(a, 10);
1277
+ a = reduceRight(x, (acc, v) => acc+v, 100);
1278
+ assertEquals(a, 110);
1279
+ });
1280
+
1281
+
1282
+ Deno.test("filter", () => {
1283
+ let a;
1284
+ const x = [1, 2, 3, 4, 5];
1285
+ a = filter(x, v => v % 2 === 1);
1286
+ assertEquals(a, [1, 3, 5]);
1287
+ a = filter(x, v => v % 2 === 0);
1288
+ assertEquals(a, [2, 4]);
1289
+ });
1290
+
1291
+
1292
+ Deno.test("filter$", () => {
1293
+ let a, x;
1294
+ x = [1, 2, 3, 4, 5];
1295
+ a = filter$(x, v => v % 2 === 1);
1296
+ assertEquals(a, [1, 3, 5]);
1297
+ assertEquals(x, [1, 3, 5]);
1298
+ x = [1, 2, 3, 4, 5];
1299
+ a = filter$(x, v => v % 2 === 0);
1300
+ assertEquals(a, [2, 4]);
1301
+ });
1302
+
1303
+
1304
+ Deno.test("filterAt", () => {
1305
+ let a;
1306
+ const x = [2, 4, 6, 8];
1307
+ a = filterAt(x, [1, 2]);
1308
+ assertEquals(a, [4, 6]);
1309
+ a = filterAt(x, [1, 3]);
1310
+ assertEquals(a, [4, 8]);
1311
+ });
1312
+
1313
+
1314
+ Deno.test("reject", () => {
1315
+ let a;
1316
+ const x = [1, 2, 3, 4, 5];
1317
+ a = reject(x, v => v % 2 === 1);
1318
+ assertEquals(a, [2, 4]);
1319
+ a = reject(x, v => v % 2 === 0);
1320
+ assertEquals(a, [1, 3, 5]);
1321
+ });
1322
+
1323
+
1324
+ Deno.test("reject$", () => {
1325
+ let a, x;
1326
+ x = [1, 2, 3, 4, 5];
1327
+ a = reject$(x, v => v % 2 === 1);
1328
+ assertEquals(a, [2, 4]);
1329
+ assertEquals(x, [2, 4]);
1330
+ x = [1, 2, 3, 4, 5];
1331
+ a = reject$(x, v => v % 2 === 0);
1332
+ assertEquals(a, [1, 3, 5]);
1333
+ });
1334
+
1335
+
1336
+ Deno.test("rejectAt", () => {
1337
+ let a;
1338
+ const x = [2, 4, 6, 8];
1339
+ a = rejectAt(x, [1, 2]);
1340
+ assertEquals(a, [2, 8]);
1341
+ a = rejectAt(x, [1, 3]);
1342
+ assertEquals(a, [2, 6]);
1343
+ });
1344
+
1345
+
1346
+ Deno.test("inclusiveScan", () => {
1347
+ let a;
1348
+ const x = [1, 2, 3, 4];
1349
+ a = inclusiveScan(x, (acc, v) => acc+v);
1350
+ assertEquals(a, [1, 3, 6, 10]);
1351
+ a = inclusiveScan(x, (acc, v) => acc+v, 100);
1352
+ assertEquals(a, [101, 103, 106, 110]);
1353
+ });
1354
+
1355
+
1356
+ Deno.test("flat", () => {
1357
+ let a;
1358
+ const x = [[1, 2], [3, [4, [5]]]];
1359
+ a = flat(x);
1360
+ assertEquals(a, [1, 2, 3, 4, 5]);
1361
+ a = flat(x, 1);
1362
+ assertEquals(a, [1, 2, 3, [4, [5]]]);
1363
+ a = flat(x, 2);
1364
+ assertEquals(a, [1, 2, 3, 4, [5]]);
1365
+ });
1366
+
1367
+
1368
+ Deno.test("flatMap", () => {
1369
+ let a;
1370
+ const x = [[1, 2], [3, [4, [5]]]];
1371
+ a = flatMap(x);
1372
+ assertEquals(a, [1, 2, 3, [4, [5]]]);
1373
+ a = flatMap(x, v => flat(v as unknown[], 1));
1374
+ assertEquals(a, [1, 2, 3, 4, [5]]);
1375
+ a = flatMap(x, v => flat(v as unknown[]));
1376
+ assertEquals(a, [1, 2, 3, 4, 5]);
1377
+ });
1378
+
1379
+
1380
+ Deno.test("zip", () => {
1381
+ let a;
1382
+ const x = [1, 2, 3];
1383
+ const y = [4, 5];
1384
+ a = zip([x, y]);
1385
+ assertEquals(a, [[1, 4], [2, 5]]); // (shortest)
1386
+ const b = zip([x, y], ([a, b]) => a + b);
1387
+ assertEquals(b, [5, 7]);
1388
+ a = zip([x, y], null, some);
1389
+ assertEquals(a, [[1, 4], [2, 5]]); // (shortest)
1390
+ a = zip([x, y], null, every, 0);
1391
+ assertEquals(a, [[1, 4], [2, 5], [3, 0]]); // (longest)
1392
+ a = zip([x, y], null, head as EndFunction, 0);
1393
+ assertEquals(a, [[1, 4], [2, 5], [3, 0]]); // (first)
1394
+ });
1395
+
1396
+
1397
+
1398
+
1399
+ // MANIPULATION
1400
+ // ------------
1401
+
1402
+ Deno.test("fill", () => {
1403
+ let a;
1404
+ const x = [1, 2, 3, 4];
1405
+ a = fill(x, 2);
1406
+ assertEquals(a, [2, 2, 2, 2]);
1407
+ a = fill(x, 2, 1);
1408
+ assertEquals(a, [1, 2, 2, 2]);
1409
+ a = fill(x, 2, 1, 3);
1410
+ assertEquals(a, [1, 2, 2, 4]);
1411
+ });
1412
+
1413
+
1414
+ Deno.test("fill$", () => {
1415
+ let a, x;
1416
+ x = [1, 2, 3, 4];
1417
+ a = fill$(x, 2);
1418
+ assertEquals(a, [2, 2, 2, 2]);
1419
+ assertEquals(x, [2, 2, 2, 2]);
1420
+ x = [1, 2, 3, 4];
1421
+ a = fill$(x, 2, 1);
1422
+ assertEquals(a, [1, 2, 2, 2]);
1423
+ x = [1, 2, 3, 4];
1424
+ a = fill$(x, 2, 1, 3);
1425
+ assertEquals(a, [1, 2, 2, 4]);
1426
+ });
1427
+
1428
+
1429
+ Deno.test("sort", () => {
1430
+ let a;
1431
+ const x = [-2, -3, 1, 4];
1432
+ a = sort(x);
1433
+ assertEquals(a, [-3, -2, 1, 4]); // (compares numbers)
1434
+ a = sort(x, (a, b) => Math.abs(a) - Math.abs(b));
1435
+ assertEquals(a, [1, -2, -3, 4]);
1436
+ a = sort(x, null, v => Math.abs(v));
1437
+ assertEquals(a, [1, -2, -3, 4]);
1438
+ });
1439
+
1440
+
1441
+ // TODO: Check various array lengths.
1442
+ Deno.test("sort$", () => {
1443
+ let a, x;
1444
+ x = [-2, -3, 1, 4];
1445
+ a = sort$(x);
1446
+ assertEquals(a, [ -3, -2, 1, 4 ]); // (compares numbers)
1447
+ assertEquals(x, [ -3, -2, 1, 4 ]);
1448
+ x = [-2, -3, 1, 4];
1449
+ a = sort$(x, (a, b) => Math.abs(a) - Math.abs(b));
1450
+ assertEquals(a, [ 1, -2, -3, 4 ]);
1451
+ x = [-2, -3, 1, 4];
1452
+ a = sort$(x, null, v => Math.abs(v));
1453
+ assertEquals(a, [ 1, -2, -3, 4 ]);
1454
+ });
1455
+
1456
+
1457
+ Deno.test("push", () => {
1458
+ let a;
1459
+ const x = [1, 2];
1460
+ a = push(x, 3);
1461
+ assertEquals(a, [1, 2, 3]);
1462
+ a = push(x, 3, 4);
1463
+ assertEquals(a, [1, 2, 3, 4]);
1464
+ });
1465
+
1466
+
1467
+ Deno.test("push$", () => {
1468
+ let a, x;
1469
+ x = [1, 2];
1470
+ a = push$(x, 3);
1471
+ assertEquals(a, [1, 2, 3]);
1472
+ assertEquals(x, [1, 2, 3]);
1473
+ x = [1, 2];
1474
+ a = push$(x, 3, 4);
1475
+ assertEquals(a, [1, 2, 3, 4]);
1476
+ });
1477
+
1478
+
1479
+ Deno.test("pop", () => {
1480
+ let a, x;
1481
+ x = [1, 2, 3];
1482
+ a = pop(x);
1483
+ assertEquals(a, [1, 2]);
1484
+ x = [1, 2, 3, 4];
1485
+ a = pop(x);
1486
+ assertEquals(a, [1, 2, 3]);
1487
+ });
1488
+
1489
+
1490
+ Deno.test("pop$", () => {
1491
+ let a, x;
1492
+ x = [1, 2, 3];
1493
+ a = pop$(x);
1494
+ assertEquals(a, [1, 2]);
1495
+ assertEquals(x, [1, 2]);
1496
+ x = [1, 2, 3, 4];
1497
+ a = pop$(x);
1498
+ assertEquals(a, [1, 2, 3]);
1499
+ });
1500
+
1501
+
1502
+ Deno.test("shift", () => {
1503
+ let a, x;
1504
+ x = [1, 2, 3];
1505
+ a = shift(x);
1506
+ assertEquals(a, [2, 3]);
1507
+ x = [1, 2, 3, 4];
1508
+ a = shift(x);
1509
+ assertEquals(a, [2, 3, 4]);
1510
+ });
1511
+
1512
+
1513
+ Deno.test("shift$", () => {
1514
+ let a, x;
1515
+ x = [1, 2, 3];
1516
+ a = shift$(x);
1517
+ assertEquals(a, [2, 3]);
1518
+ assertEquals(x, [2, 3]);
1519
+ x = [1, 2, 3, 4];
1520
+ a = shift$(x);
1521
+ assertEquals(a, [2, 3, 4]);
1522
+ });
1523
+
1524
+
1525
+ Deno.test("unshift", () => {
1526
+ let a;
1527
+ const x = [3, 4];
1528
+ a = unshift(x, 2);
1529
+ assertEquals(a, [2, 3, 4]);
1530
+ a = unshift(x, 1, 2);
1531
+ assertEquals(a, [1, 2, 3, 4]);
1532
+ });
1533
+
1534
+
1535
+ Deno.test("unshift$", () => {
1536
+ let a, x;
1537
+ x = [3, 4];
1538
+ a = unshift$(x, 2);
1539
+ assertEquals(a, [2, 3, 4]);
1540
+ assertEquals(x, [2, 3, 4]);
1541
+ x = [3, 4];
1542
+ a = unshift$(x, 1, 2);
1543
+ assertEquals(a, [1, 2, 3, 4]);
1544
+ });
1545
+
1546
+
1547
+ Deno.test("copy", () => {
1548
+ let a;
1549
+ const x = [1, 2, 3, 4, 5];
1550
+ const y = [10, 20, 30];
1551
+ a = copy(x, y);
1552
+ assertEquals(a, [10, 20, 30, 4, 5]);
1553
+ a = copy(x, y, 1);
1554
+ assertEquals(a, [1, 10, 20, 30, 5]);
1555
+ a = copy(x, y, 1, 1);
1556
+ assertEquals(a, [1, 20, 30, 4, 5]);
1557
+ a = copy(x, y, 1, 1, 2);
1558
+ assertEquals(a, [1, 20, 3, 4, 5]);
1559
+ });
1560
+
1561
+
1562
+ Deno.test("copy$", () => {
1563
+ let a;
1564
+ let x = [1, 2, 3, 4, 5];
1565
+ const y = [10, 20, 30];
1566
+ a = copy$(x, y);
1567
+ assertEquals(a, [10, 20, 30, 4, 5]);
1568
+ assertEquals(x, [10, 20, 30, 4, 5]);
1569
+ x = [1, 2, 3, 4, 5];
1570
+ a = copy$(x, y, 1);
1571
+ assertEquals(a, [1, 10, 20, 30, 5]);
1572
+ x = [1, 2, 3, 4, 5];
1573
+ a = copy$(x, y, 1, 1);
1574
+ assertEquals(a, [1, 20, 30, 4, 5]);
1575
+ x = [1, 2, 3, 4, 5];
1576
+ a = copy$(x, y, 1, 1, 2);
1577
+ assertEquals(a, [1, 20, 3, 4, 5]);
1578
+ });
1579
+
1580
+
1581
+ Deno.test("copyWithin", () => {
1582
+ let a;
1583
+ const x = [1, 2, 3, 4, 5];
1584
+ a = copyWithin(x, 3);
1585
+ assertEquals(a, [1, 2, 3, 1, 2]);
1586
+ a = copyWithin(x, 3, 1);
1587
+ assertEquals(a, [1, 2, 3, 2, 3]);
1588
+ a = copyWithin(x, 3, 1, 2);
1589
+ assertEquals(a, [1, 2, 3, 2, 5]);
1590
+ });
1591
+
1592
+
1593
+ Deno.test("copyWithin$", () => {
1594
+ let a, x;
1595
+ x = [1, 2, 3, 4, 5];
1596
+ a = copyWithin$(x, 3);
1597
+ assertEquals(a, [1, 2, 3, 1, 2]);
1598
+ assertEquals(x, [1, 2, 3, 1, 2]);
1599
+ x = [1, 2, 3, 4, 5];
1600
+ a = copyWithin$(x, 3, 1);
1601
+ assertEquals(a, [1, 2, 3, 2, 3]);
1602
+ x = [1, 2, 3, 4, 5];
1603
+ a = copyWithin$(x, 3, 1, 2);
1604
+ assertEquals(a, [1, 2, 3, 2, 5]);
1605
+ });
1606
+
1607
+
1608
+ Deno.test("moveWithin", () => {
1609
+ let a;
1610
+ const x = [1, 2, 3, 4, 5, 6];
1611
+ a = moveWithin(x, 0, 1, 3);
1612
+ assertEquals(a, [2, 3, 1, 4, 5, 6]); // (2,3 to left)
1613
+ a = moveWithin(x, 6, 3, 5);
1614
+ assertEquals(a, [1, 2, 3, 6, 4, 5]); // (4,5 to right)
1615
+ });
1616
+
1617
+
1618
+ Deno.test("moveWithin$", () => {
1619
+ let a, x;
1620
+ x = [1, 2, 3, 4, 5, 6];
1621
+ a = moveWithin$(x, 0, 1, 3);
1622
+ assertEquals(a, [2, 3, 1, 4, 5, 6]); // (2,3 to left)
1623
+ assertEquals(x, [2, 3, 1, 4, 5, 6]);
1624
+ x = [1, 2, 3, 4, 5, 6];
1625
+ a = moveWithin$(x, 6, 3, 5);
1626
+ assertEquals(a, [1, 2, 3, 6, 4, 5]); // (4,5 to right)
1627
+ });
1628
+
1629
+
1630
+ Deno.test("splice", () => {
1631
+ let a;
1632
+ const x = [1, 2, 3, 4, 5];
1633
+ a = splice(x, 2);
1634
+ assertEquals(a, [1, 2]);
1635
+ a = splice(x, 2, 2);
1636
+ assertEquals(a, [1, 2, 5]);
1637
+ a = splice(x, 2, 2, 30, 40);
1638
+ assertEquals(a, [1, 2, 30, 40, 5]);
1639
+ });
1640
+
1641
+
1642
+ Deno.test("splice$", () => {
1643
+ let a, x;
1644
+ x = [1, 2, 3, 4, 5];
1645
+ a = splice$(x, 2);
1646
+ assertEquals(a, [1, 2]);
1647
+ assertEquals(x, [1, 2]);
1648
+ x = [1, 2, 3, 4, 5];
1649
+ a = splice$(x, 2, 2);
1650
+ assertEquals(a, [1, 2, 5]);
1651
+ x = [1, 2, 3, 4, 5];
1652
+ a = splice$(x, 2, 2, 30, 40);
1653
+ assertEquals(a, [1, 2, 30, 40, 5]);
1654
+ });
1655
+
1656
+
1657
+ Deno.test("split", () => {
1658
+ let a, x;
1659
+ x = [1, 2, 2, 3, 5, 4, 4, 7];
1660
+ a = split(x, v => v % 2 === 0);
1661
+ assertEquals(a, [[1], [3, 5], [7]]);
1662
+ x = [2, 4, 5, 6, 8];
1663
+ a = split(x, v => v % 2 === 0);
1664
+ assertEquals(a, [[5]]);
1665
+ });
1666
+
1667
+
1668
+ Deno.test("splitAt", () => {
1669
+ let a, x;
1670
+ x = [1, 2, 2, 3, 5, 4, 4, 7];
1671
+ a = splitAt(x, [1, 2, 5, 6]);
1672
+ assertEquals(a, [[1], [3, 5], [7]]);
1673
+ x = [2, 4, 5, 6, 8];
1674
+ a = splitAt(x, [0, 1, 3, 4]);
1675
+ assertEquals(a, [[5]]);
1676
+ });
1677
+
1678
+
1679
+ Deno.test("cut", () => {
1680
+ let a;
1681
+ const x = [1, 2, 3, 4, 5];
1682
+ a = cut(x, (_v, i) => i===1 || i===3);
1683
+ assertEquals(a, [ [ 1 ], [ 2, 3 ], [ 4, 5 ] ]);
1684
+ a = cut(x, (_v, i) => i===0 || i===4);
1685
+ assertEquals(a, [ [], [ 1, 2, 3, 4 ], [ 5 ] ]);
1686
+ });
1687
+
1688
+
1689
+ Deno.test("cutRight", () => {
1690
+ let a;
1691
+ const x = [1, 2, 3, 4, 5];
1692
+ a = cutRight(x, (_v, i) => i===1 || i===3);
1693
+ assertEquals(a, [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]);
1694
+ a = cutRight(x, (_v, i) => i===0 || i===4);
1695
+ assertEquals(a, [ [ 1 ], [ 2, 3, 4, 5 ], [] ]);
1696
+ });
1697
+
1698
+
1699
+ Deno.test("cutAt", () => {
1700
+ let a;
1701
+ const x = [1, 2, 3, 4, 5];
1702
+ a = cutAt(x, [1, 3]);
1703
+ assertEquals(a, [[1], [2, 3], [4, 5]]);
1704
+ a = cutAt(x, [0, 4]);
1705
+ assertEquals(a, [[], [1, 2, 3, 4], [5]]);
1706
+ });
1707
+
1708
+
1709
+ Deno.test("cutAtRight", () => {
1710
+ let a;
1711
+ const x = [1, 2, 3, 4, 5];
1712
+ a = cutAtRight(x, [1, 3]);
1713
+ assertEquals(a, [[1, 2], [3, 4], [5]]);
1714
+ a = cutAtRight(x, [0, 4]);
1715
+ assertEquals(a, [[1], [2, 3, 4, 5], []]);
1716
+ });
1717
+
1718
+
1719
+ Deno.test("group", () => {
1720
+ let a;
1721
+ const x = [1, 2, 2, -2, -2, 4];
1722
+ a = group(x);
1723
+ assertEquals(a, [[1], [2, 2], [-2, -2], [4]]);
1724
+ a = group(x, (a, b) => Math.abs(a) - Math.abs(b));
1725
+ assertEquals(a, [[1], [2, 2, -2, -2], [4]]);
1726
+ a = group(x, null, v => Math.abs(v));
1727
+ assertEquals(a, [[1], [2, 2, -2, -2], [4]]);
1728
+ });
1729
+
1730
+
1731
+ Deno.test("partition", () => {
1732
+ let a, x;
1733
+ x = [1, 2, 3, 4];
1734
+ a = partition(x, v => v % 2 == 0);
1735
+ assertEquals(a, [[2, 4], [1, 3]]);
1736
+ x = [1, 2, 3, 4, 5];
1737
+ a = partition(x, v => v % 2 == 1);
1738
+ assertEquals(a, [[1, 3, 5], [2, 4]]);
1739
+ });
1740
+
1741
+
1742
+ Deno.test("partitionEach", () => {
1743
+ let x = [1, 2, 3, 4];
1744
+ const a = partitionEach(x, v => v % 2 == 0);
1745
+ assertEquals(a, new Map([[false, [1, 3]], [true, [2, 4]]]));
1746
+ x = [1, 2, 3, 4, 5];
1747
+ const b = partitionEach(x, v => v % 3);
1748
+ assertEquals(b, new Map([[1, [1, 4]], [2, [2, 5]], [0, [3]]]));
1749
+ });
1750
+
1751
+
1752
+ Deno.test("chunk", () => {
1753
+ let a;
1754
+ const x = [1, 2, 3, 4, 5, 6, 7, 8];
1755
+ a = chunk(x, 3);
1756
+ assertEquals(a, [[1, 2, 3], [4, 5, 6], [7, 8]]);
1757
+ a = chunk(x, 2, 3);
1758
+ assertEquals(a, [[1, 2], [4, 5], [7, 8]]);
1759
+ a = chunk(x, 4, 3);
1760
+ assertEquals(a, [[1, 2, 3, 4], [4, 5, 6, 7], [7, 8]]);
1761
+ });
1762
+
1763
+
1764
+ Deno.test("cycle", () => {
1765
+ let a;
1766
+ const x = [1, 2, 3];
1767
+ a = cycle(x, 0, 2);
1768
+ assertEquals(a, [1, 2]);
1769
+ a = cycle(x, 0, 4);
1770
+ assertEquals(a, [1, 2, 3, 1]);
1771
+ a = cycle(x, 1, 6);
1772
+ assertEquals(a, [2, 3, 1, 2, 3, 1]);
1773
+ });
1774
+
1775
+
1776
+ Deno.test("repeat", () => {
1777
+ let a;
1778
+ const x = [1, 2];
1779
+ a = repeat(x, 2);
1780
+ assertEquals(a, [1, 2, 1, 2]);
1781
+ a = repeat(x, 3);
1782
+ assertEquals(a, [1, 2, 1, 2, 1, 2]);
1783
+ });
1784
+
1785
+
1786
+ Deno.test("reverse", () => {
1787
+ const x = [1, 2, 3, 4];
1788
+ const a = reverse(x);
1789
+ assertEquals(a, [4, 3, 2, 1]);
1790
+ });
1791
+
1792
+
1793
+ Deno.test("reverse$", () => {
1794
+ const x = [1, 2, 3, 4];
1795
+ const a = reverse$(x);
1796
+ assertEquals(a, [4, 3, 2, 1]);
1797
+ assertEquals(x, [4, 3, 2, 1]);
1798
+ });
1799
+
1800
+
1801
+ Deno.test("rotate", () => {
1802
+ let a;
1803
+ const x = [1, 2, 3, 4];
1804
+ a = rotate(x, 1);
1805
+ assertEquals(a, [2, 3, 4, 1]);
1806
+ a = rotate(x, 2);
1807
+ assertEquals(a, [3, 4, 1, 2]);
1808
+ a = rotate(x, -1);
1809
+ assertEquals(a, [4, 1, 2, 3]);
1810
+ });
1811
+
1812
+
1813
+ Deno.test("rotate$", () => {
1814
+ let a, x;
1815
+ x = [1, 2, 3, 4];
1816
+ a = rotate$(x, 1);
1817
+ assertEquals(a, [2, 3, 4, 1]);
1818
+ assertEquals(x, [2, 3, 4, 1]);
1819
+ x = [1, 2, 3, 4];
1820
+ a = rotate$(x, 2);
1821
+ assertEquals(a, [3, 4, 1, 2]);
1822
+ x = [1, 2, 3, 4];
1823
+ a = rotate$(x, -1);
1824
+ assertEquals(a, [4, 1, 2, 3]);
1825
+ });
1826
+
1827
+
1828
+ Deno.test("intersperse", () => {
1829
+ let a, x;
1830
+ x = [1, 2, 3];
1831
+ a = intersperse(x, 10);
1832
+ assertEquals(a, [1, 10, 2, 10, 3]);
1833
+ x = [1, 2, 3, 4];
1834
+ a = intersperse(x, 10);
1835
+ assertEquals(a, [1, 10, 2, 10, 3, 10, 4]);
1836
+ });
1837
+
1838
+
1839
+ Deno.test("interpolate", () => {
1840
+ const x = [1, 2, 3];
1841
+ const a = interpolate(x, (a, b) => (a + b)/2);
1842
+ assertEquals(a, [1, 1.5, 2, 2.5, 3]);
1843
+ });
1844
+
1845
+
1846
+ Deno.test("intermix", () => {
1847
+ let a;
1848
+ const x = [1, 2, 3, 4];
1849
+ const y = [10, 20, 30];
1850
+ a = intermix(x, [10]);
1851
+ assertEquals(a, [1, 10, 2, 10, 3, 10, 4]);
1852
+ a = intermix(x, y);
1853
+ assertEquals(a, [1, 10, 2, 20, 3, 30, 4]);
1854
+ a = intermix(x, y, 2);
1855
+ assertEquals(a, [1, 2, 10, 3, 4]);
1856
+ a = intermix(x, y, 1, 2);
1857
+ assertEquals(a, [1, 10, 20, 2, 30, 10, 3, 20, 30, 4]);
1858
+ });
1859
+
1860
+
1861
+ Deno.test("interleave", () => {
1862
+ let a;
1863
+ const x = [1, 2, 3, 4];
1864
+ let y = [10, 20, 30, 40];
1865
+ a = interleave([x, y]);
1866
+ assertEquals(a, [1, 10, 2, 20, 3, 30, 4, 40]);
1867
+ y = [10, 20];
1868
+ a = interleave([x, y]);
1869
+ assertEquals(a, [1, 10, 2, 20, 3, 4]);
1870
+ });
1871
+
1872
+
1873
+
1874
+
1875
+ // COMBINE
1876
+ // -------
1877
+
1878
+ Deno.test("concat", () => {
1879
+ let a;
1880
+ const x = [1, 2];
1881
+ const y = [3, 4];
1882
+ a = concat(x, y);
1883
+ assertEquals(a, [1, 2, 3, 4]);
1884
+ a = concat(x, y, y);
1885
+ assertEquals(a, [1, 2, 3, 4, 3, 4]);
1886
+ });
1887
+
1888
+
1889
+ Deno.test("concat$", () => {
1890
+ let a;
1891
+ let x = [1, 2];
1892
+ const y = [3, 4];
1893
+ a = concat$(x, y);
1894
+ assertEquals(a, [1, 2, 3, 4]);
1895
+ assertEquals(x, [1, 2, 3, 4]);
1896
+ x = [1, 2];
1897
+ a = concat$(x, y, y);
1898
+ assertEquals(a, [1, 2, 3, 4, 3, 4]);
1899
+ });
1900
+
1901
+
1902
+ Deno.test("join", () => {
1903
+ let a;
1904
+ const x = [1, 2];
1905
+ a = join(x);
1906
+ assertEquals(a, "1,2");
1907
+ a = join(x, " : ");
1908
+ assertEquals(a, "1 : 2");
1909
+ });
1910
+
1911
+
1912
+
1913
+
1914
+ // SET OPERATIONS
1915
+ // --------------
1916
+
1917
+ Deno.test("isUnique", () => {
1918
+ let a;
1919
+ const x = [1, 2, -1, -2];
1920
+ a = isUnique(x);
1921
+ assertEquals(a, true);
1922
+ a = isUnique(x, (a, b) => Math.abs(a) - Math.abs(b));
1923
+ assertEquals(a, false);
1924
+ a = isUnique(x, null, v => Math.abs(v));
1925
+ assertEquals(a, false);
1926
+ });
1927
+
1928
+
1929
+ Deno.test("isDisjoint", () => {
1930
+ let a;
1931
+ const x = [1, 2, 3, 4];
1932
+ a = isDisjoint(x, [2, 5]);
1933
+ assertEquals(a, false);
1934
+ a = isDisjoint(x, [-2, -5]);
1935
+ assertEquals(a, true);
1936
+ a = isDisjoint(x, [-2, -5], (a, b) => Math.abs(a) - Math.abs(b));
1937
+ assertEquals(a, false);
1938
+ a = isDisjoint(x, [-2, -5], null, v => Math.abs(v));
1939
+ assertEquals(a, false);
1940
+ });
1941
+
1942
+
1943
+ Deno.test("unique", () => {
1944
+ let a, x;
1945
+ x = [1, 2, 3, 4, 2, 3];
1946
+ a = unique(x);
1947
+ assertEquals(a, [1, 2, 3, 4]);
1948
+ x = [1, 2, 3, 4, -2, -3];
1949
+ a = unique(x, (a, b) => Math.abs(a) - Math.abs(b));
1950
+ assertEquals(a, [1, 2, 3, 4]);
1951
+ a = unique(x, null, v => Math.abs(v));
1952
+ assertEquals(a, [1, 2, 3, 4]);
1953
+ });
1954
+
1955
+
1956
+ Deno.test("union", () => {
1957
+ let a;
1958
+ const x = [1, 2, 3, 4];
1959
+ let y = [2, 3, 5];
1960
+ a = union(x, y);
1961
+ assertEquals(a, [1, 2, 3, 4, 5]);
1962
+ y = [-2, -3, -5];
1963
+ a = union(x, y, (a, b) => Math.abs(a) - Math.abs(b));
1964
+ assertEquals(a, [1, 2, 3, 4, -5]);
1965
+ a = union(x, y, null, v => Math.abs(v));
1966
+ assertEquals(a, [1, 2, 3, 4, -5]);
1967
+ });
1968
+
1969
+
1970
+ Deno.test("union$", () => {
1971
+ let a, x, y;
1972
+ x = [1, 2, 3, 4];
1973
+ y = [2, 3, 5];
1974
+ a = union$(x, y);
1975
+ assertEquals(a, [1, 2, 3, 4, 5]);
1976
+ assertEquals(x, [1, 2, 3, 4, 5]);
1977
+ x = [1, 2, 3, 4];
1978
+ y = [-2, -3, -5];
1979
+ a = union$(x, y, (a, b) => Math.abs(a) - Math.abs(b));
1980
+ assertEquals(a, [1, 2, 3, 4, -5]);
1981
+ x = [1, 2, 3, 4];
1982
+ a = union$(x, y, null, v => Math.abs(v));
1983
+ assertEquals(a, [1, 2, 3, 4, -5]);
1984
+ });
1985
+
1986
+
1987
+ Deno.test("intersection", () => {
1988
+ let a;
1989
+ const x = [1, 2, 3, 4];
1990
+ let y = [2, 3, 5];
1991
+ a = intersection(x, y);
1992
+ assertEquals(a, [2, 3]);
1993
+ y = [-2, -3, -5];
1994
+ a = intersection(x, y, (a, b) => Math.abs(a) - Math.abs(b));
1995
+ assertEquals(a, [2, 3]);
1996
+ a = intersection(x, y, null, v => Math.abs(v));
1997
+ assertEquals(a, [2, 3]);
1998
+ });
1999
+
2000
+
2001
+ Deno.test("difference", () => {
2002
+ let a;
2003
+ const x = [1, 2, 3, 4, 5];
2004
+ let y = [2, 4];
2005
+ a = difference(x, y);
2006
+ assertEquals(a, [1, 3, 5]);
2007
+ y = [-2, -4];
2008
+ a = difference(x, y);
2009
+ assertEquals(a, [1, 2, 3, 4, 5]);
2010
+ a = difference(x, y, (a, b) => Math.abs(a) - Math.abs(b));
2011
+ assertEquals(a, [1, 3, 5]);
2012
+ a = difference(x, y, null, v => Math.abs(v));
2013
+ assertEquals(a, [1, 3, 5]);
2014
+ });
2015
+
2016
+
2017
+ Deno.test("symmetricDifference", () => {
2018
+ let a;
2019
+ const x = [1, 2, 3, 4];
2020
+ let y = [3, 4, 5];
2021
+ a = symmetricDifference(x, y);
2022
+ assertEquals(a, [ 1, 2, 5]);
2023
+ y = [-3, -4, -5];
2024
+ a = symmetricDifference(x, y);
2025
+ assertEquals(a, [
2026
+ 1, 2, 3, 4,
2027
+ -3, -4, -5
2028
+ ]);
2029
+ a = symmetricDifference(x, y, (a, b) => Math.abs(a) - Math.abs(b));
2030
+ assertEquals(a, [ 1, 2, -5]);
2031
+ a = symmetricDifference(x, y, null, v => Math.abs(v));
2032
+ assertEquals(a, [ 1, 2, -5]);
2033
+ });
2034
+
2035
+
2036
+ Deno.test("cartesianProduct", () => {
2037
+ let a;
2038
+ const x = [1, 2, 3];
2039
+ const y = [10, 20, 30];
2040
+ a = cartesianProduct([x, y]);
2041
+ assertEquals(a, [
2042
+ [ 1, 10 ], [ 1, 20 ],
2043
+ [ 1, 30 ], [ 2, 10 ],
2044
+ [ 2, 20 ], [ 2, 30 ],
2045
+ [ 3, 10 ], [ 3, 20 ],
2046
+ [ 3, 30 ]
2047
+ ]);
2048
+
2049
+ a = cartesianProduct([x, y], ([a, b]) => a + b);
2050
+ assertEquals(a, [
2051
+ 11, 21, 31, 12, 22,
2052
+ 32, 13, 23, 33
2053
+ ]);
2054
+ });