fp-pack 0.1.0

package/dist/stream/zipWith.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipWith.d.ts","sourceRoot":"","sources":["../../src/stream/zipWith.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAIlE,6DAA6D;AAC7D,iBAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAC;AACrH,iBAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACtB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAClC,KAAK,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAC3C,CAAC,QAAQ,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,KAAK,qBAAqB,CAAC,CAAC,CAAC,CAAC;AACjF,iBAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;AACjH,iBAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACtB,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAClC,KAAK,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAC5C,QAAQ,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAC9C,qBAAqB,CAAC,CAAC,CAAC,CAAC;AA8C5B,eAAe,OAAO,CAAC"}

package/dist/stream/zipWith.mjs

@@ -0,0 +1,31 @@
+import { isAsyncInput as c, isIterable as a } from "./utils.mjs";
+import f from "./toAsync.mjs";
+function y(i, t, e) {
+  if (e === void 0)
+    return (n) => y(i, t, n);
+  if (c(t) || c(e))
+    return (async function* () {
+      const n = f(e), s = f(t), r = n[Symbol.asyncIterator](), o = s[Symbol.asyncIterator]();
+      for (; ; ) {
+        const [l, u] = await Promise.all([r.next(), o.next()]);
+        if (l.done || u.done)
+          return;
+        yield await i(l.value, u.value);
+      }
+    })();
+  if (a(e) && a(t))
+    return (function* () {
+      const n = e[Symbol.iterator](), s = t[Symbol.iterator]();
+      for (; ; ) {
+        const r = n.next(), o = s.next();
+        if (r.done || o.done)
+          return;
+        yield i(r.value, o.value);
+      }
+    })();
+  throw new TypeError("zipWith: input is not iterable");
+}
+export {
+  y as default
+};
+//# sourceMappingURL=zipWith.mjs.map

