extra-object/index.d.ts

A collection of methods for working with Objects.<br>

/** A dictionary is a mapping of string keys to unknown values. */ export type Dictionary = Record<string, unknown>;
export type { Dictionary as Dict };
/** Entries is a list of key-value pairs, with unique keys (indices). */ export type Entries = Iterable<[string, unknown]>;
/** Lists is a pair of key list and value list, with unique keys (indices). */ export type Lists = [Iterable<string>, Iterable<unknown>];
/**
 * Handle reading of a single value.
 * @returns value
 */ export type ReadFunction<T> = () => T;
/**
 * Handle combining of two values.
 * @param a a value
 * @param b another value
 * @returns combined value
 */ export type CombineFunction = (a: unknown, b: unknown) => unknown;
/**
 * Handle comparison of two values.
 * @param a a value
 * @param b another value
 * @returns a<b: -ve, a=b: 0, a>b: +ve
 */ export type CompareFunction = (a: unknown, b: unknown) => number;
/**
 * Handle processing of values in an object.
 * @param v value in object
 * @param k key of value in object
 * @param x object containing the value
 */ export type ProcessFunction = (v: unknown, k: string, x: Dictionary) => void;
/**
 * Handle selection of entries in an object.
 * @param v value in object
 * @param k key of value in object
 * @param x object containing the value
 * @returns selected?
 */ export type TestFunction = (v: unknown, k: string, x: Dictionary) => boolean;
/**
 * Handle transformation of a value to another.
 * @param v value in object
 * @param k key of value in object
 * @param x object containing the value
 * @returns transformed value
 */ export type MapFunction = (v: unknown, k: string, x: Dictionary | null) => unknown;
/**
 * Handle reduction of multiple values into a single value.
 * @param acc accumulator (temporary result)
 * @param v value in object
 * @param k key of value in object
 * @param x object containing the value
 * @returns reduced value
 */ export type ReduceFunction = (acc: unknown, v: unknown, k: string, x: Dictionary) => unknown;
/**
 * Handle ending of a combined object.
 * @param dones iᵗʰ object done?
 * @returns combined object done?
 */ export type EndFunction = (dones: boolean[]) => boolean;
/**
 * Check if value is a dictionary.
 * @param v a value
 * @returns v is a dictionary?
 */ export declare function is(v: unknown): v is Dictionary;
/**
 * List all keys.
 * @param x an object
 * @returns k₀, k₁, ... | [kᵢ, vᵢ] ∈ x
 */ export declare function keys(x: Dictionary): Iterable<string>;
/**
 * List all values.
 * @param x an object
 * @returns v₀, v₁, ... | [kᵢ, vᵢ] ∈ x
 */ export declare function values(x: Dictionary): Iterable<unknown>;
/**
 * List all key-value pairs.
 * @param x an object
 * @returns [k₀, v₀], [k₁, v₁], ... | [kᵢ, vᵢ] ∈ x
 */ export declare function entries(x: Dictionary): Entries;
/**
 * Convert entries to object.
 * @param x entries
 * @returns x as object
 */ export declare function fromEntries(x: Entries): Dictionary;
/**
 * Convert lists to object.
 * @param x lists, i.e. [keys, values]
 * @returns x as object
 */ export declare function fromLists(x: Lists): Dictionary;
/**
 * Compare two objects.
 * @param x an object
 * @param y another object
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns x=y: 0, otherwise: -ve/+ve
 */ export declare function compare(x: Dictionary, y: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): number;
/**
 * Check if two objects are equal.
 * @param x an object
 * @param y another object
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns fm(x[kᵢ]) ≈ fm(y[kᵢ]) ∀ kᵢ ∈ x, y
 */ export declare function isEqual(x: Dictionary, y: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): boolean;
/**
 * Get the number of keys in an object.
 * @param x an object
 * @returns |x|
 */ export declare function size(x: Dictionary): number;
export { size as length };
/**
 * Check if an object is empty.
 * @param x an object
 * @returns |x| = 0?
 */ export declare function isEmpty(x: Dictionary): boolean;
