es-toolkit 1.48.1 → 1.49.0

package/dist/fp/array/initial.mjs

@@ -0,0 +1,24 @@
+import { initial as initial$1 } from "../../array/initial.mjs";
+//#region src/fp/array/initial.ts
+/**
+* Creates a function that returns every element except the last one.
+*
+* The returned function follows the main {@link initial} behavior and always returns a new array.
+* Use it with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @returns A function that maps a readonly array to its initial elements.
+*
+* @example
+* import { initial, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], initial());
+* // => [1, 2]
+*/
+function initial() {
+	return function(array) {
+		return initial$1(array);
+	};
+}
+//#endregion
+export { initial };

package/dist/fp/array/intersection.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/intersection.d.ts
+/**
+ * Creates a function that keeps values from the piped array that are also present in another array.
+ *
+ * Equality follows SameValueZero through Set membership, matching the main
+ * {@link intersection} implementation. The returned function is lazy-capable
+ * inside {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to intersect with the piped array.
+ * @returns A function that maps the piped array to its intersection.
+ *
+ * @example
+ * import { intersection, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], intersection([2, 4]));
+ * // => [2]
+ */
+declare function intersection<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { intersection };

package/dist/fp/array/intersection.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/intersection.d.ts
+/**
+ * Creates a function that keeps values from the piped array that are also present in another array.
+ *
+ * Equality follows SameValueZero through Set membership, matching the main
+ * {@link intersection} implementation. The returned function is lazy-capable
+ * inside {@link pipe}.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param secondArray - Values to intersect with the piped array.
+ * @returns A function that maps the piped array to its intersection.
+ *
+ * @example
+ * import { intersection, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2, 3], intersection([2, 4]));
+ * // => [2]
+ */
+declare function intersection<T>(secondArray: readonly T[]): (array: readonly T[]) => T[];
+//#endregion
+export { intersection };

package/dist/fp/array/intersection.js