package/dist/stream/zipWith.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipWith.mjs","sources":["../../src/stream/zipWith.ts"],"sourcesContent":["import type { AnyIterableInput, PromiseLikeValue } from './utils';\nimport { isAsyncInput, isIterable } from './utils';\nimport toAsync from './toAsync';\n\n/** zipWith - lazily combine two iterables with a function */\nfunction zipWith<A, B, R>(fn: (a: A, b: B) => R, other: Iterable<B>): (iterable: Iterable<A>) => IterableIterator<R>;\nfunction zipWith<A, B, R>(\n  fn: (a: A, b: B) => R | Promise<R>,\n  other: AnyIterableInput<PromiseLikeValue<B>>\n): (iterable: AnyIterableInput<PromiseLikeValue<A>>) => AsyncIterableIterator<R>;\nfunction zipWith<A, B, R>(fn: (a: A, b: B) => R, other: Iterable<B>, iterable: Iterable<A>): IterableIterator<R>;\nfunction zipWith<A, B, R>(\n  fn: (a: A, b: B) => R | Promise<R>,\n  other: AnyIterableInput<PromiseLikeValue<B>>,\n  iterable: AnyIterableInput<PromiseLikeValue<A>>\n): AsyncIterableIterator<R>;\nfunction zipWith<A, B, R>(\n  fn: (a: A, b: B) => R | Promise<R>,\n  other: AnyIterableInput<PromiseLikeValue<B>>,\n  iterable?: AnyIterableInput<PromiseLikeValue<A>>\n): any {\n  if (iterable === undefined) {\n    return (next: AnyIterableInput<PromiseLikeValue<A>>) => zipWith(fn, other, next);\n  }\n\n  if (isAsyncInput(other) || isAsyncInput(iterable)) {\n    return (async function* () {\n      const left = toAsync(iterable);\n      const right = toAsync(other);\n      const leftIter = left[Symbol.asyncIterator]();\n      const rightIter = right[Symbol.asyncIterator]();\n\n      while (true) {\n        const [leftResult, rightResult] = await Promise.all([leftIter.next(), rightIter.next()]);\n        if (leftResult.done || rightResult.done) {\n          return;\n        }\n        yield await fn(leftResult.value as A, rightResult.value as B);\n      }\n    })();\n  }\n\n  if (isIterable(iterable) && isIterable(other)) {\n    return (function* () {\n      const leftIter = (iterable as Iterable<A>)[Symbol.iterator]();\n      const rightIter = (other as Iterable<B>)[Symbol.iterator]();\n\n      while (true) {\n        const leftResult = leftIter.next();\n        const rightResult = rightIter.next();\n        if (leftResult.done || rightResult.done) {\n          return;\n        }\n        yield fn(leftResult.value as A, rightResult.value as B) as R;\n      }\n    })();\n  }\n\n  throw new TypeError('zipWith: input is not iterable');\n}\n\nexport default zipWith;\n"],"names":["zipWith","fn","other","iterable","next","isAsyncInput","left","toAsync","right","leftIter","rightIter","leftResult","rightResult","isIterable"],"mappings":";;AAgBA,SAASA,EACPC,GACAC,GACAC,GACK;AACL,MAAIA,MAAa;AACf,WAAO,CAACC,MAAgDJ,EAAQC,GAAIC,GAAOE,CAAI;AAGjF,MAAIC,EAAaH,CAAK,KAAKG,EAAaF,CAAQ;AAC9C,YAAQ,mBAAmB;AACzB,YAAMG,IAAOC,EAAQJ,CAAQ,GACvBK,IAAQD,EAAQL,CAAK,GACrBO,IAAWH,EAAK,OAAO,aAAa,EAAA,GACpCI,IAAYF,EAAM,OAAO,aAAa,EAAA;AAE5C,iBAAa;AACX,cAAM,CAACG,GAAYC,CAAW,IAAI,MAAM,QAAQ,IAAI,CAACH,EAAS,KAAA,GAAQC,EAAU,KAAA,CAAM,CAAC;AACvF,YAAIC,EAAW,QAAQC,EAAY;AACjC;AAEF,cAAM,MAAMX,EAAGU,EAAW,OAAYC,EAAY,KAAU;AAAA,MAC9D;AAAA,IACF,GAAA;AAGF,MAAIC,EAAWV,CAAQ,KAAKU,EAAWX,CAAK;AAC1C,YAAQ,aAAa;AACnB,YAAMO,IAAYN,EAAyB,OAAO,QAAQ,EAAA,GACpDO,IAAaR,EAAsB,OAAO,QAAQ,EAAA;AAExD,iBAAa;AACX,cAAMS,IAAaF,EAAS,KAAA,GACtBG,IAAcF,EAAU,KAAA;AAC9B,YAAIC,EAAW,QAAQC,EAAY;AACjC;AAEF,cAAMX,EAAGU,EAAW,OAAYC,EAAY,KAAU;AAAA,MACxD;AAAA,IACF,GAAA;AAGF,QAAM,IAAI,UAAU,gCAAgC;AACtD;"}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "fp-pack",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Functional programming utilities library for TypeScript",
+  "keywords": [
+    "functional",
+    "functional-programming",
+    "fp",
+    "typescript",
+    "javascript",
+    "utility",
+    "utilities",
+    "pipe",
+    "compose",
+    "curry",
+    "stream",
+    "iterable",
+    "async",
+    "lazy",
+    "side-effect"
+  ],
+  "license": "MIT",
+  "homepage": "https://superlucky84.github.io/fp-pack/",
+  "repository": "https://github.com/superlucky84/fp-pack",
+  "bugs": {
+    "url": "https://github.com/superlucky84/fp-pack/issues"
+  },
+  "main": "./dist/fp-pack.umd.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/fp-pack.umd.js"
+    },
+    "./stream": {
+      "types": "./dist/stream/index.d.ts",
+      "import": "./dist/stream/index.mjs",
+      "require": "./dist/fp-pack-stream.umd.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "stream": [
+        "dist/stream/index.d.ts"
+      ],
+      "stream/*": [
+        "dist/stream/*"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@vitest/ui": "2.1.9",
+    "prettier": "^3.7.4",
+    "typescript": "~5.9.3",
+    "vite": "^7.2.4",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^2.1.9"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && vite build --config vite.umd.config.ts && vite build --config vite.umd.stream.config.ts && node scripts/copy-skills.mjs",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run",
+    "clean": "pnpm clean:dist && pnpm clean:module",
+    "clean:dist": "rm -rf dist docs/dist",
+    "clean:module": "rm -rf dist docs/dist node_modules",
+    "docs:dev": "pnpm --filter docs dev",
+    "docs:build": "pnpm --filter docs build",
+    "docs:preview": "pnpm --filter docs preview",
+    "docs:lint": "pnpm --filter docs lint",
+    "docs:lint:fix": "pnpm --filter docs lint:fix",
+    "docs:format": "pnpm --filter docs format"
+  }
+}