/**
 * Get value at specified key.
 * @param x an object
 * @param k key
 * @returns x[k]
 */ export declare function get(x: Dictionary, k: string): unknown;
/**
 * Get values at keys.
 * @param x an object
 * @param ks keys
 * @returns [x[k], x[l], ...] | [k, l, ...] = ks
 */ export declare function getAll(x: Dictionary, ks: string[]): unknown[];
/**
 * Get value at path in a nested object.
 * @param x a nested object
 * @param p path
 * @returns x[k₀][k₁][...] | [k₀, k₁, ...] = p
 */ export declare function getPath(x: Dictionary, p: string[]): unknown;
/**
 * Check if nested object has a path.
 * @param x a nested object
 * @param p path
 * @returns x[k₀][k₁][...] exists? | [k₀, k₁, ...] = p
 */ export declare function hasPath(x: Dictionary, p: string[]): boolean;
/**
 * Set value at specified key.
 * @param x an object
 * @param k key
 * @param v value
 * @returns x' | x' = x; x'[k] = v
 */ export declare function set(x: Dictionary, k: string, v: unknown): Dictionary;
/**
 * Set value at specified key.
 * @param x an object (updated)
 * @param k key
 * @param v value
 * @returns x | x[k] = v
 */ export declare function set$(x: Dictionary, k: string, v: unknown): Dictionary;
/**
 * Set value at path in a nested object.
 * @param x a nested object (updated)
 * @param p path
 * @param v value
 * @returns x | x[k₀][k₁][...] = v; [k₀, k₁, ...] = p
 */ export declare function setPath$(x: Dictionary, p: string[], v: unknown): Dictionary;
/**
 * Exchange two values in an object.
 * @param x an object
 * @param k a key
 * @param l another key
 * @returns x' | x' = x; x'[k] = x[l]; x'[l] = x[k]
 */ export declare function swap(x: Dictionary, k: string, l: string): Dictionary;
/**
 * Exchange two values in an object.
 * @param x an object (updated)
 * @param k a key
 * @param l another key
 * @returns x | x[i] ↔ x[j]
 */ export declare function swap$(x: Dictionary, k: string, l: string): Dictionary;
/**
 * Remove an entry from object.
 * @param x an object
 * @param k key
 * @returns x \\: [k]
 */ export declare function remove(x: Dictionary, k: string): Dictionary;
/**
 * Remove an entry from object.
 * @param x an object (updated)
 * @param k key
 * @returns x = x \\: [k]
 */ export declare function remove$(x: Dictionary, k: string): Dictionary;
/**
 * Remove value at path in a nested object.
 * @param x a nested object (updated)
 * @param p path
 * @returns x = x \\: [k₀][k₁][...] | [k₀, k₁, ...] = p
 */ export declare function removePath$(x: Dictionary, p: string[]): Dictionary;
/**
 * Count values which satisfy a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; [kᵢ, vᵢ] ∈ x
 */ export declare function count(x: Dictionary, ft: TestFunction): number;
/**
 * Count occurrences of values.
 * @param x an object
 * @param fm map function (v, k, x)
 * @returns Map \{value ⇒ count\}
 */ export declare function countAs(x: Dictionary, fm?: MapFunction | null): Map<unknown, number>;
/**
 * Find smallest value.
 * @param x an object
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns v | v ≤ vᵢ; [kᵢ, vᵢ] ∈ x
 */ export declare function min(x: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): unknown;
/**
 * Find smallest entry.
 * @param x an object
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [min_key, min_value]
 */ export declare function minEntry(x: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): [string, unknown];
/**
 * Find largest value.
 * @param x an object
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns v | v ≥ vᵢ; [kᵢ, vᵢ] ∈ x
 */ export declare function max(x: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): unknown;
/**
 * Find largest entry.
 * @param x an object
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [max_key, max_value]
 */ export declare function maxEntry(x: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): [string, unknown];
/**
 * Find smallest and largest values.
 * @param x a map
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [min_value, max_value]
 */ export declare function range(x: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): [unknown, unknown];