@@ -0,0 +1,32 @@
+const require_intersection = require("../../array/intersection.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/intersection.ts
+/**
+* Creates a function that keeps values from the piped array that are also present in another array.
+*
+* Equality follows SameValueZero through Set membership, matching the main
+* {@link intersection} implementation. The returned function is lazy-capable
+* inside {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to intersect with the piped array.
+* @returns A function that maps the piped array to its intersection.
+*
+* @example
+* import { intersection, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], intersection([2, 4]));
+* // => [2]
+*/
+function intersection(secondArray) {
+	const secondSet = new Set(secondArray);
+	function intersectionEager(array) {
+		return require_intersection.intersection(array, secondArray);
+	}
+	const intersectionLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (secondSet.has(value)) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(intersectionEager, intersectionLazy);
+}
+//#endregion
+exports.intersection = intersection;

package/dist/fp/array/intersection.mjs

@@ -0,0 +1,31 @@
+import { intersection as intersection$1 } from "../../array/intersection.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/intersection.ts
+/**
+* Creates a function that keeps values from the piped array that are also present in another array.
+*
+* Equality follows SameValueZero through Set membership, matching the main
+* {@link intersection} implementation. The returned function is lazy-capable
+* inside {@link pipe}.
+*
+* @template T - The type of elements in the arrays.
+* @param secondArray - Values to intersect with the piped array.
+* @returns A function that maps the piped array to its intersection.
+*
+* @example
+* import { intersection, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2, 3], intersection([2, 4]));
+* // => [2]
+*/
+function intersection(secondArray) {
+	const secondSet = new Set(secondArray);
+	function intersectionEager(array) {
+		return intersection$1(array, secondArray);
+	}
+	return combineEagerAndLazyFunctions(intersectionEager, createLazyFunction((value, _index, emit) => {
+		if (secondSet.has(value)) emit(value);
+	}));
+}
+//#endregion
+export { intersection };

package/dist/fp/array/intersectionBy.d.mts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionBy.d.ts
+/**
+ * Creates a function that keeps values whose mapped identity appears in another array.
+ *
+ * The mapper is applied to values from both arrays. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to intersect with the piped array after mapping.
+ * @param mapper - Maps values from both arrays to comparison keys.
+ * @returns A function that maps the piped array to its mapped intersection.
+ *
+ * @example
+ * import { intersectionBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionBy<T, U>(secondArray: readonly U[], mapper: (value: T | U) => unknown): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionBy };

package/dist/fp/array/intersectionBy.d.ts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionBy.d.ts
+/**
+ * Creates a function that keeps values whose mapped identity appears in another array.
+ *
+ * The mapper is applied to values from both arrays. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to intersect with the piped array after mapping.
+ * @param mapper - Maps values from both arrays to comparison keys.
+ * @returns A function that maps the piped array to its mapped intersection.
+ *
+ * @example
+ * import { intersectionBy, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionBy<T, U>(secondArray: readonly U[], mapper: (value: T | U) => unknown): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionBy };

package/dist/fp/array/intersectionBy.js

@@ -0,0 +1,33 @@
+const require_intersectionBy = require("../../array/intersectionBy.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/intersectionBy.ts
+/**
+* Creates a function that keeps values whose mapped identity appears in another array.
+*
+* The mapper is applied to values from both arrays. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to intersect with the piped array after mapping.
+* @param mapper - Maps values from both arrays to comparison keys.
+* @returns A function that maps the piped array to its mapped intersection.
+*
+* @example
+* import { intersectionBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+* // => [{ id: 2 }]
+*/
+function intersectionBy(secondArray, mapper) {
+	const mappedSecondSet = new Set(secondArray.map((item) => mapper(item)));
+	function intersectionByEager(array) {
+		return require_intersectionBy.intersectionBy(array, secondArray, mapper);
+	}
+	const intersectionByLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (mappedSecondSet.has(mapper(value))) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(intersectionByEager, intersectionByLazy);
+}
+//#endregion
+exports.intersectionBy = intersectionBy;

package/dist/fp/array/intersectionBy.mjs

@@ -0,0 +1,32 @@
+import { intersectionBy as intersectionBy$1 } from "../../array/intersectionBy.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/intersectionBy.ts
+/**
+* Creates a function that keeps values whose mapped identity appears in another array.
+*
+* The mapper is applied to values from both arrays. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to intersect with the piped array after mapping.
+* @param mapper - Maps values from both arrays to comparison keys.
+* @returns A function that maps the piped array to its mapped intersection.
+*
+* @example
+* import { intersectionBy, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionBy([2], value => typeof value === 'number' ? value : value.id));
+* // => [{ id: 2 }]
+*/
+function intersectionBy(secondArray, mapper) {
+	const mappedSecondSet = new Set(secondArray.map((item) => mapper(item)));
+	function intersectionByEager(array) {
+		return intersectionBy$1(array, secondArray, mapper);
+	}
+	return combineEagerAndLazyFunctions(intersectionByEager, createLazyFunction((value, _index, emit) => {
+		if (mappedSecondSet.has(mapper(value))) emit(value);
+	}));
+}
+//#endregion
+export { intersectionBy };

package/dist/fp/array/intersectionWith.d.mts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionWith.d.ts
+/**
+ * Creates a function that keeps values equal to at least one configured value.
+ *
+ * Equality is decided by the provided comparator. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to compare against the piped array.
+ * @param areItemsEqual - Returns true when a piped value equals a configured value.
+ * @returns A function that maps the piped array to its custom intersection.
+ *
+ * @example
+ * import { intersectionWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionWith<T, U>(secondArray: readonly U[], areItemsEqual: (item: T, other: U) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionWith };

package/dist/fp/array/intersectionWith.d.ts

@@ -0,0 +1,22 @@
+//#region src/fp/array/intersectionWith.d.ts
+/**
+ * Creates a function that keeps values equal to at least one configured value.
+ *
+ * Equality is decided by the provided comparator. The returned function is
+ * lazy-capable inside {@link pipe}.
+ *
+ * @template T - The type of elements in the piped array.
+ * @template U - The type of elements in the configured array.
+ * @param secondArray - Values to compare against the piped array.
+ * @param areItemsEqual - Returns true when a piped value equals a configured value.
+ * @returns A function that maps the piped array to its custom intersection.
+ *
+ * @example
+ * import { intersectionWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+ * // => [{ id: 2 }]
+ */
+declare function intersectionWith<T, U>(secondArray: readonly U[], areItemsEqual: (item: T, other: U) => boolean): (array: readonly T[]) => T[];
+//#endregion
+export { intersectionWith };

package/dist/fp/array/intersectionWith.js

@@ -0,0 +1,32 @@
+const require_intersectionWith = require("../../array/intersectionWith.js");
+const require_lazy = require("../_internal/lazy.js");
+//#region src/fp/array/intersectionWith.ts
+/**
+* Creates a function that keeps values equal to at least one configured value.
+*
+* Equality is decided by the provided comparator. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to compare against the piped array.
+* @param areItemsEqual - Returns true when a piped value equals a configured value.
+* @returns A function that maps the piped array to its custom intersection.
+*
+* @example
+* import { intersectionWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+* // => [{ id: 2 }]
+*/
+function intersectionWith(secondArray, areItemsEqual) {
+	function intersectionWithEager(array) {
+		return require_intersectionWith.intersectionWith(array, secondArray, areItemsEqual);
+	}
+	const intersectionWithLazy = require_lazy.createLazyFunction((value, _index, emit) => {
+		if (secondArray.some((other) => areItemsEqual(value, other))) emit(value);
+	});
+	return require_lazy.combineEagerAndLazyFunctions(intersectionWithEager, intersectionWithLazy);
+}
+//#endregion
+exports.intersectionWith = intersectionWith;

package/dist/fp/array/intersectionWith.mjs

@@ -0,0 +1,31 @@
+import { intersectionWith as intersectionWith$1 } from "../../array/intersectionWith.mjs";
+import { combineEagerAndLazyFunctions, createLazyFunction } from "../_internal/lazy.mjs";
+//#region src/fp/array/intersectionWith.ts
+/**
+* Creates a function that keeps values equal to at least one configured value.
+*
+* Equality is decided by the provided comparator. The returned function is
+* lazy-capable inside {@link pipe}.
+*
+* @template T - The type of elements in the piped array.
+* @template U - The type of elements in the configured array.
+* @param secondArray - Values to compare against the piped array.
+* @param areItemsEqual - Returns true when a piped value equals a configured value.
+* @returns A function that maps the piped array to its custom intersection.
+*
+* @example
+* import { intersectionWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }, { id: 2 }], intersectionWith([2], (item, id) => item.id === id));
+* // => [{ id: 2 }]
+*/
+function intersectionWith(secondArray, areItemsEqual) {
+	function intersectionWithEager(array) {
+		return intersectionWith$1(array, secondArray, areItemsEqual);
+	}
+	return combineEagerAndLazyFunctions(intersectionWithEager, createLazyFunction((value, _index, emit) => {
+		if (secondArray.some((other) => areItemsEqual(value, other))) emit(value);
+	}));
+}
+//#endregion
+export { intersectionWith };

package/dist/fp/array/isSubset.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/array/isSubset.d.ts
+/**
+ * Creates a predicate that checks whether the piped array is a subset of superset.
+ *
+ * Every value in the piped array must be present in superset, using the main
+ * {@link isSubset} equality behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubset, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], isSubset([1, 2, 3]));
+ * // => true
+ */
+declare function isSubset<T>(superset: readonly T[]): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubset };

package/dist/fp/array/isSubset.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/array/isSubset.d.ts
+/**
+ * Creates a predicate that checks whether the piped array is a subset of superset.
+ *
+ * Every value in the piped array must be present in superset, using the main
+ * {@link isSubset} equality behavior.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubset, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([1, 2], isSubset([1, 2, 3]));
+ * // => true
+ */
+declare function isSubset<T>(superset: readonly T[]): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubset };

package/dist/fp/array/isSubset.js

@@ -0,0 +1,25 @@
+const require_isSubset = require("../../array/isSubset.js");
+//#region src/fp/array/isSubset.ts
+/**
+* Creates a predicate that checks whether the piped array is a subset of superset.
+*
+* Every value in the piped array must be present in superset, using the main
+* {@link isSubset} equality behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubset, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2], isSubset([1, 2, 3]));
+* // => true
+*/
+function isSubset(superset) {
+	return function(array) {
+		return require_isSubset.isSubset(superset, array);
+	};
+}
+//#endregion
+exports.isSubset = isSubset;

package/dist/fp/array/isSubset.mjs

@@ -0,0 +1,25 @@
+import { isSubset as isSubset$1 } from "../../array/isSubset.mjs";
+//#region src/fp/array/isSubset.ts
+/**
+* Creates a predicate that checks whether the piped array is a subset of superset.
+*
+* Every value in the piped array must be present in superset, using the main
+* {@link isSubset} equality behavior.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubset, pipe } from 'es-toolkit/fp';
+*
+* pipe([1, 2], isSubset([1, 2, 3]));
+* // => true
+*/
+function isSubset(superset) {
+	return function(array) {
+		return isSubset$1(superset, array);
+	};
+}
+//#endregion
+export { isSubset };

package/dist/fp/array/isSubsetWith.d.mts

@@ -0,0 +1,21 @@
+//#region src/fp/array/isSubsetWith.d.ts
+/**
+ * Creates a predicate that checks subset membership with a custom equality function.
+ *
+ * Every value in the piped array must match at least one value in superset according
+ * to areItemsEqual.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubsetWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+ * // => true
+ */
+declare function isSubsetWith<T>(superset: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubsetWith };

package/dist/fp/array/isSubsetWith.d.ts

@@ -0,0 +1,21 @@
+//#region src/fp/array/isSubsetWith.d.ts
+/**
+ * Creates a predicate that checks subset membership with a custom equality function.
+ *
+ * Every value in the piped array must match at least one value in superset according
+ * to areItemsEqual.
+ *
+ * @template T - The type of elements in the arrays.
+ * @param superset - The array that may contain all values from the piped array.
+ * @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+ * @returns A predicate for the piped array.
+ *
+ * @example
+ * import { isSubsetWith, pipe } from 'es-toolkit/fp';
+ *
+ * pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+ * // => true
+ */
+declare function isSubsetWith<T>(superset: readonly T[], areItemsEqual: (item: T, other: T) => boolean): (array: readonly T[]) => boolean;
+//#endregion
+export { isSubsetWith };