package/src/implement/array/append.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import append from './append';
+
+describe('append', () => {
+  it('appends value to array', () => {
+    expect(append(3, [1, 2])).toEqual([1, 2, 3]);
+  });
+
+  it('supports data-last usage', () => {
+    const addTail = append(4);
+    expect(addTail([1, 2])).toEqual([1, 2, 4]);
+  });
+});

package/src/implement/array/append.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Append = {
+  <T>(...args: [value: T]): (arr: T[]) => T[];
+  <T>(...args: [value: T, arr: T[]]): T[];
+};
+
+/**
+ * append - 배열 끝에 값 추가
+ */
+function append<T>(value: T, arr: T[]): T[] {
+  return [...arr, value];
+}
+
+const curriedAppend = curry(append) as Append;
+export default curriedAppend;

package/src/implement/array/chunk.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import chunk from './chunk';
+
+describe('chunk', () => {
+  it('splits an array into chunks of the given size', () => {
+    const result = chunk(2, [1, 2, 3, 4, 5]);
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it('returns a single chunk when size exceeds length', () => {
+    const result = chunk(10, [1, 2, 3]);
+    expect(result).toEqual([[1, 2, 3]]);
+  });
+
+  it('returns an empty array for non-positive sizes', () => {
+    expect(chunk(0, [1, 2, 3])).toEqual([]);
+    expect(chunk(-1, [1, 2, 3])).toEqual([]);
+  });
+
+  it('handles empty arrays', () => {
+    expect(chunk(3, [])).toEqual([]);
+  });
+});

package/src/implement/array/chunk.ts

@@ -0,0 +1,25 @@
+import curry from '../composition/curry';
+
+type Chunk = {
+  (size: number): <T>(arr: T[]) => T[][];
+  <T>(...args: [size: number, arr: T[]]): T[][];
+};
+
+/**
+ * chunk - 배열을 일정 크기로 분할
+ */
+function chunk<T>(size: number, arr: T[]): T[][] {
+  const chunkSize = Math.floor(size);
+  if (!Number.isFinite(chunkSize) || chunkSize <= 0) {
+    return [];
+  }
+
+  const result: T[][] = [];
+  for (let i = 0; i < arr.length; i += chunkSize) {
+    result.push(arr.slice(i, i + chunkSize));
+  }
+  return result;
+}
+
+const curriedChunk = curry(chunk) as Chunk;
+export default curriedChunk;

package/src/implement/array/concat.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import concat from './concat';
+
+describe('concat', () => {
+  it('concats arrays', () => {
+    expect(concat([3, 4], [1, 2])).toEqual([1, 2, 3, 4]);
+  });
+
+  it('supports data-last usage', () => {
+    const concatTail = concat([3]);
+    expect(concatTail([1, 2])).toEqual([1, 2, 3]);
+  });
+});

package/src/implement/array/concat.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Concat = {
+  <T>(...args: [other: T[]]): (arr: T[]) => T[];
+  <T>(...args: [other: T[], arr: T[]]): T[];
+};
+
+/**
+ * concat - 두 배열 연결
+ */
+function concat<T>(other: T[], arr: T[]): T[] {
+  return [...arr, ...other];
+}
+
+const curriedConcat = curry(concat) as Concat;
+export default curriedConcat;

package/src/implement/array/curried.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import chunk from './chunk';
+import drop from './drop';
+import every from './every';
+import filter from './filter';
+import find from './find';
+import flatMap from './flatMap';
+import groupBy from './groupBy';
+import map from './map';
+import reduce from './reduce';
+import some from './some';
+import sort from './sort';
+import sortBy from './sortBy';
+import take from './take';
+import uniqBy from './uniqBy';
+import zip from './zip';
+
+describe('array (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(chunk(2, [1, 2, 3, 4, 5])).toEqual([[1, 2], [3, 4], [5]]);
+    expect(chunk(2)([1, 2, 3, 4, 5])).toEqual([[1, 2], [3, 4], [5]]);
+
+    expect(drop(2, [1, 2, 3, 4])).toEqual([3, 4]);
+    expect(drop(2)([1, 2, 3, 4])).toEqual([3, 4]);
+
+    expect(take(2, [1, 2, 3, 4])).toEqual([1, 2]);
+    expect(take(2)([1, 2, 3, 4])).toEqual([1, 2]);
+
+    expect(map((n: number) => n * 2, [1, 2])).toEqual([2, 4]);
+    expect(map((n: number) => n * 2)([1, 2])).toEqual([2, 4]);
+
+    expect(filter((n: number) => n % 2 === 0, [1, 2, 3, 4])).toEqual([2, 4]);
+    expect(filter((n: number) => n % 2 === 0)([1, 2, 3, 4])).toEqual([2, 4]);
+
+    expect(find((n: number) => n > 2, [1, 2, 3, 4])).toBe(3);
+    expect(find((n: number) => n > 2)([1, 2, 3, 4])).toBe(3);
+
+    expect(flatMap((n: number) => [n, n * 2], [1, 2])).toEqual([1, 2, 2, 4]);
+    expect(flatMap((n: number) => [n, n * 2])([1, 2])).toEqual([1, 2, 2, 4]);
+
+    expect(reduce((acc: number, n: number) => acc + n, 0, [1, 2, 3])).toBe(6);
+    expect(reduce((acc: number, n: number) => acc + n)(0)([1, 2, 3])).toBe(6);
+
+    expect(some((n: number) => n > 2, [1, 2, 3])).toBe(true);
+    expect(some((n: number) => n > 2)([1, 2, 3])).toBe(true);
+
+    expect(every((n: number) => n > 0, [1, 2, 3])).toBe(true);
+    expect(every((n: number) => n > 0)([1, 2, 3])).toBe(true);
+
+    expect(sort((a: number, b: number) => a - b, [3, 1, 2])).toEqual([1, 2, 3]);
+    expect(sort((a: number, b: number) => a - b)([3, 1, 2])).toEqual([1, 2, 3]);
+
+    expect(sortBy((item: { n: number }) => item.n, [{ n: 3 }, { n: 1 }, { n: 2 }])).toEqual([
+      { n: 1 },
+      { n: 2 },
+      { n: 3 },
+    ]);
+    expect(sortBy((item: { n: number }) => item.n)([{ n: 3 }, { n: 1 }, { n: 2 }])).toEqual([
+      { n: 1 },
+      { n: 2 },
+      { n: 3 },
+    ]);
+
+    expect(groupBy((n: number) => (n % 2 === 0 ? 'even' : 'odd'), [1, 2, 3, 4])).toEqual({
+      odd: [1, 3],
+      even: [2, 4],
+    });
+    expect(groupBy((n: number) => (n % 2 === 0 ? 'even' : 'odd'))([1, 2, 3, 4])).toEqual({
+      odd: [1, 3],
+      even: [2, 4],
+    });
+
+    expect(uniqBy((item: { id: number }) => item.id, [{ id: 1 }, { id: 1 }, { id: 2 }])).toEqual([
+      { id: 1 },
+      { id: 2 },
+    ]);
+    expect(uniqBy((item: { id: number }) => item.id)([{ id: 1 }, { id: 1 }, { id: 2 }])).toEqual([
+      { id: 1 },
+      { id: 2 },
+    ]);
+
+    expect(zip(['a', 'b', 'c'], [1, 2])).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+    ]);
+    expect(zip(['a', 'b', 'c'])([1, 2])).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+    ]);
+  });
+});