/**
 * Find smallest and largest entries.
 * @param x an object
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [min_entry, max_entry]
 */ export declare function rangeEntries(x: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): [[string, unknown], [string, unknown]];
/**
 * Gets first entry from object (default order).
 * @param x an object
 * @param ed default entry
 * @returns [k₀, v₀] if x ≠ Φ else ed | [k₀, v₀] ∈ x
 */ export declare function head(x: Dictionary, ed?: [string, unknown]): [string, unknown];
/**
 * Get object without its first entry (default order).
 * @param x an object
 * @returns x \\ \{[k₀, v₀]\} if x ≠ Φ else x | [k₀, v₀] ∈ x
 */ export declare function tail(x: Dictionary): Dictionary;
/**
 * Keep first n entries only (default order).
 * @param x an object
 * @param n number of entries [1]
 * @returns \{[k₀, v₀], [k₁, v₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[k₀, v₀], [k₁, v₁], ...\}| ≤ n
 */ export declare function take(x: Dictionary, n?: number): Dictionary;
/**
 * Keep first n entries only (default order).
 * @param x an object (updated)
 * @param n number of entries [1]
 * @returns x = \{[k₀, v₀], [k₁, v₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[k₀, v₀], [k₁, v₁], ...\}| ≤ n
 */ export declare function take$(x: Dictionary, n?: number): Dictionary;
/**
 * Remove first n entries (default order).
 * @param x an object
 * @param n number of entries [1]
 * @returns \{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\}| ≤ max(|x| - n, 0)
 */ export declare function drop(x: Dictionary, n?: number): Dictionary;
/**
 * Remove first n entries (default order).
 * @param x an object (updated)
 * @param n number of entries [1]
 * @returns x = \{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\} | [kᵢ, vᵢ] ∈ x and |\{[kₙ, vₙ], [kₙ₊₁, vₙ₊₁], ...\}| ≤ max(|x| - n, 0)
 */ export declare function drop$(x: Dictionary, n?: number): Dictionary;
/**
 * List all possible subsets.
 * @param x an object
 * @param n number of entries [-1 ⇒ any]
 * @returns entries selected by bit from 0..2^|x| if n<0; only of length n otherwise
 */ export declare function subsets(x: Dictionary, n?: number): IterableIterator<object>;
/**
 * Pick an arbitrary key.
 * @param x an object
 * @param fr random number generator ([0, 1))
 * @returns kᵢ | [kᵢ, vᵢ] ∈ x
 */ export declare function randomKey(x: Dictionary, fr?: ReadFunction<number> | null): string;
export { randomKey as key };
/**
 * Pick an arbitrary entry.
 * @param x an object
 * @param fr random number generator ([0, 1))
 * @returns [kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x
` */ export declare function randomEntry(x: Dictionary, fr?: ReadFunction<number> | null): [string, unknown];
export { randomEntry as entry };
/**
 * Pick an arbitrary subset.
 * @param x an object
 * @param n number of entries [-1 ⇒ any]
 * @param fr random number generator ([0, 1))
 * @returns \{[kᵢ, vᵢ], [kⱼ, vⱼ], ...\} | [kᵢ, vᵢ], [kⱼ, vⱼ], ... ∈ x; |\{[kᵢ, vᵢ], [kⱼ, vⱼ], ...\}| = |x| if n<0 else n
 */ export declare function randomSubset(x: Dictionary, n?: number, fr?: ReadFunction<number> | null): Dictionary;
export { randomSubset as subset };
/**
 * Check if object has a key.
 * @param x an object
 * @param k search key
 * @returns [k, *] ∈ x?
 */ export declare function has(x: Dictionary, k: string): boolean;
export { has as hasKey };
/**
 * Check if object has a value.
 * @param x an object
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [*, v] ∈ x?
 */ export declare function hasValue(x: Dictionary, v: unknown, fc?: CompareFunction | null, fm?: MapFunction | null): boolean;
/**
 * Check if object has an entry.
 * @param x an object
 * @param e search entry ([k, v])
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [k, v] ∈ x? | [k, v] = e
 */ export declare function hasEntry(x: Dictionary, e: [string, unknown], fc?: CompareFunction | null, fm?: MapFunction | null): boolean;
