extra-map
Version:
A group of functions for working with Maps.<br>
1,275 lines (1,057 loc) • 31.8 kB
text/typescript
import {assertEquals} from "@std/assert";
import * as xarray from "@nodef/extra-array";
import {
is,
keys,
values,
entries,
from,
from$,
fromLists,
fromKeys,
fromValues,
compare,
isEqual,
size,
isEmpty,
get,
getAll,
getPath,
hasPath,
set,
set$,
setPath$,
swap,
swap$,
remove,
remove$,
removePath$,
count,
countAs,
min,
minEntry,
max,
maxEntry,
range,
rangeEntries,
head,
tail,
take,
take$,
drop,
drop$,
subsets,
randomKey,
randomEntry,
randomSubset,
has,
hasValue,
hasEntry,
hasSubset,
find,
findAll,
search,
searchAll,
searchValue,
searchValueAll,
forEach,
some,
every,
map,
map$,
reduce,
filter,
filter$,
filterAt,
filterAt$,
reject,
reject$,
rejectAt,
rejectAt$,
flat,
flatMap,
zip,
partition,
partitionAs,
chunk,
concat,
concat$,
join,
isDisjoint,
unionKeys,
union,
union$,
intersectionKeys,
intersection,
intersection$,
difference,
difference$,
symmetricDifference,
symmetricDifference$,
cartesianProduct,
} from "./index.ts";
// ABOUT
// -----
Deno.test("is", () => {
let a;
a = is(new Map([["a", 1], ["b", 2]]));
assertEquals(a, true);
a = is(new Map());
assertEquals(a, true);
a = is(1);
assertEquals(a, false);
});
Deno.test("keys", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
const a = keys(x);
assertEquals([...a], ["a", "b", "c"]);
});
Deno.test("values", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
const a = values(x);
assertEquals([...a], [1, 2, 3]);
});
Deno.test("entries", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
const a = entries(x);
assertEquals([...a], [["a", 1], ["b", 2], ["c", 3]]);
});
// GENERATE
// --------
Deno.test("from", () => {
const es: [string, number][] = [["a", 1], ["b", 2], ["c", 3]];
const a = from(es);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3]]));
});
Deno.test("from$", () => {
let a;
const es: [string, number][] = [["a", 1], ["b", 2], ["c", 3]];
a = from$(es);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3]]));
const x = new Map(es);
a = from$(x);
assertEquals(a===x, true);
a.set("a", 10);
assertEquals(x, new Map([["a", 10], ["b", 2], ["c", 3]]));
});
Deno.test("fromLists", () => {
const ls: [string[], number[]] = [["a", "b", "c"], [1, 2, 3]];
const a = fromLists(ls);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3]]));
});
Deno.test("fromKeys", () => {
const ks = ["a", "b", "c"];
const a = fromKeys(ks);
assertEquals(a, new Map([["a", "a"], ["b", "b"], ["c", "c"]]));
const b = fromKeys(ks, k => k.charCodeAt(0) - 97 + 1);
assertEquals(b, new Map([["a", 1], ["b", 2], ["c", 3]]));
});
Deno.test("fromValues", () => {
const vs = [1, 2, 3];
const a = fromValues(vs);
assertEquals(a, new Map([[1, 1], [2, 2], [3, 3]]));
const b = fromValues(vs, v => String.fromCharCode(v + 97 - 1));
assertEquals(b, new Map([["a", 1], ["b", 2], ["c", 3]]));
});
// COMPARE
// -------
Deno.test("compare", () => {
let y, a;
const x = new Map([["a", 1], ["b", 2]]);
y = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = compare(x, y);
assertEquals(a, -1);
y = new Map([["a", 1], ["b", 2]]);
a = compare(x, y);
assertEquals(a, 0);
y = new Map([["a", 1], ["b", -2]]);
a = compare(x, y);
assertEquals(a, 1);
a = compare(x, y, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, 0);
a = compare(x, y, null, v => Math.abs(v));
assertEquals(a, 0);
});
Deno.test("isEqual", () => {
let y, a;
const x = new Map([["a", 1], ["b", 2]]);
y = new Map([["a", 1], ["b", 2]]);
a = isEqual(x, y);
assertEquals(a, true);
y = new Map([["a", 11], ["b", 12]]);
a = isEqual(x, y);
assertEquals(a, false);
a = isEqual(x, y, (a, b) => (a % 10) - (b % 10));
assertEquals(a, true);
a = isEqual(x, y, null, v => v % 10);
assertEquals(a, true);
});
// SIZE
// ----
Deno.test("size", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
const a = size(x);
assertEquals(a, 3);
});
Deno.test("isEmpty", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = isEmpty(x);
assertEquals(a, false);
x = new Map<string, number>();
a = isEmpty(x);
assertEquals(a, true);
});
// GET/SET
// -------
Deno.test("get", () => {
let a;
const x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = get(x, "b");
assertEquals(a, 4);
a = get(x, "d");
assertEquals(a, 8);
});
Deno.test("getAll", () => {
let a;
const x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = getAll(x, ["b", "d"]);
assertEquals(a, [4, 8]);
a = getAll(x, ["e"]);
assertEquals(a, [undefined]);
});
Deno.test("getPath", () => {
let a;
const x = new Map<string, number>([["a", 2], ["b", 4], ["c", 6]]);
const y = new Map<string, unknown>([["x", x], ["e", 10], ["f", 12]]);
a = getPath(y, ["e"]);
assertEquals(a, 10);
a = getPath(y, ["x", "b"]);
assertEquals(a, 4);
a = getPath(y, ["x", "b", "c"]);
assertEquals(a, undefined);
});
Deno.test("hasPath", () => {
let a;
const x = new Map<string, number>([["a", 2], ["b", 4], ["c", 6]]);
const y = new Map<string, unknown>([["x", x], ["e", 10], ["f", 12]]);
a = hasPath(y, ["e"]);
assertEquals(a, true);
a = hasPath(y, ["x", "b"]);
assertEquals(a, true);
a = hasPath(y, ["x", "b", "c"]);
assertEquals(a, false);
});
Deno.test("set", () => {
let x, a;
x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = set(x, "b", 40);
assertEquals(a, new Map([["a", 2], ["b", 40], ["c", 6], ["d", 8]]));
x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = set(x, "d", 80);
assertEquals(a, new Map([["a", 2], ["b", 4], ["c", 6], ["d", 80]]));
});
Deno.test("set$", () => {
let x, a;
x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = set$(x, "b", 40);
assertEquals(a, new Map([["a", 2], ["b", 40], ["c", 6], ["d", 8]]));
assertEquals(x, new Map([["a", 2], ["b", 40], ["c", 6], ["d", 8]]));
x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = set$(x, "d", 80);
assertEquals(a, new Map([["a", 2], ["b", 4], ["c", 6], ["d", 80]]));
});
Deno.test("setPath$", () => {
let a;
const x = new Map<string, number>([["a", 2], ["b", 4], ["c", 6]]);
const y = new Map<string, unknown>([["x", x], ["e", 10], ["f", 12]]);
a = setPath$(y, ["e"], 100);
assertEquals(a, new Map<string, unknown>([
["x", new Map([["a", 2], ["b", 4], ["c", 6]])],
["e", 100],
["f", 12],
]));
assertEquals(y, new Map<string, unknown>([
["x", new Map([["a", 2], ["b", 4], ["c", 6]])],
["e", 100],
["f", 12],
]));
a = setPath$(y, ["x", "b"], 40);
assertEquals(a, new Map<string, unknown>([
["x", new Map([["a", 2], ["b", 40], ["c", 6]])],
["e", 100],
["f", 12],
]));
a = setPath$(y, ["x", "b", "c"], 60);
assertEquals(a, new Map<string, unknown>([
["x", new Map([["a", 2], ["b", 40], ["c", 6]])],
["e", 100],
["f", 12],
])); // now effect
});
Deno.test("swap", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = swap(x, "a", "b");
assertEquals(a, new Map([["a", 2], ["b", 1], ["c", 3], ["d", 4]]));
a = swap(x, "a", "d");
assertEquals(a, new Map([["a", 4], ["b", 2], ["c", 3], ["d", 1]]));
});
Deno.test("swap$", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = swap$(x, "a", "b");
assertEquals(a, new Map([["a", 2], ["b", 1], ["c", 3], ["d", 4]]));
assertEquals(x, new Map([["a", 2], ["b", 1], ["c", 3], ["d", 4]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = swap$(x, "a", "d");
assertEquals(a, new Map([["a", 4], ["b", 2], ["c", 3], ["d", 1]]));
});
Deno.test("remove", () => {
let a;
const x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = remove(x, "b");
assertEquals(a, new Map([["a", 2], ["c", 6], ["d", 8]]));
a = remove(x, "d");
assertEquals(a, new Map([["a", 2], ["b", 4], ["c", 6]]));
});
Deno.test("remove$", () => {
let x, a;
x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = remove$(x, "b");
assertEquals(a, new Map([["a", 2], ["c", 6], ["d", 8]]));
assertEquals(x, new Map([["a", 2], ["c", 6], ["d", 8]]));
x = new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]);
a = remove$(x, "d");
assertEquals(a, new Map([["a", 2], ["b", 4], ["c", 6]]));
});
Deno.test("removePath$", () => {
let a;
const x = new Map<string, number>([["a", 2], ["b", 4], ["c", 6]]);
const y = new Map<string, unknown>([["x", x], ["e", 10], ["f", 12]]);
a = removePath$(y, ["e"]);
assertEquals(a, new Map<string, unknown>([
["x", new Map([["a", 2], ["b", 4], ["c", 6]])],
["f", 12],
]));
assertEquals(y, new Map<string, unknown>([
["x", new Map([["a", 2], ["b", 4], ["c", 6]])],
["f", 12],
]));
a = removePath$(y, ["x", "b"]);
assertEquals(a, new Map<string, unknown>([
["x", new Map([["a", 2], ["c", 6]])],
["f", 12],
]));
a = removePath$(y, ["x", "b", "c"]);
assertEquals(a, new Map<string, unknown>([
["x", new Map([["a", 2], ["c", 6]])],
["f", 12],
])); // no effect
});
// PROPERTY
// --------
Deno.test("count", () => {
let a;
const x = new Map([["a", 1], ["b", 1], ["c", 2], ["d", 2], ["e", 4]]);
a = count(x, v => v % 2 === 1);
assertEquals(a, 2);
a = count(x, v => v % 2 === 0);
assertEquals(a, 3);
});
Deno.test("countAs", () => {
let x, a;
x = new Map([["a", 1], ["b", 1], ["c", 2], ["d", 2], ["e", 4]]);
a = countAs(x);
assertEquals(a, new Map([[1, 2], [2, 2], [4, 1]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = countAs(x, v => v % 2);
assertEquals(a, new Map([[1, 2], [0, 2]]));
});
Deno.test("min", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = min(x);
assertEquals(a, -4);
a = min(x, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, 1);
a = min(x, null, v => Math.abs(v));
assertEquals(a, 1);
});
Deno.test("minEntry", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = minEntry(x);
assertEquals(a, ["d", -4]);
a = minEntry(x, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, ["a", 1]);
a = minEntry(x, null, v => Math.abs(v));
assertEquals(a, ["a", 1]);
});
Deno.test("max", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = max(x);
assertEquals(a, 2);
a = max(x, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, -4);
a = max(x, null, v => Math.abs(v));
assertEquals(a, -4);
});
Deno.test("maxEntry", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = maxEntry(x);
assertEquals(a, ["b", 2]);
a = maxEntry(x, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, ["d", -4]);
a = maxEntry(x, null, v => Math.abs(v));
assertEquals(a, ["d", -4]);
});
Deno.test("range", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = range(x);
assertEquals(a, [-4, 2]);
a = range(x, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, [1, -4]);
a = range(x, null, v => Math.abs(v));
assertEquals(a, [1, -4]);
});
Deno.test("rangeEntries", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = rangeEntries(x);
assertEquals(a, [["d", -4], ["b", 2]]);
a = rangeEntries(x, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, [["a", 1], ["d", -4]]);
a = rangeEntries(x, null, v => Math.abs(v));
assertEquals(a, [["a", 1], ["d", -4]]);
});
// PART
// ----
Deno.test("head", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = head(x);
assertEquals(a, ["a", 1]);
x = new Map<string, number>();
a = head(x);
assertEquals(a[0], undefined);
assertEquals(a[1], undefined);
});
Deno.test("tail", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = tail(x);
assertEquals(a, new Map([["b", 2], ["c", 3]]));
x = new Map([["a", 1]]);
a = tail(x);
assertEquals(a, new Map());
});
Deno.test("take", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = take(x, 2);
assertEquals(a, new Map([["a", 1], ["b", 2]]));
a = take(x, 3);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3]]));
});
Deno.test("take$", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = take$(x, 2);
assertEquals(a, new Map([["a", 1], ["b", 2]]));
assertEquals(x, new Map([["a", 1], ["b", 2]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = take$(x, 3);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3]]));
});
Deno.test("drop", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = drop(x, 2);
assertEquals(a, new Map([["c", 3], ["d", 4], ["e", 5]]));
a = drop(x, 3);
assertEquals(a, new Map([["d", 4], ["e", 5]]));
});
Deno.test("drop$", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = drop$(x, 2);
assertEquals(a, new Map([["c", 3], ["d", 4], ["e", 5]]));
assertEquals(x, new Map([["c", 3], ["d", 4], ["e", 5]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = drop$(x, 3);
assertEquals(a, new Map([["d", 4], ["e", 5]]));
});
// ARRANGEMENTS
// ------------
Deno.test("subsets", () => {
let x, a;
x = new Map([["a", 1], ["b", 2]]);
a = subsets(x);
assertEquals([...a], [
new Map(),
new Map([["a", 1]]),
new Map([["b", 2]]),
new Map([["a", 1], ["b", 2]]),
]);
x = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = subsets(x);
assertEquals([...a], [
new Map(),
new Map([["a", 1]]),
new Map([["b", 2]]),
new Map([["a", 1], ["b", 2]]),
new Map([["c", 3]]),
new Map([["a", 1], ["c", 3]]),
new Map([["b", 2], ["c", 3]]),
new Map([["a", 1], ["b", 2], ["c", 3]]),
]);
});
Deno.test("randomKey", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = randomKey(x);
assertEquals(has(x, a), true);
a = randomKey(x);
assertEquals(has(x, a), true);
});
Deno.test("randomEntry", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = randomEntry(x);
assertEquals(hasEntry(x, a), true);
a = randomEntry(x);
assertEquals(hasEntry(x, a), true);
});
Deno.test("randomSubset", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = randomSubset(x);
assertEquals(hasSubset(x, a), true);
a = randomSubset(x, 3);
assertEquals(hasSubset(x, a), true);
assertEquals(a.size, 3);
a = randomSubset(x, 2);
assertEquals(hasSubset(x, a), true);
assertEquals(a.size, 2);
});
// FIND
// ----
Deno.test("has", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3]]);
a = has(x, "d");
assertEquals(a, false);
a = has(x, "c");
assertEquals(a, true);
});
Deno.test("hasValue", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3]]);
a = hasValue(x, 3);
assertEquals(a, false);
a = hasValue(x, 3, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, true);
a = hasValue(x, 3, null, v => Math.abs(v));
assertEquals(a, true);
});
Deno.test("hasEntry", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3]]);
a = hasEntry(x, ["c", 3]);
assertEquals(a, false);
a = hasEntry(x, ["c", 3], (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, true);
a = hasEntry(x, ["c", 3], null, v => Math.abs(v));
assertEquals(a, true);
});
Deno.test("hasSubset", () => {
let y, a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
y = new Map([["b", 2], ["d", 4]]);
a = hasSubset(x, y);
assertEquals(a, true);
y = new Map([["b", -2], ["d", -4]]);
a = hasSubset(x, y);
assertEquals(a, false);
a = hasSubset(x, y, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, true);
a = hasSubset(x, y, null, v => Math.abs(v));
assertEquals(a, true);
});
Deno.test("find", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = find(x, v => v % 2 === 0);
assertEquals(a, 2);
a = find(x, v => v % 8 === 0);
assertEquals(a, undefined);
});
Deno.test("findAll", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = findAll(x, v => v % 2 === 0);
assertEquals(a, [2, 4]);
a = findAll(x, v => v % 8 === 0);
assertEquals(a, []);
});
Deno.test("search", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 2]]);
a = search(x, v => v === 2);
assertEquals(a, "b");
a = search(x, v => v === 4);
assertEquals(a, undefined);
});
Deno.test("searchAll", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", -2]]);
a = searchAll(x, v => v === 2);
assertEquals(a, ["b"]);
a = searchAll(x, v => Math.abs(v) === 2);
assertEquals(a, ["b", "d"]);
});
Deno.test("searchValue", () => {
let a;
const x = new Map([["a", 1], ["b", -2], ["c", 3], ["d", 2], ["e", 5]]);
a = searchValue(x, 2);
assertEquals(a, "d");
a = searchValue(x, 2, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, "b");
a = searchValue(x, 2, null, v => Math.abs(v));
assertEquals(a, "b");
});
Deno.test("searchValueAll", () => {
let a;
const x = new Map([["a", 1], ["b", -2], ["c", 3], ["d", 2], ["e", 5]]);
a = searchValueAll(x, 2);
assertEquals(a, ["d"]);
a = searchValueAll(x, 2, (a, b) => Math.abs(a) - Math.abs(b));
assertEquals(a, ["b", "d"]);
a = searchValueAll(x, 2, null, v => Math.abs(v));
assertEquals(a, ["b", "d"]);
});
// FUNCTIONAL
// ----------
Deno.test("forEach", () => {
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
const a: number[] = [];
forEach(x, v => a.push(v));
assertEquals(a, [1, 2, -3, -4]);
});
Deno.test("some", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = some(x, v => v > 10);
assertEquals(a, false);
a = some(x, v => v < 0);
assertEquals(a, true);
});
Deno.test("every", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", -3], ["d", -4]]);
a = every(x, v => v > 0);
assertEquals(a, false);
a = every(x, v => v > -10);
assertEquals(a, true);
});
Deno.test("map", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
const a = map(x, v => v * 2);
assertEquals(a, new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]));
});
Deno.test("map$", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
const a = map$(x, v => v * 2);
assertEquals(a, new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]));
assertEquals(x, new Map([["a", 2], ["b", 4], ["c", 6], ["d", 8]]));
});
Deno.test("reduce", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = reduce(x, (acc, v) => acc+v);
assertEquals(a, 10);
a = reduce(x, (acc, v) => acc+v, 100);
assertEquals(a, 110);
});
Deno.test("filter", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = filter(x, v => v % 2 === 1);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
a = filter(x, v => v % 2 === 0);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
});
Deno.test("filter$", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = filter$(x, v => v % 2 === 1);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
assertEquals(x, new Map([["a", 1], ["c", 3], ["e", 5]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = filter$(x, v => v % 2 === 0);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
});
Deno.test("filterAt", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = filterAt(x, ["a", "c", "e"]);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
a = filterAt(x, ["b", "d"]);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
});
Deno.test("filterAt$", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = filterAt$(x, ["a", "c", "e"]);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
assertEquals(x, new Map([["a", 1], ["c", 3], ["e", 5]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = filterAt$(x, ["b", "d"]);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
});
Deno.test("reject", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = reject(x, v => v % 2 === 1);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
a = reject(x, v => v % 2 === 0);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
});
Deno.test("reject$", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = reject$(x, v => v % 2 === 1);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
assertEquals(x, new Map([["b", 2], ["d", 4]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = reject$(x, v => v % 2 === 0);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
});
Deno.test("rejectAt", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = rejectAt(x, ["a", "c", "e"]);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
a = rejectAt(x, ["b", "d"]);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
});
Deno.test("rejectAt$", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = rejectAt$(x, ["a", "c", "e"]);
assertEquals(a, new Map([["b", 2], ["d", 4]]));
assertEquals(x, new Map([["b", 2], ["d", 4]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = rejectAt$(x, ["b", "d"]);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
});
Deno.test("flat", () => {
let a;
const x = new Map([
["ab", new Map([
["a", 1],
["b", 2],
])],
["cde", new Map<string, unknown>([
["c", 3],
["de", new Map<string, unknown>([
["d", 4],
["e", new Map([
["e", 5]
])],
])],
])],
]);
a = flat(x);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]));
a = flat(x, 1);
assertEquals(a, new Map<string, unknown>([
["a", 1],
["b", 2],
["c", 3],
["de", new Map<string, unknown>([["d", 4], ["e", new Map([["e", 5]])]])],
]));
a = flat(x, 2);
assertEquals(a, new Map<string, unknown>([
["a", 1],
["b", 2],
["c", 3],
["d", 4],
["e", new Map([["e", 5]])],
]));
});
Deno.test("flatMap", () => {
let a;
const x = new Map([
["ab", new Map([
["a", 1],
["b", 2],
])],
["cde", new Map<string, unknown>([
["c", 3],
["de", new Map<string, unknown>([
["d", 4],
["e", new Map([
["e", 5]
])],
])],
])],
]);
a = flatMap(x);
assertEquals(a, new Map<string, unknown>([
["a", 1],
["b", 2],
["c", 3],
["de", new Map<string, unknown>([["d", 4], ["e", new Map([["e", 5]])]])],
]));
a = flatMap(x, v => flat(v as Map<string, unknown>, 1));
assertEquals(a, new Map<string, unknown>([
["a", 1],
["b", 2],
["c", 3],
["d", 4],
["e", new Map([["e", 5]])],
]));
a = flatMap(x, v => flat(v as Map<string, unknown>));
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]));
});
Deno.test("zip", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
const y = new Map([["a", 10], ["b", 20]]);
a = zip([x, y]);
assertEquals(a, new Map([["a", [1, 10]], ["b", [2, 20]]])); // shortest
a = zip([x, y], ([a, b]) => a + b);
assertEquals(a, new Map([["a", 11], ["b", 22]]));
a = zip([x, y], null, xarray.some);
assertEquals(a, new Map([["a", [1, 10]], ["b", [2, 20]]])); // shortest
a = zip([x, y], null, xarray.every, 0);
assertEquals(a, new Map([["a", [1, 10]], ["b", [2, 20]], ["c", [3, 0]]])); // longest
});
// MANIPULATION
// ------------
Deno.test("partition", () => {
let x, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
a = partition(x, v => v % 2 == 0);
assertEquals(a, [
new Map([["b", 2], ["d", 4]]),
new Map([["a", 1], ["c", 3]]),
]);
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
a = partition(x, v => v % 2 == 1);
assertEquals(a, [
new Map([["a", 1], ["c", 3], ["e", 5]]),
new Map([["b", 2], ["d", 4]]),
]);
});
Deno.test("partitionAs", () => {
let x;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
const a = partitionAs(x, v => v % 2 == 0);
assertEquals(a, new Map([
[false, new Map([["a", 1], ["c", 3]])],
[true, new Map([["b", 2], ["d", 4]])],
]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
const b = partitionAs(x, v => v % 3);
assertEquals(b, new Map([
[1, new Map([["a", 1], ["d", 4]])],
[2, new Map([["b", 2], ["e", 5]])],
[0, new Map([["c", 3]])],
]));
});
Deno.test("chunk", () => {
let a;
const x = new Map([
["a", 1], ["b", 2], ["c", 3], ["d", 4],
["e", 5], ["f", 6], ["g", 7], ["h", 8]
]);
a = chunk(x, 3);
assertEquals(a, [
new Map([["a", 1], ["b", 2], ["c", 3]]),
new Map([["d", 4], ["e", 5], ["f", 6]]),
new Map([["g", 7], ["h", 8]]),
]);
a = chunk(x, 2, 3);
assertEquals(a, [
new Map([["a", 1], ["b", 2]]),
new Map([["d", 4], ["e", 5]]),
new Map([["g", 7], ["h", 8]]),
]);
a = chunk(x, 4, 3);
assertEquals(a, [
new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]),
new Map([["d", 4], ["e", 5], ["f", 6], ["g", 7]]),
new Map([["g", 7], ["h", 8]]),
]);
});
// COMBINE
// -------
Deno.test("concat", () => {
let a;
const x = new Map([["a", 1], ["b", 2]]);
const y = new Map([["c", 3], ["d", 4]]);
a = concat(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]));
const z = new Map([["d", 40], ["e", 50]]);
a = concat(x, y, z);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 40], ["e", 50]]));
});
Deno.test("concat$", () => {
let x, y, a;
x = new Map([["a", 1], ["b", 2]]);
y = new Map([["c", 3], ["d", 4]]);
a = concat$(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]));
assertEquals(x, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]));
x = new Map([["a", 1], ["b", 2]]);
y = new Map([["c", 3], ["d", 4]]);
const z = new Map([["d", 40], ["e", 50]]);
a = concat$(x, y, z);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 40], ["e", 50]]));
});
Deno.test("join", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
a = join(x);
assertEquals(a, "a=1,b=2,c=3");
a = join(x, ", ", " => ");
assertEquals(a, "a => 1, b => 2, c => 3");
});
// SET OPERATIONS
// --------------
Deno.test("isDisjoint", () => {
let y, a;
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
y = new Map([["c", 3], ["d", 4]]);
a = isDisjoint(x, y);
assertEquals(a, false);
y = new Map([["d", 4]]);
a = isDisjoint(x, y);
assertEquals(a, true);
});
Deno.test("unionKeys", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
const y = new Map([["b", 20], ["c", 30], ["e", 50]]);
const a = unionKeys(x, y);
assertEquals(a, new Set(["a", "b", "c", "d", "e"]));
});
Deno.test("union", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
const y = new Map([["b", 20], ["c", 30], ["d", 40]]);
a = union(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 40]]));
a = union(x, y, (_a, b) => b);
assertEquals(a, new Map([["a", 1], ["b", 20], ["c", 30], ["d", 40]]));
});
Deno.test("union$", () => {
let x, y, a;
x = new Map([["a", 1], ["b", 2], ["c", 3]]);
y = new Map([["b", 20], ["c", 30], ["d", 40]]);
a = union$(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 40]]));
assertEquals(x, new Map([["a", 1], ["b", 2], ["c", 3], ["d", 40]]));
x = new Map([["a", 1], ["b", 2], ["c", 3]]);
y = new Map([["b", 20], ["c", 30], ["d", 40]]);
a = union$(x, y, (_a, b) => b);
assertEquals(a, new Map([["a", 1], ["b", 20], ["c", 30], ["d", 40]]));
});
Deno.test("intersectionKeys", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
const y = new Map([["b", 20], ["c", 30], ["e", 50]]);
const a = intersectionKeys(x, y);
assertEquals(a, new Set(["b", "c"]));
});
Deno.test("intersection", () => {
let a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
const y = new Map([["b", 20], ["c", 30], ["e", 50]]);
a = intersection(x, y);
assertEquals(a, new Map([["b", 2], ["c", 3]]));
a = intersection(x, y, (_a, b) => b);
assertEquals(a, new Map([["b", 20], ["c", 30]]));
});
Deno.test("intersection$", () => {
let x, y, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
y = new Map([["b", 20], ["c", 30], ["e", 50]]);
a = intersection$(x, y);
assertEquals(a, new Map([["b", 2], ["c", 3]]));
assertEquals(x, new Map([["b", 2], ["c", 3]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
y = new Map([["b", 20], ["c", 30], ["e", 50]]);
a = intersection$(x, y, (_a, b) => b);
assertEquals(a, new Map([["b", 20], ["c", 30]]));
});
Deno.test("difference", () => {
let y, a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
y = new Map([["b", 2], ["d", 4]]);
a = difference(x, y);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
y = new Map([["b", -2], ["d", -4]]);
a = difference(x, y);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
});
Deno.test("difference$", () => {
let x, y, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
y = new Map([["b", 2], ["d", 4]]);
a = difference$(x, y);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
assertEquals(x, new Map([["a", 1], ["c", 3], ["e", 5]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4], ["e", 5]]);
y = new Map([["b", -2], ["d", -4]]);
a = difference$(x, y);
assertEquals(a, new Map([["a", 1], ["c", 3], ["e", 5]]));
});
Deno.test("symmetricDifference", () => {
let y, a;
const x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
y = new Map([["c", 30], ["d", 40], ["e", 50], ["f", 60]]);
a = symmetricDifference(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["e", 50], ["f", 60]]));
y = new Map([["d", 40], ["e", 50], ["f", 60]]);
a = symmetricDifference(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["e", 50], ["f", 60]]));
});
Deno.test("symmetricDifference$", () => {
let x, y, a;
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
y = new Map([["c", 30], ["d", 40], ["e", 50], ["f", 60]]);
a = symmetricDifference$(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["e", 50], ["f", 60]]));
assertEquals(x, new Map([["a", 1], ["b", 2], ["e", 50], ["f", 60]]));
x = new Map([["a", 1], ["b", 2], ["c", 3], ["d", 4]]);
y = new Map([["d", 40], ["e", 50], ["f", 60]]);
a = symmetricDifference$(x, y);
assertEquals(a, new Map([["a", 1], ["b", 2], ["c", 3], ["e", 50], ["f", 60]]));
});
Deno.test("cartesianProduct", () => {
const x = new Map([["a", 1], ["b", 2], ["c", 3]]);
const y = new Map([["d", 10], ["e", 20]]);
const a = cartesianProduct([x, y]);
assertEquals([...a], [
new Map([["a", 1], ["d", 10]]),
new Map([["a", 1], ["e", 20]]),
new Map([["b", 2], ["d", 10]]),
new Map([["b", 2], ["e", 20]]),
new Map([["c", 3], ["d", 10]]),
new Map([["c", 3], ["e", 20]]),
]);
const b = cartesianProduct([x, y], a => maxEntry(a));
assertEquals([...b], [
["d", 10],
["e", 20],
["d", 10],
["e", 20],
["d", 10],
["e", 20],
]);
});