package/src/implement/array/drop.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import drop from './drop';
+
+describe('drop', () => {
+  it('drops the first n items', () => {
+    expect(drop(2, [1, 2, 3, 4])).toEqual([3, 4]);
+  });
+
+  it('returns an empty array when n exceeds length', () => {
+    expect(drop(10, [1, 2, 3])).toEqual([]);
+  });
+
+  it('returns the same array for non-positive n', () => {
+    const arr = [1, 2, 3];
+    expect(drop(0, arr)).toBe(arr);
+    expect(drop(-1, arr)).toBe(arr);
+  });
+
+  it('handles empty arrays', () => {
+    expect(drop(3, [])).toEqual([]);
+  });
+});

package/src/implement/array/drop.ts

@@ -0,0 +1,20 @@
+import curry from '../composition/curry';
+
+type Drop = {
+  (n: number): <T>(arr: T[]) => T[];
+  <T>(...args: [n: number, arr: T[]]): T[];
+};
+
+/**
+ * drop - 앞에서 n개 제외
+ */
+function drop<T>(n: number, arr: T[]): T[] {
+  const count = Math.floor(n);
+  if (!Number.isFinite(count) || count <= 0) {
+    return arr;
+  }
+  return arr.slice(count);
+}
+
+const curriedDrop = curry(drop) as Drop;
+export default curriedDrop;