/**
 * Check if object has a subset.
 * @param x an object
 * @param y search subset
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns y ⊆ x?
 */ export declare function hasSubset(x: Dictionary, y: Dictionary, fc?: CompareFunction | null, fm?: MapFunction | null): boolean;
/**
 * Find value of an entry passing a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns v | ft(v) = true; [k, v] ∈ x
 */ export declare function find(x: Dictionary, ft: TestFunction): unknown;
/**
 * Find values of entries passing a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns [vₒ, v₁, ...] | ft(vᵢ) = true; [kᵢ, vᵢ] ∈ x
 */ export declare function findAll(x: Dictionary, ft: TestFunction): unknown[];
/**
 * Find key of an entry passing a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns k | ft(x[k]) passes
 */ export declare function search(x: Dictionary, ft: TestFunction): string | null;
/**
 * Find all keys of entries passing a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns [k₀, k₁, ...] | ft(x[kᵢ]) passes
 */ export declare function searchAll(x: Dictionary, ft: TestFunction): string[];
/**
 * Find key with a given value.
 * @param x an object
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns k | fm(x[k]) ≈ fm(v)
 */ export declare function searchValue(x: Dictionary, v: unknown, fc?: CompareFunction | null, fm?: MapFunction | null): string | null;
/**
 * Find keys with a given value.
 * @param x an object
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, k, x)
 * @returns [k₀, k₁, ...] | fm(x[kᵢ]) ≈ fm(v)
 */ export declare function searchValueAll(x: Dictionary, v: unknown, fc?: CompareFunction | null, fm?: MapFunction | null): string[];
/**
 * Call a function for each entry.
 * @param x an object
 * @param fp called function (v, k, x)
 */ export declare function forEach(x: Dictionary, fp: ProcessFunction): void;
/**
 * Check if any value satisfies a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns true if ft(vᵢ) = true for some [kᵢ, vᵢ] ∈ x
 */ export declare function some(x: Dictionary, ft?: TestFunction | null): boolean;
/**
 * Check if all values satisfy a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns true if ft(vᵢ) = true for all [kᵢ, vᵢ] ∈ x
 */ export declare function every(x: Dictionary, ft: TestFunction): boolean;
/**
 * Transform values of an object.
 * @param x an object
 * @param fm map function (v, k, x)
 * @returns \{[k₀, fm(v₀)], [k₁, fm(v₁)], ...\} | [kᵢ, vᵢ] ∈ x
 */ export declare function map(x: Dictionary, fm: MapFunction): Dictionary;
/**
 * Transform values of an object.
 * @param x an object (updated)
 * @param fm map function (v, k, x)
 * @returns x = \{[k₀, fm(v₀)], [k₁, fm(v₁)], ...\} | [kᵢ, vᵢ] ∈ x
 */ export declare function map$(x: Dictionary, fm: MapFunction): Dictionary;
/**
 * Reduce values to a single value.
 * @param x an object
 * @param fr reduce function (acc, v, k, x)
 * @param acc initial value
 * @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given
 */ export declare function reduce(x: Dictionary, fr: ReduceFunction, acc?: unknown): unknown;
/**
 * Keep entries which pass a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns \{[k₀, v₀], [k₁, v₁], ...\} | ft(vᵢ) = true; [kᵢ, vᵢ] ∈ x
 */ export declare function filter(x: Dictionary, ft: TestFunction): Dictionary;
/**
 * Keep entries which pass a test.
 * @param x an object (updated)
 * @param ft test function (v, k, x)
 * @returns x = \{[k₀, v₀], [k₁, v₁], ...\} | ft(vᵢ) = true; [kᵢ, vᵢ] ∈ x
 */ export declare function filter$(x: Dictionary, ft: TestFunction): Dictionary;
/**
 * Get object with given keys.
 * @param x an object
 * @param ks keys
 * @returns \{[k₀, v₀], [k₁, v₁], ...\} | kᵢ ∈ ks; [kᵢ, vᵢ] ∈ x
 */ export declare function filterAt(x: Dictionary, ks: string[]): Dictionary;
