@nlozgachev/pipelined 0.65.0 → 0.67.0

package/dist/data.mjs

@@ -1,50 +1,93 @@
-import { S as Deferred, _ as Maybe, i as isNonEmptyArr, s as Result } from "./Core-BHN87zoB.mjs";
+import { S as Deferred, g as Maybe, i as isNonEmptyArr, n as Task, o as Result, r as Validation } from "./Core-BCN6WRzp.mjs";
 //#region src/Data/Arr.ts
 let ArrMaybe;
 (function(_ArrMaybe) {
-	const traverse = _ArrMaybe.traverse = (f) => (data) => {
-		const n = data.length;
+	const traverse = _ArrMaybe.traverse = (transform) => (items) => {
+		const n = items.length;
 		const result = new Array(n);
 		for (let i = 0; i < n; i++) {
-			const mapped = f(data[i]);
+			const mapped = transform(items[i]);
 			if (mapped.kind === "None") return Maybe.make.none();
 			result[i] = mapped.value;
 		}
 		return Maybe.make.some(result);
 	};
-	_ArrMaybe.sequence = (data) => traverse((a) => a)(data);
+	_ArrMaybe.sequence = (items) => traverse((item) => item)(items);
 })(ArrMaybe || (ArrMaybe = {}));
 let ArrResult;
 (function(_ArrResult) {
-	const traverse = _ArrResult.traverse = (f) => (data) => {
-		const n = data.length;
+	const traverse = _ArrResult.traverse = (transform) => (items) => {
+		const n = items.length;
 		const result = new Array(n);
 		for (let i = 0; i < n; i++) {
-			const mapped = f(data[i]);
+			const mapped = transform(items[i]);
 			if (mapped.kind === "Err") return mapped;
 			result[i] = mapped.value;
 		}
 		return Result.make.ok(result);
 	};
-	_ArrResult.sequence = (data) => traverse((a) => a)(data);
+	_ArrResult.sequence = (items) => traverse((item) => item)(items);
 })(ArrResult || (ArrResult = {}));
+let ArrValidation;
+(function(_ArrValidation) {
+	const traverse = _ArrValidation.traverse = (transform) => (items) => {
+		const n = items.length;
+		const result = new Array(n);
+		const errors = [];
+		for (let i = 0; i < n; i++) {
+			const mapped = transform(items[i]);
+			if (Validation.is.failed(mapped)) errors.push(...mapped.errors);
+			else if (errors.length === 0) result[i] = mapped.value;
+		}
+		return isNonEmptyArr(errors) ? Validation.make.failedAll(errors) : Validation.make.passed(result);
+	};
+	_ArrValidation.sequence = (items) => traverse((item) => item)(items);
+})(ArrValidation || (ArrValidation = {}));
 let ArrTaskResult;
 (function(_ArrTaskResult) {
-	const traverse = _ArrTaskResult.traverse = (f) => (data) => () => Deferred.from.Promise((async () => {
-		const result = [];
-		for (const a of data) {
-			const r = await Deferred.to.Promise(f(a)());
-			if (Result.is.err(r)) return r;
-			result.push(r.value);
+	const traverse = _ArrTaskResult.traverse = (transform, options) => (items) => (signal) => Deferred.from.Promise((async () => {
+		const concurrency = options?.concurrency;
+		const len = items.length;
+		if (concurrency === void 0 || concurrency <= 1 || len <= 1) {
+			const result = [];
+			for (const a of items) {
+				const r = await Deferred.to.Promise(transform(a)(signal));
+				if (Result.is.err(r)) return r;
+				result.push(r.value);
+			}
+			return Result.make.ok(result);
 		}
-		return Result.make.ok(result);
+		return new Promise((resolve) => {
+			const results = new Array(len);
+			let nextIndex = 0;
+			let settled = false;
+			const worker = async () => {
+				while (nextIndex < len && !settled) {
+					const currentIndex = nextIndex++;
+					const r = await Deferred.to.Promise(transform(items[currentIndex])(signal));
+					if (settled) return;
+					if (Result.is.err(r)) {
+						settled = true;
+						resolve(r);
+						return;
+					}
+					results[currentIndex] = r.value;
+				}
+			};
+			const workerCount = Math.min(concurrency, len);
+			const workers = [];
+			for (let i = 0; i < workerCount; i++) workers.push(worker());
+			Promise.all(workers).then(() => {
+				if (!settled) resolve(Result.make.ok(results));
+			});
+		});
 	})());
-	_ArrTaskResult.sequence = (data) => traverse((a) => a)(data);
+	_ArrTaskResult.sequence = (items) => traverse((item) => item)(items);
 })(ArrTaskResult || (ArrTaskResult = {}));
 let ArrTask;
 (function(_ArrTask) {
-	const traverse = _ArrTask.traverse = (f) => (data) => () => Deferred.from.Promise(Promise.all(data.map((a) => Deferred.to.Promise(f(a)()))));
-	_ArrTask.sequence = (data) => traverse((a) => a)(data);
+	const traverse = _ArrTask.traverse = (transform, options) => (items) => Task.all(items.map(transform), options);
+	_ArrTask.sequence = (items) => traverse((item) => item)(items);
 	_ArrTask.Result = ArrTaskResult;
 })(ArrTask || (ArrTask = {}));
 /**
@@ -74,96 +117,118 @@ let ArrTask;
 /**
 * Returns the first element of an array, or None if the array is empty.
 *
+* @see {@link last} for accessing the final element.
+* @see {@link tail} for all elements except the first.
+*
 * @example
 * ```ts
 * Arr.head([1, 2, 3]); // Some(1)
 * Arr.head([]); // None
 * ```
 */
-const head = (data) => data.length > 0 ? Maybe.make.some(data[0]) : Maybe.make.none();
+const head = (items) => items.length > 0 ? Maybe.make.some(items[0]) : Maybe.make.none();
 /**
 * Returns the last element of an array, or None if the array is empty.
 *
+* @see {@link head} for accessing the first element.
+* @see {@link init} for all elements except the last.
+*
 * @example
 * ```ts
 * Arr.last([1, 2, 3]); // Some(3)
 * Arr.last([]); // None
 * ```
 */
-const last = (data) => data.length > 0 ? Maybe.make.some(data[data.length - 1]) : Maybe.make.none();
+const last = (items) => items.length > 0 ? Maybe.make.some(items[items.length - 1]) : Maybe.make.none();
 /**
 * Returns all elements except the first, or None if the array is empty.
 *
+* @see {@link head} for accessing the first element.
+*
 * @example
 * ```ts
 * Arr.tail([1, 2, 3]); // Some([2, 3])
 * Arr.tail([]); // None
 * ```
 */
-const tail = (data) => data.length > 0 ? Maybe.make.some(data.slice(1)) : Maybe.make.none();
+const tail = (items) => items.length > 0 ? Maybe.make.some(items.slice(1)) : Maybe.make.none();
 /**
 * Returns all elements except the last, or None if the array is empty.
 *
+* @see {@link last} for accessing the final element.
+*
 * @example
 * ```ts
 * Arr.init([1, 2, 3]); // Some([1, 2])
 * Arr.init([]); // None
 * ```
 */
-const init = (data) => data.length > 0 ? Maybe.make.some(data.slice(0, -1)) : Maybe.make.none();
+const init = (items) => items.length > 0 ? Maybe.make.some(items.slice(0, -1)) : Maybe.make.none();
 /**
 * Returns the first element matching the predicate, or None.
 *
+* @see {@link findLast} for finding the last matching element.
+* @see {@link findIndex} for obtaining the index of the first matching element.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4], Arr.findFirst(n => n > 2)); // Some(3)
 * ```
 */
-const findFirst = (predicate) => (data) => {
-	const idx = data.findIndex(predicate);
-	return idx !== -1 ? Maybe.make.some(data[idx]) : Maybe.make.none();
+const findFirst = (predicate) => (items) => {
+	const idx = items.findIndex(predicate);
+	return idx !== -1 ? Maybe.make.some(items[idx]) : Maybe.make.none();
 };
 /**
 * Returns the last element matching the predicate, or None.
 *
+* @see {@link findFirst} for finding the first matching element.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4], Arr.findLast(n => n > 2)); // Some(4)
 * ```
 */
-const findLast = (predicate) => (data) => {
-	for (let i = data.length - 1; i >= 0; i--) if (predicate(data[i])) return Maybe.make.some(data[i]);
+const findLast = (predicate) => (items) => {
+	for (let i = items.length - 1; i >= 0; i--) if (predicate(items[i])) return Maybe.make.some(items[i]);
 	return Maybe.make.none();
 };
 /**
 * Returns the index of the first element matching the predicate, or None.
 *
+* @see {@link findFirst} for finding the matching element value.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4], Arr.findIndex(n => n > 2)); // Some(2)
 * ```
 */
-const findIndex = (predicate) => (data) => {
-	const idx = data.findIndex(predicate);
+const findIndex = (predicate) => (items) => {
+	const idx = items.findIndex(predicate);
 	return idx !== -1 ? Maybe.make.some(idx) : Maybe.make.none();
 };
 /**
 * Transforms each element of an array.
 *
+* @see {@link flatMap} for mapping and flattening arrays.
+* @see {@link mapWithIndex} for mapping with element indices.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]
 * ```
 */
-const map$3 = (f) => (data) => {
-	const n = data.length;
+const map$3 = (transform) => (items) => {
+	const n = items.length;
 	const result = new Array(n);
-	for (let i = 0; i < n; i++) result[i] = f(data[i]);
+	for (let i = 0; i < n; i++) result[i] = transform(items[i]);
 	return result;
 };
 /**
 * Transforms each element using both its value and its zero-based index.
 *
+* @see {@link map} for mapping without indices.
+*
 * @example
 * ```ts
 * pipe(
@@ -172,30 +237,34 @@ const map$3 = (f) => (data) => {
 * ); // [{ position: 1, value: "a" }, { position: 2, value: "b" }, { position: 3, value: "c" }]
 * ```
 */
-const mapWithIndex = (f) => (data) => {
-	const n = data.length;
+const mapWithIndex = (transform) => (items) => {
+	const n = items.length;
 	const result = new Array(n);
-	for (let i = 0; i < n; i++) result[i] = f(i, data[i]);
+	for (let i = 0; i < n; i++) result[i] = transform(i, items[i]);
 	return result;
 };
 /**
 * Filters elements that satisfy the predicate.
 *
+* @see {@link filterMap} for filtering and mapping simultaneously.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]
 * ```
 */
-const filter$3 = (predicate) => (data) => {
-	const n = data.length;
+const filter$3 = (predicate) => (items) => {
+	const n = items.length;
 	const result = [];
-	for (let i = 0; i < n; i++) if (predicate(data[i])) result.push(data[i]);
+	for (let i = 0; i < n; i++) if (predicate(items[i])) result.push(items[i]);
 	return result;
 };
 /**
 * Maps each element to a Maybe and collects only the Some values.
 * Combines map and filter in a single pass.
 *
+* @see {@link filter} for filtering with a boolean predicate.
+*
 * @example
 * ```ts
 * const parseNum = (s: string): Maybe<number> => {
@@ -206,10 +275,10 @@ const filter$3 = (predicate) => (data) => {
 * pipe(["1", "abc", "3"], Arr.filterMap(parseNum)); // [1, 3]
 * ```
 */
-const filterMap$3 = (f) => (data) => {
+const filterMap$3 = (transform) => (items) => {
 	const result = [];
-	for (let i = 0; i < data.length; i++) {
-		const mapped = f(data[i]);
+	for (let i = 0; i < items.length; i++) {
+		const mapped = transform(items[i]);
 		if (mapped.kind === "Some") result.push(mapped.value);
 	}
 	return result;
@@ -219,50 +288,59 @@ const filterMap$3 = (f) => (data) => {
 * First group contains elements that satisfy the predicate,
 * second group contains the rest.
 *
+* @see {@link partitionMap} for partitioning with a Result function.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4], Arr.partition(n => n % 2 === 0)); // [[2, 4], [1, 3]]
 * ```
 */
-const partition = (predicate) => (data) => {
+const partition = (predicate) => (items) => {
 	const pass = [];
 	const fail = [];
-	for (const a of data) (predicate(a) ? pass : fail).push(a);
+	for (const item of items) (predicate(item) ? pass : fail).push(item);
 	return [pass, fail];
 };
 /**
 * Narrows a list of Maybe values down to a list of their underlying values,
 * discarding all None instances.
 *
+* @see {@link separate} for dividing Results into error and success arrays.
+*
 * @example
 * ```ts
 * Arr.compact([Maybe.make.some(1), Maybe.make.none(), Maybe.make.some(3)]); // [1, 3]
 * ```
 */
-const compact$2 = (data) => {
+const compact$2 = (items) => {
 	const result = [];
-	for (const item of data) if (item.kind === "Some") result.push(item.value);
+	for (const item of items) if (item.kind === "Some") result.push(item.value);
 	return result;
 };
 /**
 * Separates an array of Result values into two separate lists of errors and successes.
 * Returns a tuple containing `[errors, successes]`.
 *
+* @see {@link compact} for extracting Some values from Maybe instances.
+*
 * @example
 * ```ts
 * Arr.separate([Result.make.ok(1), Result.make.err("bad"), Result.make.ok(3)]); // [["bad"], [1, 3]]
 * ```
 */
-const separate = (data) => {
+const separate = (items) => {
 	const errors = [];
 	const successes = [];
-	for (const item of data) if (item.kind === "Ok") successes.push(item.value);
+	for (const item of items) if (item.kind === "Ok") successes.push(item.value);
 	else errors.push(item.error);
 	return [errors, successes];
 };
 /**
 * Maps each element to a Result, and separates the results into a tuple of failures and successes.
 *
+* @see {@link partition} for partitioning with a boolean predicate.
+* @see {@link partitionMaybe} for partitioning with a Maybe function.
+*
 * @example
 * ```ts
 * pipe(
@@ -271,11 +349,11 @@ const separate = (data) => {
 * ); // [["odd: 1", "odd: 3"], [2, 4]]
 * ```
 */
-const partitionMap = (f) => (data) => {
+const partitionMap = (transform) => (items) => {
 	const errors = [];
 	const successes = [];
-	for (const item of data) {
-		const mapped = f(item);
+	for (const item of items) {
+		const mapped = transform(item);
 		if (mapped.kind === "Ok") successes.push(mapped.value);
 		else errors.push(mapped.error);
 	}
@@ -284,6 +362,8 @@ const partitionMap = (f) => (data) => {
 /**
 * Groups elements by a key function.
 *
+* @see {@link indexBy} for indexing elements into a Map.
+*
 * @example
 * ```ts
 * pipe(
@@ -292,27 +372,33 @@ const partitionMap = (f) => (data) => {
 * ); // { a: ["apple", "avocado"], b: ["banana"] }
 * ```
 */
-const groupBy$2 = (f) => (data) => {
+const groupBy$2 = (keySelector) => (items) => {
 	const result = {};
-	for (const a of data) {
-		const key = f(a);
+	for (const item of items) {
+		const key = keySelector(item);
 		if (!result[key]) result[key] = [];
-		result[key].push(a);
+		result[key].push(item);
 	}
 	return result;
 };
 /**
 * Removes duplicate elements using strict equality.
 *
+* @see {@link uniqBy} for deduplicating by a key projection.
+* @see {@link uniqWith} for deduplicating with custom equality.
+*
 * @example
 * ```ts
 * Arr.uniq([1, 2, 2, 3, 1]); // [1, 2, 3]
 * ```
 */
-const uniq = (data) => data.length <= 1 ? data : [...new Set(data)];
+const uniq = (items) => items.length <= 1 ? items : [...new Set(items)];
 /**
 * Removes duplicate elements by comparing the result of a key function.
 *
+* @see {@link uniq} for reference-equality deduplication.
+* @see {@link uniqWith} for deduplicating with custom equality.
+*
 * @example
 * ```ts
 * pipe(
@@ -321,14 +407,14 @@ const uniq = (data) => data.length <= 1 ? data : [...new Set(data)];
 * ); // [{id: 1, name: "a"}, {id: 2, name: "c"}]
 * ```
 */
-const uniqBy = (f) => (data) => {
+const uniqBy = (keySelector) => (items) => {
 	const seen = /* @__PURE__ */ new Set();
 	const result = [];
-	for (const a of data) {
-		const key = f(a);
+	for (const item of items) {
+		const key = keySelector(item);
 		if (!seen.has(key)) {
 			seen.add(key);
-			result.push(a);
+			result.push(item);
 		}
 	}
 	return result;
@@ -338,6 +424,9 @@ const uniqBy = (f) => (data) => {
 * Preserves the order of first occurrences. Complements `uniq` (reference equality)
 * and `uniqBy` (key extraction).
 *
+* @see {@link uniq} for reference-equality deduplication.
+* @see {@link uniqBy} for key-based deduplication.
+*
 * @example
 * ```ts
 * type Point = { x: number; y: number };
@@ -349,29 +438,33 @@ const uniqBy = (f) => (data) => {
 * ); // [{ x: 1, y: 1 }, { x: 2, y: 2 }]
 * ```
 */
-const uniqWith = (eq) => (data) => {
+const uniqWith = (areEqual) => (items) => {
 	const result = [];
-	for (const a of data) if (!result.some((x) => eq(x, a))) result.push(a);
+	for (const item of items) if (!result.some((existing) => areEqual(existing, item))) result.push(item);
 	return result;
 };
 /**
 * Sorts an array using a comparison function. Returns a new array.
 * To sort with a typed `Ordering<A>`, prefer `Arr.sortWith`.
 *
+* @see {@link sortWith} for sorting using typed Ordering instances.
+*
 * @example
 * ```ts
 * pipe([3, 1, 2], Arr.sortBy((a, b) => a - b)); // [1, 2, 3]
 * ```
 */
-const sortBy = (compare) => (data) => {
-	const arr = data;
+const sortBy = (compare) => (items) => {
+	const arr = items;
 	if (typeof arr.toSorted === "function") return arr.toSorted(compare);
-	return [...data].sort(compare);
+	return [...items].sort(compare);
 };
 /**
 * Sorts an array using an `Ordering<A>`. Returns a new array without mutating the original.
 * Use this over `sortBy` when you have a typed `Ordering<A>` from the `Ordering` module.
 *
+* @see {@link sortBy} for sorting using a comparator function.
+*
 * @example
 * ```ts
 * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
@@ -382,37 +475,41 @@ const sortBy = (compare) => (data) => {
 * pipe(products, Arr.sortWith(byPrice));
 * ```
 */
-const sortWith = (ord) => (data) => {
-	const arr = data;
-	if (typeof arr.toSorted === "function") return arr.toSorted(ord);
-	return [...data].sort(ord);
+const sortWith = (ordering) => (items) => {
+	const arr = items;
+	if (typeof arr.toSorted === "function") return arr.toSorted(ordering);
+	return [...items].sort(ordering);
 };
 /**
 * Pairs up elements from two arrays. Stops at the shorter array.
 *
+* @see {@link zipWith} for pairing elements with a custom combining function.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.zip(["a", "b"])); // [[1, "a"], [2, "b"]]
 * ```
 */
-const zip = (other) => (data) => {
-	const len = Math.min(data.length, other.length);
+const zip = (other) => (items) => {
+	const len = Math.min(items.length, other.length);
 	const result = new Array(len);
-	for (let i = 0; i < len; i++) result[i] = [data[i], other[i]];
+	for (let i = 0; i < len; i++) result[i] = [items[i], other[i]];
 	return result;
 };
 /**
 * Combines elements from two arrays using a function. Stops at the shorter array.
 *
+* @see {@link zip} for pairing elements into 2-tuples.
+*
 * @example
 * ```ts
 * pipe([1, 2], Arr.zipWith((a: number, b: string) => `${a}${b}`)(["a", "b"])); // ["1a", "2b"]
 * ```
 */
-const zipWith = (f) => (other) => (data) => {
-	const len = Math.min(data.length, other.length);
+const zipWith = (combine) => (other) => (items) => {
+	const len = Math.min(items.length, other.length);
 	const result = new Array(len);
-	for (let i = 0; i < len; i++) result[i] = f(data[i], other[i]);
+	for (let i = 0; i < len; i++) result[i] = combine(items[i], other[i]);
 	return result;
 };
 /**
@@ -423,10 +520,10 @@ const zipWith = (f) => (other) => (data) => {
 * pipe([1, 2, 3], Arr.intersperse(0)); // [1, 0, 2, 0, 3]
 * ```
 */
-const intersperse = (sep) => (data) => {
-	if (data.length <= 1) return data;
-	const result = [data[0]];
-	for (let i = 1; i < data.length; i++) result.push(sep, data[i]);
+const intersperse = (separator) => (items) => {
+	if (items.length <= 1) return items;
+	const result = [items[0]];
+	for (let i = 1; i < items.length; i++) result.push(separator, items[i]);
 	return result;
 };
 /**
@@ -437,37 +534,41 @@ const intersperse = (sep) => (data) => {
 * pipe([1, 2], Arr.concat([3, 4])); // [1, 2, 3, 4]
 * ```
 */
-const concat = (other) => (data) => [...data, ...other];
+const concat = (other) => (items) => [...items, ...other];
 /**
 * Splits an array into chunks of the given size.
 *
+* @see {@link chunkBy} for grouping consecutive elements sharing a key.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4, 5], Arr.chunksOf(2)); // [[1, 2], [3, 4], [5]]
 * ```
 */
-const chunksOf = (n) => (data) => {
-	if (n <= 0) return [];
+const chunksOf = (size) => (items) => {
+	if (size <= 0) return [];
 	const result = [];
-	for (let i = 0; i < data.length; i += n) result.push(data.slice(i, i + n));
+	for (let i = 0; i < items.length; i += size) result.push(items.slice(i, i + size));
 	return result;
 };
 /**
 * Flattens a nested array by one level.
 *
+* @see {@link flatMap} for mapping elements to arrays before flattening.
+*
 * @example
 * ```ts
 * Arr.flatten([[1, 2], [3], [4, 5]]); // [1, 2, 3, 4, 5]
 * ```
 */
-const flatten = (data) => {
+const flatten = (items) => {
 	let totalLen = 0;
-	const outerLen = data.length;
-	for (let i = 0; i < outerLen; i++) totalLen += data[i].length;
+	const outerLen = items.length;
+	for (let i = 0; i < outerLen; i++) totalLen += items[i].length;
 	const result = new Array(totalLen);
 	let idx = 0;
 	for (let i = 0; i < outerLen; i++) {
-		const chunk = data[i];
+		const chunk = items[i];
 		const innerLen = chunk.length;
 		for (let j = 0; j < innerLen; j++) result[idx++] = chunk[j];
 	}
@@ -476,16 +577,19 @@ const flatten = (data) => {
 /**
 * Maps each element to an array and flattens the result.
 *
+* @see {@link map} for mapping without flattening.
+* @see {@link flatten} for flattening without mapping.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.flatMap(n => [n, n * 10])); // [1, 10, 2, 20, 3, 30]
 * ```
 */
-const flatMap = (f) => (data) => {
-	const n = data.length;
+const flatMap = (transform) => (items) => {
+	const n = items.length;
 	const result = [];
 	for (let i = 0; i < n; i++) {
-		const chunk = f(data[i]);
+		const chunk = transform(items[i]);
 		const m = chunk.length;
 		for (let j = 0; j < m; j++) result.push(chunk[j]);
 	}
@@ -494,32 +598,38 @@ const flatMap = (f) => (data) => {
 /**
 * Reduces an array from the left.
 *
+* @see {@link scan} for preserving intermediate accumulation states.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.reduce(0, (acc, n) => acc + n)); // 6
 * ```
 */
-const reduce$2 = (initial, f) => (data) => data.reduce(f, initial);
-const _traverseTask = Object.assign((f) => ArrTask.traverse(f), { Result: ArrTaskResult.traverse });
+const reduce$2 = (initial, reducer) => (items) => items.reduce(reducer, initial);
+const _traverseTask = Object.assign((f, options) => ArrTask.traverse(f, options), { Result: ArrTaskResult.traverse });
 const _sequenceTask = Object.assign((data) => ArrTask.sequence(data), { Result: ArrTaskResult.sequence });
 /**
 * Prepends a value to the beginning of an array, returning a NonEmptyArr.
 *
+* @see {@link append} for adding an element to the end.
+*
 * @example
 * ```ts
 * pipe([1, 2], Arr.prepend(0)); // [0, 1, 2]
 * ```
 */
-const prepend = (value) => (data) => [value, ...data];
+const prepend = (item) => (items) => [item, ...items];
 /**
 * Appends a value to the end of an array, returning a NonEmptyArr.
 *
+* @see {@link prepend} for adding an element to the beginning.
+*
 * @example
 * ```ts
 * pipe([1, 2], Arr.append(3)); // [1, 2, 3]
 * ```
 */
-const append = (value) => (data) => [...data, value];
+const append = (item) => (items) => [...items, item];
 /**
 * Returns the length of an array.
 *
@@ -528,31 +638,35 @@ const append = (value) => (data) => [...data, value];
 * Arr.size([1, 2, 3]); // 3
 * ```
 */
-const size$3 = (data) => data.length;
+const size$3 = (items) => items.length;
 /**
 * Returns true if any element satisfies the predicate.
 *
+* @see {@link every} for checking whether all elements satisfy a predicate.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.some(n => n > 2)); // true
 * ```
 */
-const some = (predicate) => (data) => {
-	const n = data.length;
-	for (let i = 0; i < n; i++) if (predicate(data[i])) return true;
+const some = (predicate) => (items) => {
+	const n = items.length;
+	for (let i = 0; i < n; i++) if (predicate(items[i])) return true;
 	return false;
 };
 /**
 * Returns true if all elements satisfy the predicate.
 *
+* @see {@link some} for checking whether any element satisfies a predicate.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.every(n => n > 0)); // true
 * ```
 */
-const every = (predicate) => (data) => {
-	const n = data.length;
-	for (let i = 0; i < n; i++) if (!predicate(data[i])) return false;
+const every = (predicate) => (items) => {
+	const n = items.length;
+	for (let i = 0; i < n; i++) if (!predicate(items[i])) return false;
 	return true;
 };
 /**
@@ -563,11 +677,13 @@ const every = (predicate) => (data) => {
 * Arr.reverse([1, 2, 3]); // [3, 2, 1]
 * ```
 */
-const reverse = (data) => [...data].toReversed();
+const reverse = (items) => [...items].toReversed();
 /**
 * Returns a new array with `item` inserted before the element at `index`.
 * Negative indices are clamped to 0; indices beyond the array length append to the end.
 *
+* @see {@link removeAt} for removing an element at an index.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.insertAt(1, 99)); // [1, 99, 2, 3]
@@ -575,11 +691,11 @@ const reverse = (data) => [...data].toReversed();
 * pipe([1, 2, 3], Arr.insertAt(3, 99)); // [1, 2, 3, 99]
 * ```
 */
-const insertAt = (index, item) => (data) => {
-	const i = Math.max(0, Math.min(index, data.length));
-	const arr = data;
+const insertAt = (index, item) => (items) => {
+	const i = Math.max(0, Math.min(index, items.length));
+	const arr = items;
 	if (typeof arr.toSpliced === "function") return arr.toSpliced(i, 0, item);
-	const result = [...data];
+	const result = [...items];
 	result.splice(i, 0, item);
 	return result;
 };
@@ -587,6 +703,8 @@ const insertAt = (index, item) => (data) => {
 * Returns a new array with the element at `index` removed.
 * Returns the original array unchanged if `index` is out of bounds.
 *
+* @see {@link insertAt} for inserting an element at an index.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.removeAt(1)); // [1, 3]
@@ -594,76 +712,90 @@ const insertAt = (index, item) => (data) => {
 * pipe([1, 2, 3], Arr.removeAt(5)); // [1, 2, 3]
 * ```
 */
-const removeAt = (index) => (data) => {
-	if (index < 0 || index >= data.length) return data;
-	const arr = data;
+const removeAt = (index) => (items) => {
+	if (index < 0 || index >= items.length) return items;
+	const arr = items;
 	if (typeof arr.toSpliced === "function") return arr.toSpliced(index, 1);
-	const result = [...data];
+	const result = [...items];
 	result.splice(index, 1);
 	return result;
 };
 /**
 * Takes the first n elements from an array.
 *
+* @see {@link drop} for discarding the first n elements.
+* @see {@link takeWhile} for taking elements based on a predicate.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4], Arr.take(2)); // [1, 2]
 * ```
 */
-const take = (n) => (data) => n <= 0 ? [] : data.slice(0, n);
+const take = (count) => (items) => count <= 0 ? [] : items.slice(0, count);
 /**
 * Drops the first n elements from an array.
 *
+* @see {@link take} for keeping the first n elements.
+* @see {@link dropWhile} for discarding elements based on a predicate.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 4], Arr.drop(2)); // [3, 4]
 * ```
 */
-const drop = (n) => (data) => data.slice(n);
+const drop = (count) => (items) => items.slice(count);
 /**
 * Takes elements from the start while the predicate holds.
 *
+* @see {@link dropWhile} for discarding elements while a predicate holds.
+* @see {@link take} for taking a fixed count of elements.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 1], Arr.takeWhile(n => n < 3)); // [1, 2]
 * ```
 */
-const takeWhile = (predicate) => (data) => {
+const takeWhile = (predicate) => (items) => {
 	const result = [];
-	for (const a of data) {
-		if (!predicate(a)) break;
-		result.push(a);
+	for (const item of items) {
+		if (!predicate(item)) break;
+		result.push(item);
 	}
 	return result;
 };
 /**
 * Drops elements from the start while the predicate holds.
 *
+* @see {@link takeWhile} for keeping elements while a predicate holds.
+* @see {@link drop} for discarding a fixed count of elements.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3, 1], Arr.dropWhile(n => n < 3)); // [3, 1]
 * ```
 */
-const dropWhile = (predicate) => (data) => {
+const dropWhile = (predicate) => (items) => {
 	let i = 0;
-	while (i < data.length && predicate(data[i])) i++;
-	return data.slice(i);
+	while (i < items.length && predicate(items[i])) i++;
+	return items.slice(i);
 };
 /**
 * Like `reduce`, but returns every intermediate accumulator as an array.
 * The initial value is not included — the output has the same length as the input.
 *
+* @see {@link reduce} for computing only the final accumulator value.
+*
 * @example
 * ```ts
 * pipe([1, 2, 3], Arr.scan(0, (acc, n) => acc + n)); // [1, 3, 6]
 * ```
 */
-const scan = (initial, f) => (data) => {
-	const n = data.length;
+const scan = (initial, reducer) => (items) => {
+	const n = items.length;
 	const result = new Array(n);
 	let acc = initial;
 	for (let i = 0; i < n; i++) {
-		acc = f(acc, data[i]);
+		acc = reducer(acc, items[i]);
 		result[i] = acc;
 	}
 	return result;
@@ -679,28 +811,31 @@ const scan = (initial, f) => (data) => {
 * pipe([1, 2, 3], Arr.splitAt(10));   // [[1, 2, 3], []]
 * ```
 */
-const splitAt = (index) => (data) => {
+const splitAt = (index) => (items) => {
 	const i = Math.max(0, index);
-	return [data.slice(0, i), data.slice(i)];
+	return [items.slice(0, i), items.slice(i)];
 };
 /**
 * Partitions an array by applying a function returning `Maybe<B>`.
 * Elements returning `None` are gathered into `failures` (original `A` values);
 * elements returning `Some(b)` are gathered into `successes` (`B` values).
 *
+* @see {@link partitionMap} for partitioning with a Result mapper.
+* @see {@link partition} for partitioning with a boolean predicate.
+*
 * @example
 * ```ts
 * const parseNumber = (s: string) => isNaN(Number(s)) ? Maybe.make.none() : Maybe.make.some(Number(s));
 * pipe(["1", "abc", "3"], Arr.partitionMaybe(parseNumber)); // [["abc"], [1, 3]]
 * ```
 */
-const partitionMaybe = (f) => (data) => {
+const partitionMaybe = (transform) => (items) => {
 	const failures = [];
 	const successes = [];
-	for (let i = 0; i < data.length; i++) {
-		const res = f(data[i]);
+	for (let i = 0; i < items.length; i++) {
+		const res = transform(items[i]);
 		if (res.kind === "Some") successes.push(res.value);
-		else failures.push(data[i]);
+		else failures.push(items[i]);
 	}
 	return [failures, successes];
 };
@@ -715,13 +850,15 @@ const partitionMaybe = (f) => (data) => {
 * pipe([10, 20, 30], Arr.at(5));  // None
 * ```
 */
-const at = (index) => (data) => {
-	const targetIndex = index < 0 ? data.length + index : index;
-	if (targetIndex < 0 || targetIndex >= data.length) return Maybe.make.none();
-	return Maybe.make.some(data[targetIndex]);
+const at = (index) => (items) => {
+	const targetIndex = index < 0 ? items.length + index : index;
+	if (targetIndex < 0 || targetIndex >= items.length) return Maybe.make.none();
+	return Maybe.make.some(items[targetIndex]);
 };
 /**
-* Finds the first element in an array for which `f` returns `Some(b)`.
+* Finds the first element in an array for which `transform` returns `Some(b)`.
+*
+* @see {@link findFirst} for finding elements with a boolean predicate.
 *
 * @example
 * ```ts
@@ -731,9 +868,9 @@ const at = (index) => (data) => {
 * ); // Some(1)
 * ```
 */
-const findMap = (f) => (data) => {
-	for (let i = 0; i < data.length; i++) {
-		const res = f(data[i]);
+const findMap = (transform) => (items) => {
+	for (let i = 0; i < items.length; i++) {
+		const res = transform(items[i]);
 		if (res.kind === "Some") return res;
 	}
 	return Maybe.make.none();
@@ -741,6 +878,8 @@ const findMap = (f) => (data) => {
 /**
 * Indexes elements of an array into a `ReadonlyMap<K, A>` using a key extraction function.
 *
+* @see {@link groupBy} for grouping multiple items per key into arrays.
+*
 * @example
 * ```ts
 * pipe(
@@ -749,9 +888,9 @@ const findMap = (f) => (data) => {
 * ); // ReadonlyMap { 1 => { id: 1, name: "Alice" }, 2 => { id: 2, name: "Bob" } }
 * ```
 */
-const indexBy = (keyFn) => (data) => {
+const indexBy = (keySelector) => (items) => {
 	const resultMap = new globalThis.Map();
-	for (let i = 0; i < data.length; i++) resultMap.set(keyFn(data[i]), data[i]);
+	for (let i = 0; i < items.length; i++) resultMap.set(keySelector(items[i]), items[i]);
 	return resultMap;
 };
 /**
@@ -763,16 +902,18 @@ const indexBy = (keyFn) => (data) => {
 * // ReadonlyMap { "a" => 3, "b" => 2, "c" => 1 }
 * ```
 */
-const frequencies = (data) => {
+const frequencies = (items) => {
 	const resultMap = new globalThis.Map();
-	for (let i = 0; i < data.length; i++) {
-		const item = data[i];
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
 		resultMap.set(item, (resultMap.get(item) ?? 0) + 1);
 	}
 	return resultMap;
 };
 /**
-* Groups consecutive elements that share the same key returned by `keyFn`.
+* Groups consecutive elements that share the same key returned by `keySelector`.
+*
+* @see {@link chunksOf} for fixed-size chunking.
 *
 * @example
 * ```ts
@@ -782,14 +923,14 @@ const frequencies = (data) => {
 * ); // [[1, 1], [2], [3, 3], [1]]
 * ```
 */
-const chunkBy = (keyFn) => (data) => {
-	if (data.length === 0) return [];
+const chunkBy = (keySelector) => (items) => {
+	if (items.length === 0) return [];
 	const result = [];
-	let currentChunk = [data[0]];
-	let currentKey = keyFn(data[0]);
-	for (let i = 1; i < data.length; i++) {
-		const item = data[i];
-		const key = keyFn(item);
+	let currentChunk = [items[0]];
+	let currentKey = keySelector(items[0]);
+	for (let i = 1; i < items.length; i++) {
+		const item = items[i];
+		const key = keySelector(item);
 		if (Object.is(key, currentKey)) currentChunk.push(item);
 		else {
 			result.push(currentChunk);
@@ -804,20 +945,22 @@ const chunkBy = (keyFn) => (data) => {
 * Removes consecutive duplicate elements.
 * An optional `Equality<A>` can be provided (defaults to `Object.is`).
 *
+* @see {@link uniq} for deduplicating across the entire array.
+*
 * @example
 * ```ts
 * Arr.dedupeAdjacent()([1, 1, 2, 2, 1, 3]); // [1, 2, 1, 3]
 * ```
 */
-const dedupeAdjacent = (eq = (a, b) => Object.is(a, b)) => (data) => {
-	if (data.length === 0) return [];
-	const result = [data[0]];
-	for (let i = 1; i < data.length; i++) if (!eq(data[i], result[result.length - 1])) result.push(data[i]);
+const dedupeAdjacent = (areEqual = (first, second) => Object.is(first, second)) => (items) => {
+	if (items.length === 0) return [];
+	const result = [items[0]];
+	for (let i = 1; i < items.length; i++) if (!areEqual(items[i], result[result.length - 1])) result.push(items[i]);
 	return result;
 };
 /**
 * Produces a sliding window of `size` elements over an array, advancing by `step` (default `1`).
-* Returns an empty array if `size <= 0` or `size > data.length`.
+* Returns an empty array if `size <= 0` or `size > items.length`.
 *
 * @example
 * ```ts
@@ -825,15 +968,15 @@ const dedupeAdjacent = (eq = (a, b) => Object.is(a, b)) => (data) => {
 * pipe([1, 2, 3, 4], Arr.windowed(2, { step: 2 })); // [[1, 2], [3, 4]]
 * ```
 */
-const windowed = (windowSize, options) => (data) => {
+const windowed = (windowSize, options) => (items) => {
 	const step = options?.step ?? 1;
-	if (windowSize <= 0 || step <= 0 || data.length < windowSize) return [];
+	if (windowSize <= 0 || step <= 0 || items.length < windowSize) return [];
 	const result = [];
-	for (let i = 0; i <= data.length - windowSize; i += step) result.push(data.slice(i, i + windowSize));
+	for (let i = 0; i <= items.length - windowSize; i += step) result.push(items.slice(i, i + windowSize));
 	return result;
 };
 /**
-* Generates an array from an initial seed state until `f` returns `None`.
+* Generates an array from an initial seed state until `step` returns `None`.
 *
 * @example
 * ```ts
@@ -841,11 +984,11 @@ const windowed = (windowSize, options) => (data) => {
 * // [1, 2, 3]
 * ```
 */
-const unfold = (initial, f) => {
+const unfold = (initial, step) => {
 	const result = [];
 	let currentState = initial;
 	while (true) {
-		const next = f(currentState);
+		const next = step(currentState);
 		if (next.kind === "None") break;
 		const [item, nextState] = next.value;
 		result.push(item);
@@ -886,6 +1029,7 @@ const Arr = {
 	prepend,
 	append,
 	size: size$3,
+	length: size$3,
 	some,
 	every,
 	reverse,
@@ -906,33 +1050,44 @@ const Arr = {
 	dedupeAdjacent,
 	windowed,
 	unfold,
-	from: { Array: (data) => data.length > 0 ? Maybe.make.some(data) : Maybe.make.none() },
 	is: {
-		empty: (data) => data.length === 0,
-		nonEmpty: (data) => isNonEmptyArr(data)
+		/**
+		* Returns `true` when the array is empty.
+		*
+		* @see {@link nonEmpty} for checking if an array contains elements.
+		*/
+		empty: (items) => items.length === 0,
+		/**
+		* Returns `true` when the array contains at least one element.
+		*
+		* @see {@link empty} for checking if an array is empty.
+		*/
+		nonEmpty: (items) => isNonEmptyArr(items)
 	},
 	traverse: {
 		Maybe: ArrMaybe.traverse,
 		Result: ArrResult.traverse,
-		Task: _traverseTask
+		Task: _traverseTask,
+		Validation: ArrValidation.traverse
 	},
 	sequence: {
 		Maybe: ArrMaybe.sequence,
 		Result: ArrResult.sequence,
-		Task: _sequenceTask
+		Task: _sequenceTask,
+		Validation: ArrValidation.sequence
 	},
 	NonEmpty: {
-		singleton: (value) => [value],
-		from: { Array: (data) => isNonEmptyArr(data) ? Maybe.make.some(data) : Maybe.make.none() },
-		head: (data) => data[0],
-		last: (data) => data[data.length - 1],
-		tail: (data) => data.slice(1),
-		reduce: (f) => (data) => data.reduce(f),
-		map: (f) => (data) => map$3(f)(data),
-		mapWithIndex: (f) => (data) => mapWithIndex(f)(data),
-		intersperse: (sep) => (data) => intersperse(sep)(data),
-		concat: (other) => (data) => concat(other)(data),
-		reverse: (data) => reverse(data)
+		singleton: (item) => [item],
+		from: { array: (items) => isNonEmptyArr(items) ? Maybe.make.some(items) : Maybe.make.none() },
+		head: (items) => items[0],
+		last: (items) => items[items.length - 1],
+		tail: (items) => items.slice(1),
+		reduce: (reducer) => (items) => items.reduce(reducer),
+		map: (transform) => (items) => map$3(transform)(items),
+		mapWithIndex: (transform) => (items) => mapWithIndex(transform)(items),
+		intersperse: (separator) => (items) => intersperse(separator)(items),
+		concat: (other) => (items) => concat(other)(items),
+		reverse: (items) => reverse(items)
 	}
 };
 //#endregion
@@ -963,30 +1118,36 @@ const BigNum = {
 		* BigNum.is.zero(5n); // false
 		* ```
 		*/
-		zero: (b) => b === 0n,
+		zero: (value) => value === 0n,
 		/**
 		* Returns `true` when the bigint is an even integer.
 		*
+		* @see {@link BigNum.is.odd} to check if a bigint is odd.
+		*
 		* @example
 		* ```ts
 		* BigNum.is.even(4n); // true
 		* BigNum.is.even(3n); // false
 		* ```
 		*/
-		even: (b) => b % 2n === 0n,
+		even: (value) => value % 2n === 0n,
 		/**
 		* Returns `true` when the bigint is an odd integer.
 		*
+		* @see {@link BigNum.is.even} to check if a bigint is even.
+		*
 		* @example
 		* ```ts
 		* BigNum.is.odd(3n); // true
 		* BigNum.is.odd(4n); // false
 		* ```
 		*/
-		odd: (b) => b % 2n !== 0n,
+		odd: (value) => value % 2n !== 0n,
 		/**
 		* Returns `true` when the bigint is strictly greater than zero (`0n`).
 		*
+		* @see {@link BigNum.is.negative} to check if a bigint is less than zero.
+		*
 		* @example
 		* ```ts
 		* BigNum.is.positive(5n);  // true
@@ -994,10 +1155,12 @@ const BigNum = {
 		* BigNum.is.positive(-5n); // false
 		* ```
 		*/
-		positive: (b) => b > 0n,
+		positive: (value) => value > 0n,
 		/**
 		* Returns `true` when the bigint is strictly less than zero (`0n`).
 		*
+		* @see {@link BigNum.is.positive} to check if a bigint is greater than zero.
+		*
 		* @example
 		* ```ts
 		* BigNum.is.negative(-5n); // true
@@ -1005,7 +1168,7 @@ const BigNum = {
 		* BigNum.is.negative(5n);  // false
 		* ```
 		*/
-		negative: (b) => b < 0n
+		negative: (value) => value < 0n
 	},
 	from: {
 		/**
@@ -1017,10 +1180,10 @@ const BigNum = {
 		* BigNum.from.string("abc"); // None
 		* ```
 		*/
-		string: (s) => {
+		string: (text) => {
 			try {
-				if (s.trim() === "") return Maybe.make.none();
-				return Maybe.make.some(BigInt(s));
+				if (text.trim() === "") return Maybe.make.none();
+				return Maybe.make.some(BigInt(text));
 			} catch {
 				return Maybe.make.none();
 			}
@@ -1034,9 +1197,9 @@ const BigNum = {
 		* BigNum.from.number(3.14); // None
 		* ```
 		*/
-		number: (n) => {
-			if (!Number.isInteger(n) || n < Number.MIN_SAFE_INTEGER || n > Number.MAX_SAFE_INTEGER) return Maybe.make.none();
-			return Maybe.make.some(BigInt(n));
+		number: (value) => {
+			if (!Number.isInteger(value) || value < Number.MIN_SAFE_INTEGER || value > Number.MAX_SAFE_INTEGER) return Maybe.make.none();
+			return Maybe.make.some(BigInt(value));
 		}
 	},
 	to: { 
@@ -1049,75 +1212,100 @@ const BigNum = {
 	* BigNum.to.number(9007199254740993n);      // None
 	* ```
 	*/
-number: (b) => {
-		if (b < BigInt(Number.MIN_SAFE_INTEGER) || b > BigInt(Number.MAX_SAFE_INTEGER)) return Maybe.make.none();
-		return Maybe.make.some(Number(b));
+number: (value) => {
+		if (value < BigInt(Number.MIN_SAFE_INTEGER) || value > BigInt(Number.MAX_SAFE_INTEGER)) return Maybe.make.none();
+		return Maybe.make.some(Number(value));
 	} },
 	/**
-	* Adds `b` to `a`. Data-last curried signature: `add(b)(a)` = `a + b`.
+	* Adds `amount` to `value`. Data-last curried signature: `add(amount)(value)` = `value + amount`.
+	*
+	* @see {@link BigNum.subtract} to subtract an amount from a bigint.
 	*
 	* @example
 	* ```ts
 	* pipe(10n, BigNum.add(5n)); // 15n
 	* ```
 	*/
-	add: (b) => (a) => a + b,
+	add: (amount) => (value) => value + amount,
 	/**
-	* Subtracts `b` from `a`. Data-last curried signature: `sub(b)(a)` = `a - b`.
+	* Subtracts `amount` from `from`. Data-last curried signature: `subtract(amount)(from)` = `from - amount`.
+	*
+	* @see {@link BigNum.add} to add an amount to a bigint.
 	*
 	* @example
 	* ```ts
-	* pipe(10n, BigNum.sub(3n)); // 7n
+	* pipe(10n, BigNum.subtract(3n)); // 7n
 	* ```
 	*/
-	sub: (b) => (a) => a - b,
+	subtract: (amount) => (from) => from - amount,
 	/**
-	* Multiplies `a` by `b`. Data-last curried signature: `mul(b)(a)` = `a * b`.
+	* Multiplies `value` by `factor`. Data-last curried signature: `multiply(factor)(value)` = `value * factor`.
+	*
+	* @see {@link BigNum.divide} to divide a bigint by a divisor.
 	*
 	* @example
 	* ```ts
-	* pipe(6n, BigNum.mul(7n)); // 42n
+	* pipe(6n, BigNum.multiply(7n)); // 42n
 	* ```
 	*/
-	mul: (b) => (a) => a * b,
+	multiply: (factor) => (value) => value * factor,
 	/**
-	* Divides `a` by `b`. Returns `None` if `b` is `0n`.
+	* Divides `dividend` by `divisor`. Returns `None` if `divisor` is `0n`.
+	*
+	* @see {@link BigNum.multiply} to multiply a bigint by a factor.
+	* @see {@link BigNum.remainder} to compute the division remainder.
 	*
 	* @example
 	* ```ts
-	* pipe(20n, BigNum.div(4n)); // Some(5n)
-	* pipe(5n, BigNum.div(0n));  // None
+	* pipe(20n, BigNum.divide(4n)); // Some(5n)
+	* pipe(5n, BigNum.divide(0n));  // None
 	* ```
 	*/
-	div: (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a / b),
+	divide: (divisor) => (dividend) => divisor === 0n ? Maybe.make.none() : Maybe.make.some(dividend / divisor),
 	/**
-	* Computes remainder of `a / b`. Returns `None` if `b` is `0n`.
+	* Computes remainder of `dividend / divisor`. Returns `None` if `divisor` is `0n`.
+	*
+	* @see {@link BigNum.divide} for full division.
 	*
 	* @example
 	* ```ts
-	* pipe(10n, BigNum.mod(3n)); // Some(1n)
-	* pipe(5n, BigNum.mod(0n));  // None
+	* pipe(10n, BigNum.remainder(3n)); // Some(1n)
+	* pipe(5n, BigNum.remainder(0n));  // None
 	* ```
 	*/
-	mod: (b) => (a) => b === 0n ? Maybe.make.none() : Maybe.make.some(a % b),
+	remainder: (divisor) => (dividend) => divisor === 0n ? Maybe.make.none() : Maybe.make.some(dividend % divisor),
 	/**
-	* Clamps `a` between `min` and `max` (inclusive).
+	* Clamps `value` between `min` and `max` (inclusive).
 	*
 	* @example
 	* ```ts
 	* pipe(150n, BigNum.clamp(0n, 100n)); // 100n
 	* ```
 	*/
-	clamp: (min, max) => (a) => a < min ? min : a > max ? max : a,
+	clamp: (min, max) => (value) => value < min ? min : value > max ? max : value,
+	/**
+	* Returns `true` when the bigint is between `min` and `max` (both inclusive).
+	*
+	* @see {@link BigNum.inRange} for half-open range checking [start, end).
+	*
+	* @example
+	* ```ts
+	* pipe(5n, BigNum.between(1n, 10n)); // true
+	* pipe(0n, BigNum.between(1n, 10n)); // false
+	* ```
+	*/
+	between: (min, max) => (value) => value >= min && value <= max,
 	/**
-	* Returns `true` if `a` is in the range `[start, end)` (inclusive start, exclusive end).
+	* Returns `true` if `value` is in the range `[start, end)` (inclusive start, exclusive end).
+	*
+	* @see {@link BigNum.between} for fully closed range checking [min, max].
 	*
 	* @example
 	* ```ts
 	* pipe(5n, BigNum.inRange(1n, 10n)); // true
 	* ```
 	*/
-	inRange: (start, end) => (a) => a >= start && a < end,
+	inRange: (start, end) => (value) => value >= start && value < end,
 	/**
 	* Returns absolute value of a `bigint`.
 	*
@@ -1126,65 +1314,69 @@ number: (b) => {
 	* BigNum.abs(-42n); // 42n
 	* ```
 	*/
-	abs: (a) => a < 0n ? -a : a,
+	abs: (value) => value < 0n ? -value : value,
 	/**
-	* Returns the minimum of `a` and `b`.
+	* Returns the minimum of `value` and `other`.
+	*
+	* @see {@link BigNum.max} to determine the maximum value.
 	*
 	* @example
 	* ```ts
 	* pipe(10n, BigNum.min(5n)); // 5n
 	* ```
 	*/
-	min: (b) => (a) => a < b ? a : b,
+	min: (other) => (value) => value < other ? value : other,
 	/**
-	* Returns the maximum of `a` and `b`.
+	* Returns the maximum of `value` and `other`.
+	*
+	* @see {@link BigNum.min} to determine the minimum value.
 	*
 	* @example
 	* ```ts
 	* pipe(10n, BigNum.max(5n)); // 10n
 	* ```
 	*/
-	max: (b) => (a) => a > b ? a : b
+	max: (other) => (value) => value > other ? value : other
 };
 //#endregion
 //#region src/Data/Bool.ts
-const isBoolean = (u) => typeof u === "boolean";
-const isTrue = (u) => u === true;
-const isFalse = (u) => u === false;
-const isTruthy = (u) => Boolean(u);
-const isFalsy = (u) => !u;
-const not = (b) => !b;
-const and = (that) => (self) => self && that;
-const or = (that) => (self) => self || that;
-const xor = (that) => (self) => self !== that;
-const andLazy = (that) => (self) => self && that();
-const orLazy = (that) => (self) => self || that();
-const all = (booleans) => {
-	for (let i = 0; i < booleans.length; i++) if (!booleans[i]) return false;
+const isBoolean = (value) => typeof value === "boolean";
+const isTrue = (value) => value === true;
+const isFalse = (value) => value === false;
+const isTruthy = (value) => Boolean(value);
+const isFalsy = (value) => !value;
+const not = (condition) => !condition;
+const and = (that) => (condition) => condition && that;
+const or = (that) => (condition) => condition || that;
+const xor = (that) => (condition) => condition !== that;
+const andLazy = (that) => (condition) => condition && that();
+const orLazy = (that) => (condition) => condition || that();
+const all = (conditions) => {
+	for (let i = 0; i < conditions.length; i++) if (!conditions[i]) return false;
 	return true;
 };
-const any = (booleans) => {
-	for (let i = 0; i < booleans.length; i++) if (booleans[i]) return true;
+const any = (conditions) => {
+	for (let i = 0; i < conditions.length; i++) if (conditions[i]) return true;
 	return false;
 };
-const fold = (onFalse, onTrue) => (b) => b ? onTrue() : onFalse();
-const match = (cases) => (b) => b ? cases.true() : cases.false();
-const fromString = (s) => {
-	const trimmed = s.trim().toLowerCase();
+const fold = (onFalse, onTrue) => (condition) => condition ? onTrue() : onFalse();
+const match = (cases) => (condition) => condition ? cases.true() : cases.false();
+const fromString = (text) => {
+	const trimmed = text.trim().toLowerCase();
 	if (trimmed === "true") return Maybe.make.some(true);
 	if (trimmed === "false") return Maybe.make.some(false);
 	return Maybe.make.none();
 };
-const fromNumber = (n) => {
-	if (n === 1) return Maybe.make.some(true);
-	if (n === 0) return Maybe.make.some(false);
+const fromNumber = (value) => {
+	if (value === 1) return Maybe.make.some(true);
+	if (value === 0) return Maybe.make.some(false);
 	return Maybe.make.none();
 };
 const fromTruthy = (value) => Boolean(value);
-const toMaybe = (onTrue) => (b) => b ? Maybe.make.some(onTrue()) : Maybe.make.none();
-const toResult = (onErr, onOk) => (b) => b ? Result.make.ok(onOk()) : Result.make.err(onErr());
-const toNumber = (b) => b ? 1 : 0;
-const toString = (b) => b ? "true" : "false";
+const toMaybe = (onTrue) => (condition) => condition ? Maybe.make.some(onTrue()) : Maybe.make.none();
+const toResult = (onErr, onOk) => (condition) => condition ? Result.make.ok(onOk()) : Result.make.err(onErr());
+const toNumber = (condition) => condition ? 1 : 0;
+const toString = (condition) => condition ? "true" : "false";
 const Bool = {
 	is: {
 		/**
@@ -1202,6 +1394,8 @@ const Bool = {
 		/**
 		* Narrowing guard — checks if a value is strictly `true`.
 		*
+		* @see {@link Bool.is.false} to check if a value is strictly false.
+		*
 		* @example
 		* ```ts
 		* Bool.is.true(true);  // true
@@ -1212,6 +1406,8 @@ const Bool = {
 		/**
 		* Narrowing guard — checks if a value is strictly `false`.
 		*
+		* @see {@link Bool.is.true} to check if a value is strictly true.
+		*
 		* @example
 		* ```ts
 		* Bool.is.false(false); // true
@@ -1222,6 +1418,8 @@ const Bool = {
 		/**
 		* Type guard — checks if a value is truthy (not `false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
 		*
+		* @see {@link Bool.is.falsy} to check if a value is falsy.
+		*
 		* @example
 		* ```ts
 		* Bool.is.truthy("hello"); // true
@@ -1234,6 +1432,8 @@ const Bool = {
 		/**
 		* Type guard — checks if a value is falsy (`false`, `0`, `0n`, `""`, `null`, `undefined`, or `NaN`).
 		*
+		* @see {@link Bool.is.truthy} to check if a value is truthy.
+		*
 		* @example
 		* ```ts
 		* Bool.is.falsy("");        // true
@@ -1254,9 +1454,12 @@ const Bool = {
 	*/
 	not,
 	/**
-	* Logical AND combinator. Returns `true` only if both `self` and `that` are `true`.
+	* Logical AND combinator. Returns `true` only if both `condition` and `that` are `true`.
 	*
-	* Data-last: `pipe(self, Bool.and(that))`.
+	* Data-last: `pipe(condition, Bool.and(that))`.
+	*
+	* @see {@link Bool.or} for logical OR combinator.
+	* @see {@link Bool.andLazy} for short-circuiting lazy evaluation.
 	*
 	* @example
 	* ```ts
@@ -1266,9 +1469,12 @@ const Bool = {
 	*/
 	and,
 	/**
-	* Logical OR combinator. Returns `true` if either `self` or `that` is `true`.
+	* Logical OR combinator. Returns `true` if either `condition` or `that` is `true`.
+	*
+	* Data-last: `pipe(condition, Bool.or(that))`.
 	*
-	* Data-last: `pipe(self, Bool.or(that))`.
+	* @see {@link Bool.and} for logical AND combinator.
+	* @see {@link Bool.orLazy} for short-circuiting lazy evaluation.
 	*
 	* @example
 	* ```ts
@@ -1278,9 +1484,9 @@ const Bool = {
 	*/
 	or,
 	/**
-	* Logical XOR (exclusive OR) combinator. Returns `true` if exactly one of `self` and `that` is `true`.
+	* Logical XOR (exclusive OR) combinator. Returns `true` if exactly one of `condition` and `that` is `true`.
 	*
-	* Data-last: `pipe(self, Bool.xor(that))`.
+	* Data-last: `pipe(condition, Bool.xor(that))`.
 	*
 	* @example
 	* ```ts
@@ -1291,9 +1497,12 @@ const Bool = {
 	xor,
 	/**
 	* Lazy logical AND combinator.
-	* If `self` is `false`, the `that` computation is never evaluated.
+	* If `condition` is `false`, the `that` computation is never evaluated.
 	*
-	* Data-last: `pipe(self, Bool.andLazy(that))`.
+	* Data-last: `pipe(condition, Bool.andLazy(that))`.
+	*
+	* @see {@link Bool.orLazy} for lazy logical OR combinator.
+	* @see {@link Bool.and} for strict logical AND evaluation.
 	*
 	* @example
 	* ```ts
@@ -1306,9 +1515,12 @@ const Bool = {
 	andLazy,
 	/**
 	* Lazy logical OR combinator.
-	* If `self` is `true`, the `that` computation is never evaluated.
+	* If `condition` is `true`, the `that` computation is never evaluated.
+	*
+	* Data-last: `pipe(condition, Bool.orLazy(that))`.
 	*
-	* Data-last: `pipe(self, Bool.orLazy(that))`.
+	* @see {@link Bool.andLazy} for lazy logical AND combinator.
+	* @see {@link Bool.or} for strict logical OR evaluation.
 	*
 	* @example
 	* ```ts
@@ -1324,6 +1536,8 @@ const Bool = {
 	* Returns `true` if every boolean is `true`, or for an empty array (vacuous truth).
 	* Short-circuits on the first `false`.
 	*
+	* @see {@link Bool.any} to check if at least one boolean is true.
+	*
 	* @example
 	* ```ts
 	* Bool.all([true, true, true]);  // true
@@ -1337,6 +1551,8 @@ const Bool = {
 	* Returns `true` if at least one boolean is `true`. Returns `false` for an empty array.
 	* Short-circuits on the first `true`.
 	*
+	* @see {@link Bool.all} to check if all booleans are true.
+	*
 	* @example
 	* ```ts
 	* Bool.any([false, true, false]); // true
@@ -1351,6 +1567,8 @@ const Bool = {
 	* Positional ordering: `onFalse` first, `onTrue` second.
 	* Aligned with `Result.fold(onErr, onOk)` and `Maybe.fold(onNone, onSome)`.
 	*
+	* @see {@link Bool.match} for named-case pattern matching with an object literal.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -1366,6 +1584,8 @@ const Bool = {
 	/**
 	* Pattern matching on boolean using named cases `{ true, false }`.
 	*
+	* @see {@link Bool.fold} for positional argument pattern matching.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -1470,119 +1690,221 @@ const Bool = {
 //#endregion
 //#region src/Data/Dict.ts
 const DictIs = {
-	empty: (m) => m.size === 0,
-	nonEmpty: (m) => m.size > 0
+	/**
+	* Returns `true` when the dictionary contains zero entries.
+	*
+	* @see {@link nonEmpty} for checking if a dictionary contains entries.
+	*/
+	empty: (dict) => dict.size === 0,
+	/**
+	* Returns `true` when the dictionary contains at least one entry.
+	*
+	* @see {@link empty} for checking if a dictionary is empty.
+	*/
+	nonEmpty: (dict) => dict.size > 0
 };
 const empty$1 = () => new globalThis.Map();
 const singleton$1 = (key, value) => new globalThis.Map([[key, value]]);
 const DictFrom = {
 	entries: (entries) => new globalThis.Map(entries),
-	Record: (record) => new globalThis.Map(Object.entries(record)),
-	Array: (data) => new globalThis.Map(data),
-	nullable: (data) => data === null || data === void 0 ? Maybe.make.none() : Maybe.make.some(data)
+	record: (record) => new globalThis.Map(Object.entries(record)),
+	nullable: (dict) => dict === null || dict === void 0 ? Maybe.make.none() : Maybe.make.some(dict)
 };
-const DictTo = { Record: (map) => {
+const DictTo = { record: (dict) => {
 	const result = {};
-	for (const [k, v] of map) result[k] = v;
+	for (const [k, v] of dict) result[k] = v;
 	return result;
 } };
-const groupBy$1 = (f) => (as) => {
+const groupBy$1 = (keySelector) => (items) => {
 	const result = new globalThis.Map();
-	for (const a of as) {
-		const k = f(a);
+	for (const item of items) {
+		const k = keySelector(item);
 		const existing = result.get(k);
-		if (existing !== void 0) existing.push(a);
-		else result.set(k, [a]);
+		if (existing !== void 0) existing.push(item);
+		else result.set(k, [item]);
 	}
 	return result;
 };
-const has$1 = (key) => (data) => data.has(key);
-const lookup$1 = (key) => (data) => {
-	const val = data.get(key);
-	return val !== void 0 || data.has(key) ? Maybe.make.some(val) : Maybe.make.none();
-};
-const size$2 = (data) => data.size;
-const keys$1 = (data) => Array.from(data.keys());
-const values$1 = (data) => Array.from(data.values());
-const entries$1 = (data) => Array.from(data.entries());
-const insert = (key, value) => (data) => {
-	const res = new globalThis.Map(data);
+/**
+* Returns `true` when the dictionary contains the specified key.
+*
+* @see {@link lookup} for retrieving the value associated with a key.
+*/
+const has$1 = (key) => (dict) => dict.has(key);
+/**
+* Retrieves the value associated with a key wrapped in a `Maybe`.
+*
+* @see {@link has} for checking key existence without retrieving the value.
+*/
+const lookup$1 = (key) => (dict) => {
+	const val = dict.get(key);
+	return val !== void 0 || dict.has(key) ? Maybe.make.some(val) : Maybe.make.none();
+};
+const size$2 = (dict) => dict.size;
+/**
+* Returns all keys of a dictionary.
+*
+* @see {@link values} for extracting dictionary values.
+* @see {@link entries} for extracting key-value pairs.
+*/
+const keys$1 = (dict) => Array.from(dict.keys());
+/**
+* Returns all values of a dictionary.
+*
+* @see {@link keys} for extracting dictionary keys.
+* @see {@link entries} for extracting key-value pairs.
+*/
+const values$1 = (dict) => Array.from(dict.values());
+/**
+* Returns all key-value pairs of a dictionary.
+*
+* @see {@link keys} for extracting dictionary keys.
+* @see {@link values} for extracting dictionary values.
+*/
+const entries$1 = (dict) => Array.from(dict.entries());
+/**
+* Returns a new dictionary with the key set to value.
+*
+* @see {@link remove} for deleting a key from a dictionary.
+* @see {@link upsert} for conditional insertion/update.
+*/
+const insert = (key, value) => (dict) => {
+	const res = new globalThis.Map(dict);
 	res.set(key, value);
 	return res;
 };
-const remove$1 = (key) => (data) => {
-	if (!data.has(key)) return data;
-	const res = new globalThis.Map(data);
+/**
+* Returns a new dictionary with the specified key removed.
+*
+* @see {@link insert} for adding or replacing a key in a dictionary.
+*/
+const remove$1 = (key) => (dict) => {
+	if (!dict.has(key)) return dict;
+	const res = new globalThis.Map(dict);
 	res.delete(key);
 	return res;
 };
-const upsert = (key, f) => (data) => {
-	const res = new globalThis.Map(data);
-	const existing = data.has(key) ? Maybe.make.some(data.get(key)) : Maybe.make.none();
-	res.set(key, f(existing));
+/**
+* Inserts or updates a key using a callback that receives the existing value if present.
+*
+* @see {@link insert} for unconditional key setting.
+*/
+const upsert = (key, update) => (dict) => {
+	const res = new globalThis.Map(dict);
+	const existing = dict.has(key) ? Maybe.make.some(dict.get(key)) : Maybe.make.none();
+	res.set(key, update(existing));
 	return res;
 };
-const map$2 = (f) => (data) => {
+/**
+* Transforms each value in the dictionary.
+*
+* @see {@link mapWithKey} for transforming values with key access.
+*/
+const map$2 = (transform) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) res.set(k, f(v));
+	for (const [k, v] of dict) res.set(k, transform(v));
 	return res;
 };
-const mapWithKey$1 = (f) => (data) => {
+/**
+* Transforms each value in the dictionary, also receiving the key.
+*
+* @see {@link map} for transforming values without key access.
+*/
+const mapWithKey$1 = (transform) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) res.set(k, f(k, v));
+	for (const [k, v] of dict) res.set(k, transform(k, v));
 	return res;
 };
-const filter$2 = (predicate) => (data) => {
+/**
+* Filters dictionary entries by a predicate on values.
+*
+* @see {@link filterWithKey} for filtering with key access.
+*/
+const filter$2 = (predicate) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) if (predicate(v)) res.set(k, v);
+	for (const [k, v] of dict) if (predicate(v)) res.set(k, v);
 	return res;
 };
-const filterWithKey$1 = (predicate) => (data) => {
+/**
+* Filters dictionary entries by a predicate that also receives the key.
+*
+* @see {@link filter} for filtering values without key access.
+*/
+const filterWithKey$1 = (predicate) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) if (predicate(k, v)) res.set(k, v);
+	for (const [k, v] of dict) if (predicate(k, v)) res.set(k, v);
 	return res;
 };
-const compact$1 = (data) => {
+/**
+* Removes all `None` values from a dictionary, unwrapping `Some` values.
+*/
+const compact$1 = (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) if (v.kind === "Some") res.set(k, v.value);
+	for (const [k, v] of dict) if (v.kind === "Some") res.set(k, v.value);
 	return res;
 };
-const filterMap$2 = (f) => (data) => {
+/**
+* Transforms values with a function returning `Maybe`, keeping only `Some` values.
+*
+* @see {@link filter} for filtering without transformation.
+*/
+const filterMap$2 = (transform) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) {
-		const mb = f(v);
+	for (const [k, v] of dict) {
+		const mb = transform(v);
 		if (mb.kind === "Some") res.set(k, mb.value);
 	}
 	return res;
 };
-const union$1 = (other) => (data) => {
-	if (data.size === 0) return other;
-	if (other.size === 0) return data;
-	const res = new globalThis.Map(data);
+/**
+* Combines two dictionaries, preferring entries from `other` on key collisions.
+*
+* @see {@link intersection} for keeping only common keys.
+* @see {@link difference} for removing keys present in the other dictionary.
+*/
+const union$1 = (other) => (dict) => {
+	if (dict.size === 0) return other;
+	if (other.size === 0) return dict;
+	const res = new globalThis.Map(dict);
 	for (const [k, v] of other) res.set(k, v);
 	return res;
 };
-const intersection$1 = (other) => (data) => {
+/**
+* Returns a new dictionary containing only keys present in both dictionaries.
+*
+* @see {@link union} for combining all keys from both dictionaries.
+* @see {@link difference} for subtracting keys.
+*/
+const intersection$1 = (other) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) if (other.has(k)) res.set(k, v);
+	for (const [k, v] of dict) if (other.has(k)) res.set(k, v);
 	return res;
 };
-const difference$1 = (other) => (data) => {
-	if (other.size === 0) return data;
+/**
+* Returns a new dictionary containing keys from `dict` that are not in `other`.
+*
+* @see {@link union} for combining all keys.
+* @see {@link intersection} for keeping only common keys.
+*/
+const difference$1 = (other) => (dict) => {
+	if (other.size === 0) return dict;
 	const res = new globalThis.Map();
-	for (const [k, v] of data) if (!other.has(k)) res.set(k, v);
+	for (const [k, v] of dict) if (!other.has(k)) res.set(k, v);
 	return res;
 };
-const reduce$1 = (init, f) => (data) => {
-	let acc = init;
-	for (const [, v] of data) acc = f(acc, v);
+const reduce$1 = (initial, reducer) => (dict) => {
+	let acc = initial;
+	for (const [, v] of dict) acc = reducer(acc, v);
 	return acc;
 };
-const reduceWithKey = (init, f) => (data) => {
-	let acc = init;
-	for (const [k, v] of data) acc = f(acc, v, k);
+const reduceWithKey = (initial, reducer) => (dict) => {
+	let acc = initial;
+	for (const [k, v] of dict) acc = reducer(acc, v, k);
 	return acc;
 };
+/**
+* Merges two dictionaries using a combination function on collisions.
+*/
 function mergeWith$1(combine) {
 	return ((arg1, arg2) => {
 		if (arg2 !== void 0) {
@@ -1600,27 +1922,27 @@ function mergeWith$1(combine) {
 		};
 	});
 }
-const mapEntries$1 = (f) => (data) => {
+const mapEntries$1 = (transform) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) {
-		const [nk, nv] = f(k, v);
+	for (const [k, v] of dict) {
+		const [nk, nv] = transform(k, v);
 		res.set(nk, nv);
 	}
 	return res;
 };
-const mapKeys$1 = (f) => (data) => {
+const mapKeys$1 = (transform) => (dict) => {
 	const res = new globalThis.Map();
-	for (const [k, v] of data) res.set(f(k), v);
+	for (const [k, v] of dict) res.set(transform(k), v);
 	return res;
 };
 const _nonEmptySingleton = (key, value) => new globalThis.Map([[key, value]]);
-const _nonEmptyFromMap = (m) => m.size > 0 ? Maybe.make.some(m) : Maybe.make.none();
-const _nonEmptyKeys = (m) => keys$1(m);
-const _nonEmptyValues = (m) => values$1(m);
-const _nonEmptyEntries = (m) => entries$1(m);
-const _nonEmptyReduce = (f) => (m) => _nonEmptyValues(m).reduce(f);
-const _nonEmptyMap = (f) => (m) => map$2(f)(m);
-const _nonEmptyMapWithKey = (f) => (m) => mapWithKey$1(f)(m);
+const _nonEmptyFromMap = (dict) => dict.size > 0 ? Maybe.make.some(dict) : Maybe.make.none();
+const _nonEmptyKeys = (dict) => keys$1(dict);
+const _nonEmptyValues = (dict) => values$1(dict);
+const _nonEmptyEntries = (dict) => entries$1(dict);
+const _nonEmptyReduce = (reducer) => (dict) => _nonEmptyValues(dict).reduce(reducer);
+const _nonEmptyMap = (transform) => (dict) => map$2(transform)(dict);
+const _nonEmptyMapWithKey = (transform) => (dict) => mapWithKey$1(transform)(dict);
 const Dict = {
 	is: DictIs,
 	empty: empty$1,
@@ -1653,7 +1975,7 @@ const Dict = {
 	mapKeys: mapKeys$1,
 	NonEmpty: {
 		singleton: _nonEmptySingleton,
-		from: { Map: _nonEmptyFromMap },
+		from: { map: _nonEmptyFromMap },
 		keys: _nonEmptyKeys,
 		values: _nonEmptyValues,
 		entries: _nonEmptyEntries,
@@ -1706,9 +2028,9 @@ const Json = {
 };
 //#endregion
 //#region src/Data/Num.ts
-const sumFn = (ns) => {
+const sumFn = (numbers) => {
 	let result = 0;
-	for (let i = 0; i < ns.length; i++) result += ns[i];
+	for (let i = 0; i < numbers.length; i++) result += numbers[i];
 	return result;
 };
 const Num = {
@@ -1722,27 +2044,31 @@ const Num = {
 		* Num.is.zero(5); // false
 		* ```
 		*/
-		zero: (n) => n === 0,
+		zero: (value) => value === 0,
 		/**
 		* Returns `true` when the number is a whole integer.
 		*
+		* @see {@link Num.is.float} to check for fractional numbers.
+		*
 		* @example
 		* ```ts
 		* Num.is.integer(5);    // true
 		* Num.is.integer(3.14); // false
 		* ```
 		*/
-		integer: (n) => Number.isInteger(n),
+		integer: (value) => Number.isInteger(value),
 		/**
 		* Returns `true` when the number is a finite float (fractional number).
 		*
+		* @see {@link Num.is.integer} to check for whole numbers.
+		*
 		* @example
 		* ```ts
 		* Num.is.float(3.14); // true
 		* Num.is.float(5);    // false
 		* ```
 		*/
-		float: (n) => Number.isFinite(n) && !Number.isInteger(n),
+		float: (value) => Number.isFinite(value) && !Number.isInteger(value),
 		/**
 		* Returns `true` when the number is finite (not `Infinity`, `-Infinity`, or `NaN`).
 		*
@@ -1752,7 +2078,7 @@ const Num = {
 		* Num.is.finite(Infinity); // false
 		* ```
 		*/
-		finite: (n) => Number.isFinite(n),
+		finite: (value) => Number.isFinite(value),
 		/**
 		* Returns `true` when the value is `NaN`.
 		*
@@ -1762,10 +2088,12 @@ const Num = {
 		* Num.is.nan(42);  // false
 		* ```
 		*/
-		nan: (n) => Number.isNaN(n),
+		nan: (value) => Number.isNaN(value),
 		/**
 		* Returns `true` when the number is an even integer.
 		*
+		* @see {@link Num.is.odd} to check if a number is odd.
+		*
 		* @example
 		* ```ts
 		* Num.is.even(4);   // true
@@ -1773,10 +2101,12 @@ const Num = {
 		* Num.is.even(2.5); // false
 		* ```
 		*/
-		even: (n) => Number.isInteger(n) && n % 2 === 0,
+		even: (value) => Number.isInteger(value) && value % 2 === 0,
 		/**
 		* Returns `true` when the number is an odd integer.
 		*
+		* @see {@link Num.is.even} to check if a number is even.
+		*
 		* @example
 		* ```ts
 		* Num.is.odd(3);   // true
@@ -1784,10 +2114,12 @@ const Num = {
 		* Num.is.odd(2.5); // false
 		* ```
 		*/
-		odd: (n) => Number.isInteger(n) && n % 2 !== 0,
+		odd: (value) => Number.isInteger(value) && value % 2 !== 0,
 		/**
 		* Returns `true` when the number is strictly greater than zero.
 		*
+		* @see {@link Num.is.negative} to check if a number is less than zero.
+		*
 		* @example
 		* ```ts
 		* Num.is.positive(5);  // true
@@ -1795,10 +2127,12 @@ const Num = {
 		* Num.is.positive(-5); // false
 		* ```
 		*/
-		positive: (n) => n > 0,
+		positive: (value) => value > 0,
 		/**
 		* Returns `true` when the number is strictly less than zero.
 		*
+		* @see {@link Num.is.positive} to check if a number is greater than zero.
+		*
 		* @example
 		* ```ts
 		* Num.is.negative(-5); // true
@@ -1806,7 +2140,7 @@ const Num = {
 		* Num.is.negative(5);  // false
 		* ```
 		*/
-		negative: (n) => n < 0
+		negative: (value) => value < 0
 	},
 	/**
 	* Generates an array of numbers from `from` to `to` (both inclusive),
@@ -1840,10 +2174,12 @@ const Num = {
 	* pipe(42, Num.clamp(0, 100));  // 42
 	* ```
 	*/
-	clamp: (min, max) => (n) => Math.min(Math.max(n, min), max),
+	clamp: (min, max) => (value) => Math.min(Math.max(value, min), max),
 	/**
 	* Returns `true` when the number is between `min` and `max` (both inclusive).
 	*
+	* @see {@link Num.inRange} for half-open range checking [start, end).
+	*
 	* @example
 	* ```ts
 	* pipe(5, Num.between(1, 10));  // true
@@ -1851,10 +2187,12 @@ const Num = {
 	* pipe(10, Num.between(1, 10)); // true
 	* ```
 	*/
-	between: (min, max) => (n) => n >= min && n <= max,
+	between: (min, max) => (value) => value >= min && value <= max,
 	/**
 	* Returns `true` when the number is in the range `[start, end)` (inclusive of `start`, exclusive of `end`).
 	*
+	* @see {@link Num.between} for fully closed range checking [min, max].
+	*
 	* @example
 	* ```ts
 	* pipe(5, Num.inRange(1, 10));  // true
@@ -1862,7 +2200,7 @@ const Num = {
 	* pipe(10, Num.inRange(1, 10)); // false
 	* ```
 	*/
-	inRange: (start, end) => (n) => n >= start && n < end,
+	inRange: (start, end) => (value) => value >= start && value < end,
 	/**
 	* Parses a string as a number. Returns `None` when the result is `NaN`.
 	*
@@ -1874,13 +2212,15 @@ const Num = {
 	* Num.parse("");     // None
 	* ```
 	*/
-	parse: (s) => {
-		if (s.trim() === "") return Maybe.make.none();
-		const n = Number(s);
+	parse: (text) => {
+		if (text.trim() === "") return Maybe.make.none();
+		const n = Number(text);
 		return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
 	},
 	/**
-	* Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
+	* Adds `amount` to a number. Data-last: use in `pipe` or `Arr.map`.
+	*
+	* @see {@link Num.subtract} to subtract an amount from a number.
 	*
 	* @example
 	* ```ts
@@ -1888,9 +2228,11 @@ const Num = {
 	* pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
 	* ```
 	*/
-	add: (b) => (a) => a + b,
+	add: (amount) => (value) => value + amount,
 	/**
-	* Subtracts `b` from a number. Data-last: `subtract(b)(a)` = `a - b`.
+	* Subtracts `amount` from a number. Data-last: `subtract(amount)(from)` = `from - amount`.
+	*
+	* @see {@link Num.add} to add an amount to a number.
 	*
 	* @example
 	* ```ts
@@ -1898,9 +2240,11 @@ const Num = {
 	* pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
 	* ```
 	*/
-	subtract: (b) => (a) => a - b,
+	subtract: (amount) => (from) => from - amount,
 	/**
-	* Multiplies a number by `b`. Data-last: use in `pipe` or `Arr.map`.
+	* Multiplies a number by `factor`. Data-last: use in `pipe` or `Arr.map`.
+	*
+	* @see {@link Num.divide} to divide a number by a divisor.
 	*
 	* @example
 	* ```ts
@@ -1908,9 +2252,12 @@ const Num = {
 	* pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]
 	* ```
 	*/
-	multiply: (b) => (a) => a * b,
+	multiply: (factor) => (value) => value * factor,
 	/**
-	* Divides a number by `b`. Returns `None` when `b` is zero. Data-last: `divide(b)(a)` = `a / b`.
+	* Divides a number by `divisor`. Returns `None` when `divisor` is zero. Data-last: `divide(divisor)(dividend)` = `dividend / divisor`.
+	*
+	* @see {@link Num.multiply} to multiply a number by a factor.
+	* @see {@link Num.remainder} to compute the division remainder.
 	*
 	* @example
 	* ```ts
@@ -1919,7 +2266,7 @@ const Num = {
 	* pipe([10, 20, 30], Arr.filterMap(Num.divide(10))); // [1, 2, 3]
 	* ```
 	*/
-	divide: (b) => (a) => b === 0 ? Maybe.make.none() : Maybe.make.some(a / b),
+	divide: (divisor) => (dividend) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(dividend / divisor),
 	/**
 	* Returns the absolute value of a number.
 	*
@@ -1929,7 +2276,7 @@ const Num = {
 	* pipe(5, Num.abs);  // 5
 	* ```
 	*/
-	abs: (n) => Math.abs(n),
+	abs: (value) => Math.abs(value),
 	/**
 	* Negates a number (arithmetic negation).
 	*
@@ -1939,40 +2286,51 @@ const Num = {
 	* pipe(-5, Num.negate); // 5
 	* ```
 	*/
-	negate: (n) => -n,
+	negate: (value) => -value,
 	/**
 	* Rounds a number to the nearest integer.
 	*
+	* @see {@link Num.floor} to round down.
+	* @see {@link Num.ceil} to round up.
+	*
 	* @example
 	* ```ts
 	* pipe(3.5, Num.round); // 4
 	* pipe(3.4, Num.round); // 3
 	* ```
 	*/
-	round: (n) => Math.round(n),
+	round: (value) => Math.round(value),
 	/**
 	* Rounds a number down to the nearest integer.
 	*
+	* @see {@link Num.round} to round to nearest integer.
+	* @see {@link Num.ceil} to round up.
+	*
 	* @example
 	* ```ts
 	* pipe(3.9, Num.floor); // 3
 	* pipe(-3.2, Num.floor); // -4
 	* ```
 	*/
-	floor: (n) => Math.floor(n),
+	floor: (value) => Math.floor(value),
 	/**
 	* Rounds a number up to the nearest integer.
 	*
+	* @see {@link Num.round} to round to nearest integer.
+	* @see {@link Num.floor} to round down.
+	*
 	* @example
 	* ```ts
 	* pipe(3.1, Num.ceil); // 4
 	* pipe(-3.9, Num.ceil); // -3
 	* ```
 	*/
-	ceil: (n) => Math.ceil(n),
+	ceil: (value) => Math.ceil(value),
 	/**
 	* Returns the remainder of dividing a number by `divisor`. Returns `None` when `divisor` is zero.
-	* Data-last: `remainder(divisor)(a)` = `a % divisor`.
+	* Data-last: `remainder(divisor)(dividend)` = `dividend % divisor`.
+	*
+	* @see {@link Num.divide} for full division.
 	*
 	* @example
 	* ```ts
@@ -1981,7 +2339,7 @@ const Num = {
 	* pipe([10, 11, 12], Arr.filterMap(Num.remainder(3))); // [1, 2, 0]
 	* ```
 	*/
-	remainder: (divisor) => (n) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(n % divisor),
+	remainder: (divisor) => (dividend) => divisor === 0 ? Maybe.make.none() : Maybe.make.some(dividend % divisor),
 	/**
 	* Computes the sum of a list of numbers. Returns `0` if the list is empty.
 	*
@@ -2001,39 +2359,43 @@ const Num = {
 	* Num.mean([]);        // None
 	* ```
 	*/
-	mean: (ns) => ns.length === 0 ? Maybe.make.none() : Maybe.make.some(sumFn(ns) / ns.length),
+	mean: (numbers) => numbers.length === 0 ? Maybe.make.none() : Maybe.make.some(sumFn(numbers) / numbers.length),
 	/**
 	* Computes the minimum of a list of numbers. Returns `None` if the list is empty.
 	*
+	* @see {@link Num.max} to compute the maximum value.
+	*
 	* @example
 	* ```ts
 	* Num.min([5, 1, 3]); // Some(1)
 	* Num.min([]);        // None
 	* ```
 	*/
-	min: (ns) => {
-		if (ns.length === 0) return Maybe.make.none();
-		let [result] = ns;
-		for (let i = 1; i < ns.length; i++) if (ns[i] < result) result = ns[i];
+	min: (numbers) => {
+		if (numbers.length === 0) return Maybe.make.none();
+		let [result] = numbers;
+		for (let i = 1; i < numbers.length; i++) if (numbers[i] < result) result = numbers[i];
 		return Maybe.make.some(result);
 	},
 	/**
 	* Computes the maximum of a list of numbers. Returns `None` if the list is empty.
 	*
+	* @see {@link Num.min} to compute the minimum value.
+	*
 	* @example
 	* ```ts
 	* Num.max([1, 5, 3]); // Some(5)
 	* Num.max([]);        // None
 	* ```
 	*/
-	max: (ns) => {
-		if (ns.length === 0) return Maybe.make.none();
-		let [result] = ns;
-		for (let i = 1; i < ns.length; i++) if (ns[i] > result) result = ns[i];
+	max: (numbers) => {
+		if (numbers.length === 0) return Maybe.make.none();
+		let [result] = numbers;
+		for (let i = 1; i < numbers.length; i++) if (numbers[i] > result) result = numbers[i];
 		return Maybe.make.some(result);
 	},
 	/**
-	* Formats a number using `Intl.NumberFormat`. Returns `None` when `n` is `NaN` or non-finite.
+	* Formats a number using `Intl.NumberFormat`. Returns `None` when `value` is `NaN` or non-finite.
 	* Data-last curried signature.
 	*
 	* @example
@@ -2043,11 +2405,11 @@ const Num = {
 	* pipe(NaN, formatCurrency);    // None
 	* ```
 	*/
-	format: (options, locales) => (n) => !Number.isFinite(n) ? Maybe.make.none() : Maybe.make.some(new Intl.NumberFormat(locales, options).format(n))
+	format: (options, locales) => (value) => !Number.isFinite(value) ? Maybe.make.none() : Maybe.make.some(new Intl.NumberFormat(locales, options).format(value))
 };
 //#endregion
 //#region src/Data/Rec.ts
-const _isNonEmpty = (data) => Object.keys(data).length > 0;
+const _isNonEmpty = (record) => Object.keys(record).length > 0;
 const _setKey = (record, key, value) => {
 	if (key === "__proto__") Object.defineProperty(record, key, {
 		value,
@@ -2059,8 +2421,8 @@ const _setKey = (record, key, value) => {
 };
 let RecMaybe;
 (function(_RecMaybe) {
-	const traverse = _RecMaybe.traverse = (f) => (data) => {
-		const recordKeys = Object.keys(data);
+	const traverse = _RecMaybe.traverse = (transform) => (record) => {
+		const recordKeys = Object.keys(record);
 		if (recordKeys.length === 0) return {
 			kind: "Some",
 			value: {}
@@ -2068,7 +2430,7 @@ let RecMaybe;
 		const result = {};
 		for (let i = 0; i < recordKeys.length; i++) {
 			const key = recordKeys[i];
-			const maybeVal = f(data[key]);
+			const maybeVal = transform(record[key]);
 			if (maybeVal.kind === "None") return maybeVal;
 			_setKey(result, key, maybeVal.value);
 		}
@@ -2077,16 +2439,16 @@ let RecMaybe;
 			value: result
 		};
 	};
-	_RecMaybe.sequence = (data) => traverse((a) => a)(data);
+	_RecMaybe.sequence = (record) => traverse((value) => value)(record);
 })(RecMaybe || (RecMaybe = {}));
 let RecResult;
 (function(_RecResult) {
-	const traverse = _RecResult.traverse = (f) => (data) => {
-		const recordKeys = Object.keys(data);
+	const traverse = _RecResult.traverse = (transform) => (record) => {
+		const recordKeys = Object.keys(record);
 		const result = {};
 		for (let i = 0; i < recordKeys.length; i++) {
 			const key = recordKeys[i];
-			const res = f(data[key]);
+			const res = transform(record[key]);
 			if (res.kind === "Err") return res;
 			_setKey(result, key, res.value);
 		}
@@ -2095,7 +2457,7 @@ let RecResult;
 			value: result
 		};
 	};
-	_RecResult.sequence = (data) => traverse((a) => a)(data);
+	_RecResult.sequence = (record) => traverse((value) => value)(record);
 })(RecResult || (RecResult = {}));
 /**
 * Functional record/object utilities that compose well with pipe.
@@ -2117,16 +2479,20 @@ const RecIs = {
 	/**
 	* Returns true if the record has no keys.
 	*
+	* @see {@link nonEmpty} for checking if a record has keys.
+	*
 	* @example
 	* ```ts
 	* Rec.is.empty({});       // true
 	* Rec.is.empty({ a: 1 }); // false
 	* ```
 	*/
-	empty: (data) => Object.keys(data).length === 0,
+	empty: (record) => Object.keys(record).length === 0,
 	/**
 	* Type guard to check if a record is non-empty.
 	*
+	* @see {@link empty} for checking if a record has no keys.
+	*
 	* @example
 	* ```ts
 	* Rec.is.nonEmpty({ a: 1 }); // true
@@ -2138,30 +2504,36 @@ const RecIs = {
 /**
 * Transforms each value in a record.
 *
+* @see {@link mapWithKey} for transforming values with key access.
+* @see {@link mapKeys} for transforming keys while preserving values.
+* @see {@link mapEntries} for transforming keys and values simultaneously.
+*
 * @example
 * ```ts
 * pipe({ a: 1, b: 2 }, Rec.map(n => n * 2)); // { a: 2, b: 4 }
 * ```
 */
-const map$1 = (f) => (data) => {
-	const recordKeys = Object.keys(data);
-	const recordValues = Object.values(data);
-	const result = Object.create(Object.getPrototypeOf(data));
+const map$1 = (transform) => (record) => {
+	const recordKeys = Object.keys(record);
+	const recordValues = Object.values(record);
+	const result = Object.create(Object.getPrototypeOf(record));
 	for (let i = 0; i < recordKeys.length; i++) {
 		const key = recordKeys[i];
 		if (key === "__proto__") Object.defineProperty(result, "__proto__", {
-			value: f(recordValues[i]),
+			value: transform(recordValues[i]),
 			writable: true,
 			enumerable: true,
 			configurable: true
 		});
-		else result[key] = f(recordValues[i]);
+		else result[key] = transform(recordValues[i]);
 	}
 	return result;
 };
 /**
 * Maps each value in a record with a function returning a `Maybe`, keeping only `Some` values.
 *
+* @see {@link filter} for filtering with a boolean predicate.
+*
 * @example
 * ```ts
 * pipe(
@@ -2170,12 +2542,12 @@ const map$1 = (f) => (data) => {
 * ); // { b: 20 }
 * ```
 */
-const filterMap$1 = (f) => (data) => {
-	const recordKeys = Object.keys(data);
-	const recordValues = Object.values(data);
-	const result = Object.create(Object.getPrototypeOf(data));
+const filterMap$1 = (transform) => (record) => {
+	const recordKeys = Object.keys(record);
+	const recordValues = Object.values(record);
+	const result = Object.create(Object.getPrototypeOf(record));
 	for (let i = 0; i < recordKeys.length; i++) {
-		const maybeVal = f(recordValues[i]);
+		const maybeVal = transform(recordValues[i]);
 		if (maybeVal.kind === "Some") _setKey(result, recordKeys[i], maybeVal.value);
 	}
 	return result;
@@ -2183,49 +2555,56 @@ const filterMap$1 = (f) => (data) => {
 /**
 * Transforms each value in a record, also receiving the key.
 *
+* @see {@link map} for transforming values without key access.
+*
 * @example
 * ```ts
 * pipe({ a: 1, b: 2 }, Rec.mapWithKey((k, v) => `${k}:${v}`));
 * // { a: "a:1", b: "b:2" }
 * ```
 */
-const mapWithKey = (f) => (data) => {
-	const recordKeys = Object.keys(data);
-	const recordValues = Object.values(data);
-	const result = Object.create(Object.getPrototypeOf(data));
+const mapWithKey = (transform) => (record) => {
+	const recordKeys = Object.keys(record);
+	const recordValues = Object.values(record);
+	const result = Object.create(Object.getPrototypeOf(record));
 	for (let i = 0; i < recordKeys.length; i++) {
 		const key = recordKeys[i];
-		_setKey(result, key, f(key, recordValues[i]));
+		_setKey(result, key, transform(key, recordValues[i]));
 	}
 	return result;
 };
 /**
 * Filters values in a record by a predicate.
 *
+* @see {@link filterWithKey} for filtering values with key access.
+* @see {@link filterMap} for filtering and mapping in a single pass.
+*
 * @example
 * ```ts
 * pipe({ a: 1, b: 2, c: 3 }, Rec.filter(n => n > 1)); // { b: 2, c: 3 }
 * ```
 */
-const filter$1 = (predicate) => (data) => {
-	const recordKeys = Object.keys(data);
-	const recordValues = Object.values(data);
-	const result = Object.create(Object.getPrototypeOf(data));
+const filter$1 = (predicate) => (record) => {
+	const recordKeys = Object.keys(record);
+	const recordValues = Object.values(record);
+	const result = Object.create(Object.getPrototypeOf(record));
 	for (let i = 0; i < recordKeys.length; i++) if (predicate(recordValues[i])) _setKey(result, recordKeys[i], recordValues[i]);
 	return result;
 };
 /**
 * Filters values in a record by a predicate that also receives the key.
 *
+* @see {@link filter} for filtering values without key access.
+*
 * @example
 * ```ts
 * pipe({ a: 1, b: 2, c: 3 }, Rec.filterWithKey((k, v) => k !== "a" && v > 0));
 * // { b: 2 }
 * ```
 */
-const filterWithKey = (predicate) => (data) => {
+const filterWithKey = (predicate) => (record) => {
 	const result = {};
-	for (const [k, v] of Object.entries(data)) if (predicate(k, v)) _setKey(result, k, v);
+	for (const [k, v] of Object.entries(record)) if (predicate(k, v)) _setKey(result, k, v);
 	return result;
 };
 /**
@@ -2237,37 +2616,46 @@ const filterWithKey = (predicate) => (data) => {
 * pipe({ a: 1, b: 2 }, Rec.lookup("c")); // None
 * ```
 */
-const lookup = (key) => (data) => Object.hasOwn(data, key) ? {
+const lookup = (key) => (record) => Object.hasOwn(record, key) ? {
 	kind: "Some",
-	value: data[key]
+	value: record[key]
 } : { kind: "None" };
 /**
 * Returns all keys of a record.
 *
+* @see {@link values} for extracting record values.
+* @see {@link entries} for extracting key-value pairs.
+*
 * @example
 * ```ts
 * Rec.keys({ a: 1, b: 2 }); // ["a", "b"]
 * ```
 */
-const keys = (data) => Object.keys(data);
+const keys = (record) => Object.keys(record);
 /**
 * Returns all values of a record.
 *
+* @see {@link keys} for extracting record keys.
+* @see {@link entries} for extracting key-value pairs.
+*
 * @example
 * ```ts
 * Rec.values({ a: 1, b: 2 }); // [1, 2]
 * ```
 */
-const values = (data) => Object.values(data);
+const values = (record) => Object.values(record);
 /**
 * Returns all key-value pairs of a record.
 *
+* @see {@link keys} for extracting record keys.
+* @see {@link values} for extracting record values.
+*
 * @example
 * ```ts
 * Rec.entries({ a: 1, b: 2 }); // [["a", 1], ["b", 2]]
 * ```
 */
-const entries = (data) => Object.entries(data);
+const entries = (record) => Object.entries(record);
 const RecFrom = { 
 /**
 * Creates a record from key-value pairs.
@@ -2277,9 +2665,9 @@ const RecFrom = {
 * Rec.from.entries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
 * ```
 */
-entries: (data) => Object.fromEntries(data) };
+entries: (pairs) => Object.fromEntries(pairs) };
 /**
-* Groups elements of an array into a record keyed by the result of `keyFn`. Each key maps to
+* Groups elements of an array into a record keyed by the result of `keySelector`. Each key maps to
 * the array of elements that produced it, in insertion order.
 *
 * Unlike `Dict.groupBy`, keys are always strings. Use `Dict.groupBy` when you need non-string
@@ -2293,10 +2681,10 @@ entries: (data) => Object.fromEntries(data) };
 * ); // { a: ["apple", "avocado"], b: ["banana", "blueberry"] }
 * ```
 */
-const groupBy = (keyFn) => (items) => {
+const groupBy = (keySelector) => (items) => {
 	const result = {};
 	for (const item of items) {
-		const key = keyFn(item);
+		const key = keySelector(item);
 		if (Object.hasOwn(result, key)) result[key].push(item);
 		else _setKey(result, key, [item]);
 	}
@@ -2305,40 +2693,46 @@ const groupBy = (keyFn) => (items) => {
 /**
 * Picks specific keys from a record.
 *
+* @see {@link omit} for removing specific keys from a record.
+*
 * @example
 * ```ts
 * pipe({ a: 1, b: 2, c: 3 }, Rec.pick("a", "c")); // { a: 1, c: 3 }
 * ```
 */
-const pick = (...pickedKeys) => (data) => {
+const pick = (...pickedKeys) => (record) => {
 	const result = {};
-	for (const key of pickedKeys) if (Object.hasOwn(data, key)) _setKey(result, key, data[key]);
+	for (const key of pickedKeys) if (Object.hasOwn(record, key)) _setKey(result, key, record[key]);
 	return result;
 };
 /**
 * Omits specific keys from a record.
 *
+* @see {@link pick} for retaining only specific keys from a record.
+*
 * @example
 * ```ts
 * pipe({ a: 1, b: 2, c: 3 }, Rec.omit("b")); // { a: 1, c: 3 }
 * ```
 */
-const omit = (...omittedKeys) => (data) => {
+const omit = (...omittedKeys) => (record) => {
 	const omitSet = new Set(omittedKeys);
 	const result = {};
-	for (const key of Object.keys(data)) if (!omitSet.has(key)) _setKey(result, key, data[key]);
+	for (const key of Object.keys(record)) if (!omitSet.has(key)) _setKey(result, key, record[key]);
 	return result;
 };
 /**
 * Merges two records. Values from the second record take precedence.
 *
+* @see {@link mergeWith} for merging records with custom collision resolution.
+*
 * @example
 * ```ts
 * pipe({ a: 1, b: 2 }, Rec.merge({ b: 3, c: 4 })); // { a: 1, b: 3, c: 4 }
 * ```
 */
-const merge = (other) => (data) => ({
-	...data,
+const merge = (other) => (record) => ({
+	...record,
 	...other
 });
 function mergeWith(combine) {
@@ -2368,24 +2762,27 @@ function mergeWith(combine) {
 * Rec.size({ a: 1, b: 2 }); // 2
 * ```
 */
-const size$1 = (data) => Object.keys(data).length;
+const size$1 = (record) => Object.keys(record).length;
 /**
 * Transforms each key while preserving values.
 * If two keys map to the same new key, the last one wins.
 *
+* @see {@link map} for transforming values.
+* @see {@link mapEntries} for transforming keys and values simultaneously.
+*
 * @example
 * ```ts
 * pipe({ firstName: "Alice", lastName: "Smith" }, Rec.mapKeys(k => k.toUpperCase()));
 * // { FIRSTNAME: "Alice", LASTNAME: "Smith" }
 * ```
 */
-const mapKeys = (f) => (data) => {
-	const recKeys = Object.keys(data);
-	if (recKeys.length === 0) return data;
+const mapKeys = (transform) => (record) => {
+	const recKeys = Object.keys(record);
+	if (recKeys.length === 0) return record;
 	const result = {};
 	for (let i = 0; i < recKeys.length; i++) {
 		const k = recKeys[i];
-		_setKey(result, f(k), data[k]);
+		_setKey(result, transform(k), record[k]);
 	}
 	return result;
 };
@@ -2399,13 +2796,13 @@ const mapKeys = (f) => (data) => {
 * // { a: 1, c: 3 }
 * ```
 */
-const compact = (data) => {
-	const recKeys = Object.keys(data);
+const compact = (record) => {
+	const recKeys = Object.keys(record);
 	if (recKeys.length === 0) return {};
 	const result = {};
 	for (let i = 0; i < recKeys.length; i++) {
 		const k = recKeys[i];
-		const v = data[k];
+		const v = record[k];
 		if (v.kind === "Some") _setKey(result, k, v.value);
 	}
 	return result;
@@ -2413,6 +2810,9 @@ const compact = (data) => {
 /**
 * Transforms key and value pairs simultaneously.
 *
+* @see {@link map} for transforming values.
+* @see {@link mapKeys} for transforming keys.
+*
 * @example
 * ```ts
 * pipe(
@@ -2421,13 +2821,13 @@ const compact = (data) => {
 * ); // { A: 10, B: 20 }
 * ```
 */
-const mapEntries = (f) => (data) => {
-	const recKeys = Object.keys(data);
+const mapEntries = (transform) => (record) => {
+	const recKeys = Object.keys(record);
 	if (recKeys.length === 0) return {};
 	const result = {};
 	for (let i = 0; i < recKeys.length; i++) {
 		const k = recKeys[i];
-		const [newKey, newVal] = f(k, data[k]);
+		const [newKey, newVal] = transform(k, record[k]);
 		_setKey(result, newKey, newVal);
 	}
 	return result;
@@ -2443,12 +2843,12 @@ const mapEntries = (f) => (data) => {
 * ); // { user: { profile: { age: 31 } } }
 * ```
 */
-const updateIn = (path, f) => (data) => {
+const updateIn = (path, transform) => (record) => {
 	const updateNode = (obj, pathKeys) => {
 		const [head, ...tail] = pathKeys;
 		if (tail.length === 0) return {
 			...obj,
-			[head]: f(obj?.[head])
+			[head]: transform(obj?.[head])
 		};
 		const child = obj && typeof obj === "object" && head in obj ? obj[head] : {};
 		return {
@@ -2456,12 +2856,12 @@ const updateIn = (path, f) => (data) => {
 			[head]: updateNode(child, tail)
 		};
 	};
-	return updateNode(data, path);
+	return updateNode(record, path);
 };
 const Rec = {
 	is: RecIs,
 	from: RecFrom,
-	to: { Dict: (data) => new globalThis.Map(Object.entries(data)) },
+	to: { Dict: (record) => new globalThis.Map(Object.entries(record)) },
 	map: map$1,
 	filterMap: filterMap$1,
 	mapWithKey,
@@ -2491,13 +2891,13 @@ const Rec = {
 	},
 	NonEmpty: {
 		singleton: (key, value) => ({ [key]: value }),
-		from: { Record: (data) => _isNonEmpty(data) ? Maybe.make.some(data) : Maybe.make.none() },
-		keys: (data) => keys(data),
-		values: (data) => values(data),
-		entries: (data) => entries(data),
-		reduce: (f) => (data) => values(data).reduce(f),
-		map: (f) => (data) => map$1(f)(data),
-		mapWithKey: (f) => (data) => mapWithKey(f)(data)
+		from: { record: (record) => _isNonEmpty(record) ? Maybe.make.some(record) : Maybe.make.none() },
+		keys: (record) => keys(record),
+		values: (record) => values(record),
+		entries: (record) => entries(record),
+		reduce: (reducer) => (record) => values(record).reduce(reducer),
+		map: (transform) => (record) => map$1(transform)(record),
+		mapWithKey: (transform) => (record) => mapWithKey(transform)(record)
 	}
 };
 //#endregion
@@ -2508,18 +2908,21 @@ const StrNonEmptyConst = { from: {
 *
 * @example
 * ```ts
-* Str.NonEmpty.from.String("hello"); // Some("hello")
-* Str.NonEmpty.from.String("");      // None
+* Str.NonEmpty.from.string("hello"); // Some("hello")
+* Str.NonEmpty.from.string("");      // None
 * ```
 */
-String: (s) => s.length > 0 ? Maybe.make.some(s) : Maybe.make.none() } };
-const isEmpty$1 = (s) => s.length === 0;
-const isNonEmpty$1 = (s) => s.length > 0;
+string: (text) => text.length > 0 ? Maybe.make.some(text) : Maybe.make.none() } };
+const isEmpty$1 = (text) => text.length === 0;
+const isNonEmpty$1 = (text) => text.length > 0;
+const isBlank = (text) => text.trim().length === 0;
 const Str = {
 	is: {
 		/**
 		* Returns `true` when the string is empty.
 		*
+		* @see {@link nonEmpty} for checking if a string contains at least one character.
+		*
 		* @example
 		* ```ts
 		* pipe("", Str.is.empty);   // true
@@ -2529,8 +2932,22 @@ const Str = {
 		empty: isEmpty$1,
 		/**
 		* Type guard to check if a string is non-empty.
+		*
+		* @see {@link empty} for checking if a string has zero length.
 		*/
-		nonEmpty: isNonEmpty$1
+		nonEmpty: isNonEmpty$1,
+		/**
+		* Returns `true` when the string is empty or contains only whitespace.
+		*
+		* @see {@link empty} for checking zero length without trimming whitespace.
+		*
+		* @example
+		* ```ts
+		* pipe("   ", Str.is.blank); // true
+		* pipe("hi", Str.is.blank);  // false
+		* ```
+		*/
+		blank: isBlank
 	},
 	/**
 	* Splits a string by a separator. Data-last: use in `pipe`.
@@ -2540,7 +2957,7 @@ const Str = {
 	* pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
 	* ```
 	*/
-	split: (separator) => (s) => s.split(separator),
+	split: (separator) => (text) => text.split(separator),
 	/**
 	* Removes leading and trailing whitespace from a string.
 	*
@@ -2549,7 +2966,7 @@ const Str = {
 	* pipe("  hello  ", Str.trim); // "hello"
 	* ```
 	*/
-	trim: (s) => s.trim(),
+	trim: (text) => text.trim(),
 	/**
 	* Returns `true` when the string contains the given substring.
 	*
@@ -2559,74 +2976,88 @@ const Str = {
 	* pipe("hello world", Str.includes("xyz"));   // false
 	* ```
 	*/
-	includes: (substring) => (s) => s.includes(substring),
+	includes: (substring) => (text) => text.includes(substring),
 	/**
 	* Replaces the first occurrence of a pattern in a string. Data-last: use in `pipe`.
 	*
+	* @see {@link replaceAll} for substituting every occurrence instead of only the first.
+	*
 	* @example
 	* ```ts
 	* pipe("foo foo foo", Str.replace("foo", "bar")); // "bar foo foo"
 	* pipe("Hello World", Str.replace(/world/i, "Earth")); // "Hello Earth"
 	* ```
 	*/
-	replace: (pattern, replacement) => (s) => s.replace(pattern, replacement),
+	replace: (pattern, replacement) => (text) => text.replace(pattern, replacement),
 	/**
 	* Replaces all occurrences of a pattern in a string. Data-last: use in `pipe`.
 	*
+	* @see {@link replace} for substituting only the first occurrence.
+	*
 	* @example
 	* ```ts
 	* pipe("foo foo foo", Str.replaceAll("foo", "bar")); // "bar bar bar"
 	* pipe("aAbBaA", Str.replaceAll(/a/gi, "x")); // "xxBBxx"
 	* ```
 	*/
-	replaceAll: (pattern, replacement) => (s) => s.replaceAll(pattern, replacement),
+	replaceAll: (pattern, replacement) => (text) => text.replaceAll(pattern, replacement),
 	/**
 	* Returns `true` when the string starts with the given prefix.
 	*
+	* @see {@link endsWith} for checking suffix matches.
+	*
 	* @example
 	* ```ts
 	* pipe("hello world", Str.startsWith("hello")); // true
 	* pipe("hello world", Str.startsWith("world")); // false
 	* ```
 	*/
-	startsWith: (prefix) => (s) => s.startsWith(prefix),
+	startsWith: (prefix) => (text) => text.startsWith(prefix),
 	/**
 	* Returns `true` when the string ends with the given suffix.
 	*
+	* @see {@link startsWith} for checking prefix matches.
+	*
 	* @example
 	* ```ts
 	* pipe("hello world", Str.endsWith("world")); // true
 	* pipe("hello world", Str.endsWith("hello")); // false
 	* ```
 	*/
-	endsWith: (suffix) => (s) => s.endsWith(suffix),
+	endsWith: (suffix) => (text) => text.endsWith(suffix),
 	/**
 	* Converts a string to uppercase.
 	*
+	* @see {@link toLowerCase} for lowercasing characters.
+	*
 	* @example
 	* ```ts
 	* pipe("hello", Str.toUpperCase); // "HELLO"
 	* ```
 	*/
-	toUpperCase: (s) => s.toUpperCase(),
+	toUpperCase: (text) => text.toUpperCase(),
 	/**
 	* Converts a string to lowercase.
 	*
+	* @see {@link toUpperCase} for uppercasing characters.
+	*
 	* @example
 	* ```ts
 	* pipe("HELLO", Str.toLowerCase); // "hello"
 	* ```
 	*/
-	toLowerCase: (s) => s.toLowerCase(),
+	toLowerCase: (text) => text.toLowerCase(),
 	/**
 	* Converts the first character of a string to uppercase.
 	*
+	* @see {@link uncapitalize} for converting the first character to lowercase.
+	*
 	* @example
 	* ```ts
 	* pipe("hello", Str.capitalize); // "Hello"
 	* ```
 	*/
-	capitalize: (s) => s.length === 0 ? "" : s.charAt(0).toUpperCase() + s.slice(1),
+	capitalize: (text) => text.length === 0 ? "" : text.charAt(0).toUpperCase() + text.slice(1),
 	/**
 	* Splits a string into lines, normalising `\r\n` and `\r` line endings.
 	*
@@ -2636,7 +3067,7 @@ const Str = {
 	* Str.lines("a\r\nb");         // ["a", "b"]
 	* ```
 	*/
-	lines: (s) => s.split(/\r?\n|\r/),
+	lines: (text) => text.split(/\r?\n|\r/),
 	/**
 	* Splits a string into words on any whitespace boundary, filtering out empty strings.
 	*
@@ -2645,17 +3076,7 @@ const Str = {
 	* Str.words("  hello   world  "); // ["hello", "world"]
 	* ```
 	*/
-	words: (s) => s.trim().split(/\s+/).filter(Boolean),
-	/**
-	* Returns `true` when the string is empty or contains only whitespace.
-	*
-	* @example
-	* ```ts
-	* pipe("   ", Str.isBlank); // true
-	* pipe("hi", Str.isBlank);  // false
-	* ```
-	*/
-	isBlank: (s) => s.trim().length === 0,
+	words: (text) => text.trim().split(/\s+/).filter(Boolean),
 	/**
 	* Returns the length of the string.
 	*
@@ -2665,7 +3086,7 @@ const Str = {
 	* pipe("", Str.length);      // 0
 	* ```
 	*/
-	length: (s) => s.length,
+	length: (text) => text.length,
 	/**
 	* Extracts a substring between two indices. Data-last: use in `pipe`.
 	*
@@ -2675,27 +3096,31 @@ const Str = {
 	* pipe("hello", Str.slice(2));    // "llo"
 	* ```
 	*/
-	slice: (start, end) => (s) => s.slice(start, end),
+	slice: (start, end) => (text) => text.slice(start, end),
 	/**
 	* Pads the start of a string to a specified length. Data-last: use in `pipe`.
 	*
+	* @see {@link padEnd} for padding the right side of a string.
+	*
 	* @example
 	* ```ts
 	* pipe("5", Str.padStart(3, "0")); // "005"
 	* pipe("hi", Str.padStart(5));     // "   hi"
 	* ```
 	*/
-	padStart: (maxLength, fillString) => (s) => s.padStart(maxLength, fillString),
+	padStart: (maxLength, fillString) => (text) => text.padStart(maxLength, fillString),
 	/**
 	* Pads the end of a string to a specified length. Data-last: use in `pipe`.
 	*
+	* @see {@link padStart} for padding the left side of a string.
+	*
 	* @example
 	* ```ts
 	* pipe("hi", Str.padEnd(5, "."));  // "hi..."
 	* pipe("hi", Str.padEnd(5));       // "hi   "
 	* ```
 	*/
-	padEnd: (maxLength, fillString) => (s) => s.padEnd(maxLength, fillString),
+	padEnd: (maxLength, fillString) => (text) => text.padEnd(maxLength, fillString),
 	/**
 	* Safe number parsers that return `Maybe` instead of `NaN`.
 	*/
@@ -2703,6 +3128,8 @@ const Str = {
 		/**
 		* Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
 		*
+		* @see {@link float} for parsing floating-point numbers.
+		*
 		* @example
 		* ```ts
 		* Str.parse.int("42");   // Some(42)
@@ -2710,14 +3137,16 @@ const Str = {
 		* Str.parse.int("abc");  // None
 		* ```
 		*/
-		int: (s) => {
-			if (s.length === 0) return Maybe.make.none();
-			const n = Number.parseInt(s, 10);
+		int: (text) => {
+			if (text.length === 0) return Maybe.make.none();
+			const n = Number.parseInt(text, 10);
 			return Number.isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
 		},
 		/**
 		* Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
 		*
+		* @see {@link int} for parsing base-10 integers.
+		*
 		* @example
 		* ```ts
 		* Str.parse.float("3.14"); // Some(3.14)
@@ -2725,38 +3154,57 @@ const Str = {
 		* Str.parse.float("abc");  // None
 		* ```
 		*/
-		float: (s) => {
-			if (s.length === 0) return Maybe.make.none();
-			const n = Number.parseFloat(s);
+		float: (text) => {
+			if (text.length === 0) return Maybe.make.none();
+			const n = Number.parseFloat(text);
 			return Number.isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
 		}
 	},
 	/**
-	* Safely parses a JSON string, returning a `Result<SyntaxError, unknown>`.
+	* Matches a string against a regular expression.
+	* Pure and safe: resets `pattern.lastIndex = 0` to prevent bugs with stateful `/g` and `/y` regexes.
+	*
+	* @see {@link test} for boolean validation without extracting capture groups.
 	*
 	* @example
 	* ```ts
-	* Str.parseJson('{"a": 1}'); // Ok({ a: 1 })
-	* Str.parseJson('invalid');  // Err(SyntaxError)
+	* pipe("hello 42", Str.match(/\d+/)); // Some(["42"])
+	* pipe("hello", Str.match(/\d+/));    // None
 	* ```
 	*/
-	parseJson: (s) => {
-		try {
-			return Result.make.ok(JSON.parse(s));
-		} catch (error) {
-			return Result.make.err(error);
-		}
+	match: (pattern) => (text) => {
+		pattern.lastIndex = 0;
+		const result = text.match(pattern);
+		return result !== null ? Maybe.make.some(result) : Maybe.make.none();
+	},
+	/**
+	* Tests whether a string matches a regular expression.
+	* Pure and safe: resets `pattern.lastIndex = 0` to prevent bugs with stateful `/g` and `/y` regexes.
+	*
+	* @see {@link match} for extracting capture groups into a Maybe.
+	*
+	* @example
+	* ```ts
+	* pipe("user@example.com", Str.test(/^[^@]+@[^@]+$/)); // true
+	* pipe("invalid-email", Str.test(/^[^@]+@[^@]+$/));    // false
+	* ```
+	*/
+	test: (pattern) => (text) => {
+		pattern.lastIndex = 0;
+		return pattern.test(text);
 	},
 	/**
 	* Converts the first character of a string to lower case.
 	*
+	* @see {@link capitalize} for converting the first character to uppercase.
+	*
 	* @example
 	* ```ts
-	* Str.uncapitalize("Hello"); // "hello"
-	* Str.uncapitalize("");      // ""
+	* pipe("Hello", Str.uncapitalize); // "hello"
+	* pipe("", Str.uncapitalize);      // ""
 	* ```
 	*/
-	uncapitalize: (s) => s.length === 0 ? "" : s.charAt(0).toLowerCase() + s.slice(1),
+	uncapitalize: (text) => text.length === 0 ? "" : text.charAt(0).toLowerCase() + text.slice(1),
 	/**
 	* Truncates a string to a maximum length, appending an optional suffix (default `"..."`).
 	* Data-last curried signature.
@@ -2768,100 +3216,158 @@ const Str = {
 	* pipe("Hello, world!", Str.truncate({ length: 8, suffix: "…" })); // "Hello, w…"
 	* ```
 	*/
-	truncate: (options) => (s) => {
+	truncate: (options) => (text) => {
 		const { length: targetLength, suffix = "..." } = options;
-		if (s.length <= targetLength) return s;
+		if (text.length <= targetLength) return text;
 		if (targetLength <= suffix.length) return suffix.slice(0, targetLength);
-		return s.slice(0, targetLength - suffix.length) + suffix;
+		return text.slice(0, targetLength - suffix.length) + suffix;
 	},
 	NonEmpty: StrNonEmptyConst
 };
 //#endregion
 //#region src/Data/Uniq.ts
-const isEmpty = (s) => s.size === 0;
-const isNonEmpty = (s) => s.size > 0;
+const isEmpty = (set) => set.size === 0;
+const isNonEmpty = (set) => set.size > 0;
 const empty = () => new globalThis.Set();
 const singleton = (item) => new globalThis.Set([item]);
-const fromArray = (arr) => new globalThis.Set(arr);
-const has = (item) => (s) => s.has(item);
-const size = (s) => s.size;
-const add = (item) => (s) => {
-	if (s.has(item)) return s;
-	const result = new globalThis.Set(s);
+const fromArray = (items) => new globalThis.Set(items);
+/**
+* Returns `true` when the set contains the given element.
+*
+* @see {@link add} for inserting an element into a set.
+* @see {@link remove} for deleting an element from a set.
+*/
+const has = (item) => (set) => set.has(item);
+const size = (set) => set.size;
+/**
+* Returns a new set with the element added.
+*
+* @see {@link remove} for deleting an element from a set.
+* @see {@link toggle} for toggling presence of an element.
+*/
+const add = (item) => (set) => {
+	if (set.has(item)) return set;
+	const result = new globalThis.Set(set);
 	result.add(item);
 	return result;
 };
-const remove = (item) => (s) => {
-	if (!s.has(item)) return s;
-	const result = new globalThis.Set(s);
+/**
+* Returns a new set with the element removed.
+*
+* @see {@link add} for adding an element to a set.
+*/
+const remove = (item) => (set) => {
+	if (!set.has(item)) return set;
+	const result = new globalThis.Set(set);
 	result.delete(item);
 	return result;
 };
-const toggle = (item) => (s) => {
-	const result = new globalThis.Set(s);
+/**
+* Toggles presence of an element in a set.
+*
+* @see {@link add} for unconditionally adding an element.
+* @see {@link remove} for unconditionally removing an element.
+*/
+const toggle = (item) => (set) => {
+	const result = new globalThis.Set(set);
 	if (result.has(item)) result.delete(item);
 	else result.add(item);
 	return result;
 };
-const map = (f) => (s) => {
+/**
+* Transforms each element of a set into a new set.
+*
+* @see {@link filterMap} for mapping and filtering in a single step.
+*/
+const map = (transform) => (set) => {
 	const result = new globalThis.Set();
-	for (const item of s) result.add(f(item));
+	for (const item of set) result.add(transform(item));
 	return result;
 };
-const filter = (predicate) => (s) => {
+/**
+* Filters elements of a set by a predicate.
+*
+* @see {@link filterMap} for filtering and mapping simultaneously.
+*/
+const filter = (predicate) => (set) => {
 	const result = new globalThis.Set();
-	for (const item of s) if (predicate(item)) result.add(item);
+	for (const item of set) if (predicate(item)) result.add(item);
 	return result;
 };
-const filterMap = (f) => (s) => {
+/**
+* Transforms elements with a function returning `Maybe`, keeping only `Some` values.
+*
+* @see {@link filter} for filtering with a boolean predicate.
+* @see {@link map} for transforming without filtering.
+*/
+const filterMap = (transform) => (set) => {
 	const result = new globalThis.Set();
-	for (const item of s) {
-		const mb = f(item);
+	for (const item of set) {
+		const mb = transform(item);
 		if (mb.kind === "Some") result.add(mb.value);
 	}
 	return result;
 };
-const union = (other) => (s) => {
-	const set = s;
-	if (typeof set.union === "function") return set.union(other);
-	const result = new globalThis.Set(s);
+/**
+* Computes the union of two sets.
+*
+* @see {@link intersection} for keeping only elements present in both sets.
+* @see {@link difference} for subtracting elements.
+*/
+const union = (other) => (set) => {
+	const s = set;
+	if (typeof s.union === "function") return s.union(other);
+	const result = new globalThis.Set(set);
 	for (const item of other) result.add(item);
 	return result;
 };
-const intersection = (other) => (s) => {
-	const set = s;
-	if (typeof set.intersection === "function") return set.intersection(other);
+/**
+* Computes the intersection of two sets.
+*
+* @see {@link union} for combining elements from both sets.
+* @see {@link difference} for subtracting elements.
+*/
+const intersection = (other) => (set) => {
+	const s = set;
+	if (typeof s.intersection === "function") return s.intersection(other);
 	const result = new globalThis.Set();
-	for (const item of s) if (other.has(item)) result.add(item);
+	for (const item of set) if (other.has(item)) result.add(item);
 	return result;
 };
-const difference = (other) => (s) => {
-	const set = s;
-	if (typeof set.difference === "function") return set.difference(other);
+/**
+* Computes the set difference (`set \ other`).
+*
+* @see {@link union} for combining all elements.
+* @see {@link intersection} for keeping only common elements.
+*/
+const difference = (other) => (set) => {
+	const s = set;
+	if (typeof s.difference === "function") return s.difference(other);
 	const result = new globalThis.Set();
-	for (const item of s) if (!other.has(item)) result.add(item);
+	for (const item of set) if (!other.has(item)) result.add(item);
 	return result;
 };
-const isSubsetOf = (other) => (s) => {
-	const set = s;
-	if (typeof set.isSubsetOf === "function") return set.isSubsetOf(other);
-	for (const item of s) if (!other.has(item)) return false;
+const isSubsetOf = (other) => (set) => {
+	const s = set;
+	if (typeof s.isSubsetOf === "function") return s.isSubsetOf(other);
+	for (const item of set) if (!other.has(item)) return false;
 	return true;
 };
-const reduce = (init, f) => (s) => {
-	let acc = init;
-	for (const item of s) acc = f(acc, item);
+const reduce = (initial, reducer) => (set) => {
+	let acc = initial;
+	for (const item of set) acc = reducer(acc, item);
 	return acc;
 };
-const toArray = (s) => [...s];
+const toArray = (set) => [...set];
 const Uniq = {
 	is: {
 		empty: isEmpty,
-		nonEmpty: isNonEmpty
+		nonEmpty: isNonEmpty,
+		subsetOf: isSubsetOf
 	},
 	empty,
 	singleton,
-	from: { Array: fromArray },
+	from: { array: fromArray },
 	has,
 	size,
 	add,
@@ -2874,15 +3380,14 @@ const Uniq = {
 	union,
 	intersection,
 	difference,
-	isSubsetOf,
 	reduce,
-	to: { Array: toArray },
+	to: { array: toArray },
 	NonEmpty: {
 		singleton: (item) => new globalThis.Set([item]),
-		from: { Set: (s) => s.size > 0 ? Maybe.make.some(s) : Maybe.make.none() },
-		reduce: (f) => (s) => toArray(s).reduce(f),
-		map: (f) => (s) => map(f)(s),
-		to: { Array: (s) => toArray(s) }
+		from: { set: (set) => set.size > 0 ? Maybe.make.some(set) : Maybe.make.none() },
+		reduce: (reducer) => (set) => toArray(set).reduce(reducer),
+		map: (transform) => (set) => map(transform)(set),
+		to: { array: (set) => toArray(set) }
 	}
 };
 //#endregion