package/src/implement/array/dropWhile.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import dropWhile from './dropWhile';
+
+describe('dropWhile', () => {
+  it('drops while predicate holds', () => {
+    expect(dropWhile((n: number) => n < 3, [1, 2, 3, 2])).toEqual([3, 2]);
+  });
+
+  it('supports data-last usage', () => {
+    const dropSmall = dropWhile((n: number) => n <= 2);
+    expect(dropSmall([1, 2, 3, 4])).toEqual([3, 4]);
+  });
+});

package/src/implement/array/dropWhile.ts

@@ -0,0 +1,26 @@
+import curry from '../composition/curry';
+
+type DropWhile = {
+  <T>(...args: [predicate: (value: T) => boolean]): (arr: T[]) => T[];
+  <T>(...args: [predicate: (value: T) => boolean, arr: T[]]): T[];
+};
+
+/**
+ * dropWhile - 조건이 유지되는 동안 앞에서 제외
+ */
+function dropWhile<T>(predicate: (value: T) => boolean, arr: T[]): T[] {
+  const result: T[] = [];
+  let dropping = true;
+  for (const item of arr) {
+    if (dropping && !predicate(item)) {
+      dropping = false;
+    }
+    if (!dropping) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+const curriedDropWhile = curry(dropWhile) as DropWhile;
+export default curriedDropWhile;

package/src/implement/array/every.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import every from './every';
+
+describe('every', () => {
+  it('returns true when all items satisfy the predicate', () => {
+    expect(every((n: number) => n > 0, [1, 2, 3])).toBe(true);
+  });
+
+  it('returns false when any item fails the predicate', () => {
+    expect(every((n: number) => n > 2, [1, 2, 3])).toBe(false);
+  });
+
+  it('returns true for empty arrays', () => {
+    expect(every((n: number) => n > 0, [])).toBe(true);
+  });
+});

package/src/implement/array/every.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Every = {
+  <T>(...args: [predicate: (value: T) => boolean]): (arr: T[]) => boolean;
+  <T>(...args: [predicate: (value: T) => boolean, arr: T[]]): boolean;
+};
+
+/**
+ * every - 조건 검사 (모두 만족)
+ */
+function every<T>(predicate: (value: T) => boolean, arr: T[]): boolean {
+  return arr.every(predicate);
+}
+
+const curriedEvery = curry(every) as Every;
+export default curriedEvery;

package/src/implement/array/filter.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import filter from "./filter";
+
+describe("filter", () => {
+  it("filters items by predicate", () => {
+    expect(filter((n: number) => n % 2 === 0, [1, 2, 3, 4])).toEqual([2, 4]);
+  });
+
+  it("returns an empty array when no items match", () => {
+    expect(filter((n: number) => n > 10, [1, 2, 3])).toEqual([]);
+  });
+
+  it("returns empty array when input is empty", () => {
+    expect(filter((n: number) => n > 0, [])).toEqual([]);
+  });
+});

package/src/implement/array/filter.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Filter = {
+  <T>(...args: [predicate: (value: T) => boolean]): (arr: T[]) => T[];
+  <T>(...args: [predicate: (value: T) => boolean, arr: T[]]): T[];
+};
+
+/**
+ * filter - 조건 필터링
+ */
+function filter<T>(predicate: (value: T) => boolean, arr: T[]): T[] {
+  return arr.filter(predicate);
+}
+
+const curriedFilter = curry(filter) as Filter;
+export default curriedFilter;

package/src/implement/array/find.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import find from './find';
+
+describe('find', () => {
+  it('returns the first matching element', () => {
+    expect(find((n: number) => n > 2, [1, 2, 3, 4])).toBe(3);
+  });
+
+  it('returns undefined when no items match', () => {
+    expect(find((n: number) => n > 10, [1, 2, 3])).toBeUndefined();
+  });
+
+  it('returns undefined for empty arrays', () => {
+    expect(find((n: number) => n > 0, [])).toBeUndefined();
+  });
+});

package/src/implement/array/find.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Find = {
+  <T>(...args: [predicate: (value: T) => boolean]): (arr: T[]) => T | undefined;
+  <T>(...args: [predicate: (value: T) => boolean, arr: T[]]): T | undefined;
+};
+
+/**
+ * find - 조건 만족 첫 요소
+ */
+function find<T>(predicate: (value: T) => boolean, arr: T[]): T | undefined {
+  return arr.find(predicate);
+}
+
+const curriedFind = curry(find) as Find;
+export default curriedFind;

package/src/implement/array/flatMap.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import flatMap from './flatMap';
+
+describe('flatMap', () => {
+  it('maps and flattens one level', () => {
+    const result = flatMap((n: number) => [n, n * 2], [1, 2, 3]);
+    expect(result).toEqual([1, 2, 2, 4, 3, 6]);
+  });
+
+  it('returns empty array for empty input', () => {
+    expect(flatMap((n: number) => [n], [])).toEqual([]);
+  });
+});

package/src/implement/array/flatMap.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type FlatMap = {
+  <T, R>(...args: [fn: (value: T) => R[]]): (arr: T[]) => R[];
+  <T, R>(...args: [fn: (value: T) => R[], arr: T[]]): R[];
+};
+
+/**
+ * flatMap - map 후 flatten
+ */
+function flatMap<T, R>(fn: (value: T) => R[], arr: T[]): R[] {
+  return arr.flatMap(fn);
+}
+
+const curriedFlatMap = curry(flatMap) as FlatMap;
+export default curriedFlatMap;

package/src/implement/array/flatten.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from 'vitest';
+import flatten from './flatten';
+
+describe('flatten', () => {
+  it('flattens a single level', () => {
+    expect(flatten([[1, 2], [3]])).toEqual([1, 2, 3]);
+  });
+});

package/src/implement/array/flatten.ts

@@ -0,0 +1,8 @@
+/**
+ * flatten - 1단계 배열 평탄화
+ */
+function flatten<T>(arr: T[][]): T[] {
+  return arr.flat();
+}
+
+export default flatten;

package/src/implement/array/flattenDeep.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import flattenDeep from './flattenDeep';
+
+describe('flattenDeep', () => {
+  it('flattens nested arrays of any depth', () => {
+    const input = [1, [2, [3, 4], 5], [[6]]];
+    expect(flattenDeep(input)).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  it('handles empty arrays', () => {
+    expect(flattenDeep([])).toEqual([]);
+  });
+});

package/src/implement/array/flattenDeep.ts

@@ -0,0 +1,21 @@
+/**
+ * flattenDeep - 깊은 배열 평탄화
+ */
+function flattenDeep<T>(arr: any[]): T[] {
+  const result: T[] = [];
+
+  const walk = (items: any[]) => {
+    for (const item of items) {
+      if (Array.isArray(item)) {
+        walk(item);
+      } else {
+        result.push(item);
+      }
+    }
+  };
+
+  walk(arr);
+  return result;
+}
+
+export default flattenDeep;

package/src/implement/array/groupBy.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import groupBy from './groupBy';
+
+describe('groupBy', () => {
+  it('groups items by key function', () => {
+    const result = groupBy((n: number) => (n % 2 === 0 ? 'even' : 'odd'), [1, 2, 3, 4]);
+    expect(result).toEqual({ odd: [1, 3], even: [2, 4] });
+  });
+
+  it('returns empty object for empty arrays', () => {
+    expect(groupBy((n: number) => String(n), [])).toEqual({});
+  });
+});

package/src/implement/array/groupBy.ts

@@ -0,0 +1,23 @@
+import curry from '../composition/curry';
+
+type GroupBy = {
+  <T>(...args: [fn: (value: T) => string]): (arr: T[]) => Record<string, T[]>;
+  <T>(...args: [fn: (value: T) => string, arr: T[]]): Record<string, T[]>;
+};
+
+/**
+ * groupBy - 키 기준 그룹화
+ */
+function groupBy<T>(fn: (value: T) => string, arr: T[]): Record<string, T[]> {
+  return arr.reduce<Record<string, T[]>>((acc, item) => {
+    const key = fn(item);
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
+
+const curriedGroupBy = curry(groupBy) as GroupBy;
+export default curriedGroupBy;