/**
 * Get object with given keys.
 * @param x an object (updated)
 * @param ks keys
 * @returns x = \{[k₀, v₀], [k₁, v₁], ...\} | kᵢ ∈ ks; [kᵢ, vᵢ] ∈ x
 */ export declare function filterAt$(x: Dictionary, ks: string[]): Dictionary;
/**
 * Discard entries which pass a test.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns \{[k₀, v₀], [k₁, v₁], ...\} | ft(vᵢ) = false; [kᵢ, vᵢ] ∈ x
 */ export declare function reject(x: Dictionary, ft: TestFunction): Dictionary;
/**
 * Discard entries which pass a test.
 * @param x an object (updated)
 * @param ft test function (v, k, x)
 * @returns x = \{[k₀, v₀], [k₁, v₁], ...\} | ft(vᵢ) = false; [kᵢ, vᵢ] ∈ x
 */ export declare function reject$(x: Dictionary, ft: TestFunction): Dictionary;
/**
 * Get object without given keys.
 * @param x an object
 * @param ks keys
 * @returns \{[k₀, v₀], [k₁, v₁], ...\} | kᵢ ∉ ks; [kᵢ, vᵢ] ∈ x
 */ export declare function rejectAt(x: Dictionary, ks: string[]): Dictionary;
/**
 * Get object without given keys.
 * @param x an object (updated)
 * @param ks keys
 * @returns x = \{[k₀, v₀], [k₁, v₁], ...\} | kᵢ ∉ ks; [kᵢ, vᵢ] ∈ x
 */ export declare function rejectAt$(x: Dictionary, ks: string[]): Dictionary;
/**
 * Flatten nested object to given depth.
 * @param x a nested object
 * @param n maximum depth [-1 ⇒ all]
 * @param fm map function (v, k, x)
 * @param ft test function for flatten (v, k, x)
 * @returns flat map
 */ export declare function flat(x: Dictionary, n?: number, fm?: MapFunction | null, ft?: TestFunction | null): Dictionary;
/**
 * Flatten nested object, using map function.
 * @param x a nested object
 * @param fm map function (v, k, x)
 * @param ft test function (v, k, x)
 * @returns flat map
 */ export declare function flatMap(x: Dictionary, fm?: MapFunction | null, ft?: TestFunction | null): Dictionary;
/**
 * Combine matching entries from objects.
 * @param xs objects
 * @param fm map function (vs, k)
 * @param fe end function (dones) [array.some]
 * @param vd default value
 * @returns \{"k₀": fm([x₀[k₀], x₁[k₀], ...]), "k₁": fm([x₀[k₁], x₁[k₁], ...]), ...\}
 */ export declare function zip(xs: Dictionary[], fm?: MapFunction | null, fe?: EndFunction | null, vd?: unknown): Dictionary;
/**
 * Segregate entries by test result.
 * @param x an object
 * @param ft test function (v, k, x)
 * @returns [satisfies, doesnt]
 */ export declare function partition(x: Dictionary, ft: TestFunction): [object, object];
/**
 * Segregate entries by similarity.
 * @param x an object
 * @param fm map function (v, k, x)
 * @returns Map \{key ⇒ values\}
 */ export declare function partitionAs(x: Dictionary, fm: MapFunction): Map<unknown, object>;
/**
 * Break object into chunks of given size.
 * @param x an object
 * @param n chunk size [1]
 * @param s chunk step [n]
 * @returns [x[0..n], x[s..s+n], x[2s..2s+n], ...]
 */ export declare function chunk(x: Dictionary, n?: number, s?: number): Dictionary[];
/**
 * Combine entries from objects, preferring last.
 * @param xs objects
 * @returns x₀ ∪ x₁ ∪ ... | [x₀, x₁, ...] = xs
 */ export declare function concat(...xs: Dictionary[]): Dictionary;
/**
 * Combines entries from objects, preferring last.
 * @param x an object (updated)
 * @param ys other objects
 * @returns x = x ∪ y₀ ∪ y₁ ∪ ... | [y₀, y₁, ...] = ys
 */ export declare function concat$(x: Dictionary, ...ys: Dictionary[]): Dictionary;