package/dist/fp/array/isSubsetWith.js

@@ -0,0 +1,26 @@
+const require_isSubsetWith = require("../../array/isSubsetWith.js");
+//#region src/fp/array/isSubsetWith.ts
+/**
+* Creates a predicate that checks subset membership with a custom equality function.
+*
+* Every value in the piped array must match at least one value in superset according
+* to areItemsEqual.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubsetWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+* // => true
+*/
+function isSubsetWith(superset, areItemsEqual) {
+	return function(array) {
+		return require_isSubsetWith.isSubsetWith(superset, array, areItemsEqual);
+	};
+}
+//#endregion
+exports.isSubsetWith = isSubsetWith;

package/dist/fp/array/isSubsetWith.mjs

@@ -0,0 +1,26 @@
+import { isSubsetWith as isSubsetWith$1 } from "../../array/isSubsetWith.mjs";
+//#region src/fp/array/isSubsetWith.ts
+/**
+* Creates a predicate that checks subset membership with a custom equality function.
+*
+* Every value in the piped array must match at least one value in superset according
+* to areItemsEqual.
+*
+* @template T - The type of elements in the arrays.
+* @param superset - The array that may contain all values from the piped array.
+* @param areItemsEqual - Returns true when a piped value and a superset value are equal.
+* @returns A predicate for the piped array.
+*
+* @example
+* import { isSubsetWith, pipe } from 'es-toolkit/fp';
+*
+* pipe([{ id: 1 }], isSubsetWith([{ id: 1 }, { id: 2 }], (a, b) => a.id === b.id));
+* // => true
+*/
+function isSubsetWith(superset, areItemsEqual) {
+	return function(array) {
+		return isSubsetWith$1(superset, array, areItemsEqual);
+	};
+}
+//#endregion
+export { isSubsetWith };

package/dist/fp/array/join.d.mts

@@ -0,0 +1,20 @@
+//#region src/fp/array/join.d.ts
+/**
+ * Creates a function that joins array values into a string.
+ *
+ * The separator is passed to Array.prototype.join, so undefined uses a comma.
+ * Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param separator - The separator placed between values.
+ * @returns A function that maps a readonly array to a joined string.
+ *
+ * @example
+ * import { join, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], join('-'));
+ * // => 'a-b-c'
+ */
+declare function join<T>(separator?: string): (array: readonly T[]) => string;
+//#endregion
+export { join };

package/dist/fp/array/join.d.ts

@@ -0,0 +1,20 @@
+//#region src/fp/array/join.d.ts
+/**
+ * Creates a function that joins array values into a string.
+ *
+ * The separator is passed to Array.prototype.join, so undefined uses a comma.
+ * Use the returned function with {@link pipe}.
+ *
+ * @template T - The type of elements in the array.
+ * @param separator - The separator placed between values.
+ * @returns A function that maps a readonly array to a joined string.
+ *
+ * @example
+ * import { join, pipe } from 'es-toolkit/fp';
+ *
+ * pipe(['a', 'b', 'c'], join('-'));
+ * // => 'a-b-c'
+ */
+declare function join<T>(separator?: string): (array: readonly T[]) => string;
+//#endregion
+export { join };

package/dist/fp/array/join.js

@@ -0,0 +1,24 @@
+//#region src/fp/array/join.ts
+/**
+* Creates a function that joins array values into a string.
+*
+* The separator is passed to Array.prototype.join, so undefined uses a comma.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param separator - The separator placed between values.
+* @returns A function that maps a readonly array to a joined string.
+*
+* @example
+* import { join, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], join('-'));
+* // => 'a-b-c'
+*/
+function join(separator) {
+	return function(array) {
+		return array.join(separator);
+	};
+}
+//#endregion
+exports.join = join;

package/dist/fp/array/join.mjs

@@ -0,0 +1,24 @@
+//#region src/fp/array/join.ts
+/**
+* Creates a function that joins array values into a string.
+*
+* The separator is passed to Array.prototype.join, so undefined uses a comma.
+* Use the returned function with {@link pipe}.
+*
+* @template T - The type of elements in the array.
+* @param separator - The separator placed between values.
+* @returns A function that maps a readonly array to a joined string.
+*
+* @example
+* import { join, pipe } from 'es-toolkit/fp';
+*
+* pipe(['a', 'b', 'c'], join('-'));
+* // => 'a-b-c'
+*/
+function join(separator) {
+	return function(array) {
+		return array.join(separator);
+	};
+}
+//#endregion
+export { join };