/**
 * Join entries together into a string.
 * @param x an object
 * @param sep separator [,]
 * @param asc associator [=]
 * @returns "k₀=v₀,k₁=v₁,..." | [kᵢ, vᵢ] ∈ x
 */ export declare function join(x: Dictionary, sep?: string, asc?: string): string;
/**
 * Check if objects have no common keys.
 * @param x an object
 * @param y another object
 * @returns x ∩ y = Φ?
 */ export declare function isDisjoint(x: Dictionary, y: Dictionary): boolean;
/**
 * Obtain keys present in any object.
 * @param xs objects
 * @returns [k₀, k₁, ...] | [kᵢ, vᵢ] ∈ x₀ ∪ x₁, ...; [x₀, x₁, ...] = xs
 */ export declare function unionKeys(...xs: Dictionary[]): Set<string>;
/**
 * Obtain entries present in any object.
 * @param x an object
 * @param y another object
 * @param fc combine function (a, b)
 * @returns x ∪ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x or [kᵢ, vᵢ] ∈ y\}
 */ export declare function union(x: Dictionary, y: Dictionary, fc?: CombineFunction | null): Dictionary;
/**
 * Obtain entries present in any object.
 * @param x an object (updated)
 * @param y another object
 * @param fc combine function (a, b)
 * @returns x = x ∪ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x or [kᵢ, vᵢ] ∈ y\}
 */ export declare function union$(x: Dictionary, y: Dictionary, fc?: CombineFunction | null): Dictionary;
/**
 * Obtain keys present in all objects.
 * @param xs objects
 * @returns [k₀, k₁, ...] | [kᵢ, vᵢ] ∈ x₀ ∩ x₁, ...; [x₀, x₁, ...] = xs
 */ export declare function intersectionKeys(...xs: Dictionary[]): Set<string>;
/**
 * Obtain entries present in both objects.
 * @param x an object
 * @param y another object
 * @param fc combine function (a, b)
 * @returns x ∩ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x and [kᵢ, vᵢ] ∈ y\}
 */ export declare function intersection(x: Dictionary, y: Dictionary, fc?: CombineFunction | null): Dictionary;
/**
 * Obtain entries present in both objects.
 * @param x an object (updated)
 * @param y another object
 * @param fc combine function (a, b)
 * @returns x = x ∩ y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x and [kᵢ, vᵢ] ∈ y\}
 */ export declare function intersection$(x: Dictionary, y: Dictionary, fc?: CombineFunction | null): Dictionary;
/**
 * Obtain entries not present in another object.
 * @param x an object
 * @param y another object
 * @returns x - y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x, [kᵢ, *] ∉ y\}
 */ export declare function difference(x: Dictionary, y: Dictionary): Dictionary;
/**
 * Obtain entries not present in another object.
 * @param x an object (updated)
 * @param y another object
 * @returns x = x - y = \{[kᵢ, vᵢ] | [kᵢ, vᵢ] ∈ x, [kᵢ, *] ∉ y\}
 */ export declare function difference$(x: Dictionary, y: Dictionary): Dictionary;
/**
 * Obtain entries not present in both objects.
 * @param x an object
 * @param y another object
 * @returns x-y ∪ y-x
 */ export declare function symmetricDifference(x: Dictionary, y: Dictionary): Dictionary;
/**
 * Obtain entries not present in both objects.
 * @param x an object (updated)
 * @param y another object
 * @returns x = x-y ∪ y-x
 */ export declare function symmetricDifference$(x: Dictionary, y: Dictionary): Dictionary;
/**
 * List cartesian product of objects.
 * @param xs objects
 * @param fm map function (vs)
 * @returns x₀ × x₁ × ... = \{\{[k₀, v₀], [k₁, v₁], ...\} | [k₀, v₀] ∈ x₀, [k₁, v₁] ∈ x₁, ...]\}
 */ export declare function cartesianProduct(xs: Dictionary[], fm?: MapFunction | null): IterableIterator<unknown>;