fp-pack 0.1.0

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

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import head from './head';
+
+describe('head', () => {
+  it('returns the first element', () => {
+    expect(head([1, 2, 3])).toBe(1);
+  });
+
+  it('returns undefined for empty arrays', () => {
+    expect(head([])).toBeUndefined();
+  });
+});

package/src/implement/array/head.ts

@@ -0,0 +1,8 @@
+/**
+ * head - 첫 요소 가져오기
+ */
+function head<T>(arr: T[]): T | undefined {
+  return arr[0];
+}
+
+export default head;

package/src/implement/array/index.ts

@@ -0,0 +1,33 @@
+export { default as map } from './map';
+export { default as filter } from './filter';
+export { default as reduce } from './reduce';
+export { default as flatMap } from './flatMap';
+export { default as find } from './find';
+export { default as some } from './some';
+export { default as every } from './every';
+export { default as take } from './take';
+export { default as drop } from './drop';
+export { default as dropWhile } from './dropWhile';
+export { default as chunk } from './chunk';
+export { default as zip } from './zip';
+export { default as zipWith } from './zipWith';
+export { default as unzip } from './unzip';
+export { default as uniq } from './uniq';
+export { default as uniqBy } from './uniqBy';
+export { default as sortBy } from './sortBy';
+export { default as sort } from './sort';
+export { default as groupBy } from './groupBy';
+export { default as zipIndex } from './zipIndex';
+export { default as takeWhile } from './takeWhile';
+export { default as scan } from './scan';
+export { default as concat } from './concat';
+export { default as append } from './append';
+export { default as prepend } from './prepend';
+export { default as flatten } from './flatten';
+export { default as head } from './head';
+export { default as tail } from './tail';
+export { default as last } from './last';
+export { default as init } from './init';
+export { default as range } from './range';
+export { default as partition } from './partition';
+export { default as flattenDeep } from './flattenDeep';

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

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import init from './init';
+
+describe('init', () => {
+  it('returns all elements except the last', () => {
+    expect(init([1, 2, 3])).toEqual([1, 2]);
+  });
+
+  it('returns empty array for arrays with 0 or 1 element', () => {
+    expect(init([])).toEqual([]);
+    expect(init([1])).toEqual([]);
+  });
+});

package/src/implement/array/init.ts

@@ -0,0 +1,9 @@
+/**
+ * init - 마지막 요소 제외
+ */
+function init<T>(arr: T[]): T[] {
+  if (arr.length <= 1) return [];
+  return arr.slice(0, -1);
+}
+
+export default init;

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

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import last from './last';
+
+describe('last', () => {
+  it('returns the last element', () => {
+    expect(last([1, 2, 3])).toBe(3);
+  });
+
+  it('returns undefined for empty arrays', () => {
+    expect(last([])).toBeUndefined();
+  });
+});

package/src/implement/array/last.ts

@@ -0,0 +1,9 @@
+/**
+ * last - 마지막 요소 가져오기
+ */
+function last<T>(arr: T[]): T | undefined {
+  if (arr.length === 0) return undefined;
+  return arr[arr.length - 1];
+}
+
+export default last;

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

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import map from './map';
+
+describe('map', () => {
+  it('maps each element using the provided function', () => {
+    expect(map((n: number) => n * 2, [1, 2, 3])).toEqual([2, 4, 6]);
+  });
+
+  it('returns an empty array for empty input', () => {
+    expect(map((n: number) => n * 2, [])).toEqual([]);
+  });
+});

package/src/implement/array/map.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Map = {
+  <T, R>(...args: [fn: (value: T) => R]): (arr: T[]) => R[];
+  <T, R>(...args: [fn: (value: T) => R, arr: T[]]): R[];
+};
+
+/**
+ * map - 요소 변환
+ */
+function map<T, R>(fn: (value: T) => R, arr: T[]): R[] {
+  return arr.map(fn);
+}
+
+const curriedMap = curry(map) as Map;
+export default curriedMap;

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

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import partition from './partition';
+
+describe('partition', () => {
+  it('splits items by predicate', () => {
+    const [even, odd] = partition((value: number) => value % 2 === 0, [1, 2, 3, 4, 5]);
+    expect(even).toEqual([2, 4]);
+    expect(odd).toEqual([1, 3, 5]);
+  });
+
+  it('returns empty groups for empty arrays', () => {
+    expect(partition((value: number) => value > 0, [])).toEqual([[], []]);
+  });
+});

package/src/implement/array/partition.ts

@@ -0,0 +1,27 @@
+import curry from '../composition/curry';
+
+type Partition = {
+  <T>(...args: [predicate: (value: T) => boolean]): (arr: T[]) => [T[], T[]];
+  <T>(...args: [predicate: (value: T) => boolean, arr: T[]]): [T[], T[]];
+};
+
+/**
+ * partition - 조건에 따라 분리
+ */
+function partition<T>(predicate: (value: T) => boolean, arr: T[]): [T[], T[]] {
+  const truthy: T[] = [];
+  const falsy: T[] = [];
+
+  for (const item of arr) {
+    if (predicate(item)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
+    }
+  }
+
+  return [truthy, falsy];
+}
+
+const curriedPartition = curry(partition) as Partition;
+export default curriedPartition;

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

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

package/src/implement/array/prepend.ts

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

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

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import range from './range';
+
+describe('range', () => {
+  it('creates an ascending range excluding the end', () => {
+    expect(range(0, 5)).toEqual([0, 1, 2, 3, 4]);
+  });
+
+  it('creates a descending range excluding the end', () => {
+    expect(range(5, 0)).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  it('returns empty array when start equals end', () => {
+    expect(range(3, 3)).toEqual([]);
+  });
+});

package/src/implement/array/range.ts

@@ -0,0 +1,18 @@
+/**
+ * range - 숫자 범위 생성 (end 제외)
+ */
+function range(start: number, end: number): number[] {
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return [];
+  if (start === end) return [];
+
+  const step = start < end ? 1 : -1;
+  const result: number[] = [];
+
+  for (let value = start; step > 0 ? value < end : value > end; value += step) {
+    result.push(value);
+  }
+
+  return result;
+}
+
+export default range;

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

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import reduce from './reduce';
+
+describe('reduce', () => {
+  it('reduces an array to a single value', () => {
+    const sum = reduce((acc: number, n: number) => acc + n, 0, [1, 2, 3, 4]);
+    expect(sum).toBe(10);
+  });
+
+  it('returns the initial value for empty arrays', () => {
+    expect(reduce((acc: number, n: number) => acc + n, 5, [])).toBe(5);
+  });
+
+  it('can build up objects', () => {
+    const result = reduce(
+      (acc: Record<string, number>, n: number) => {
+        acc[String(n)] = n * 10;
+        return acc;
+      },
+      {},
+      [1, 2]
+    );
+    expect(result).toEqual({ '1': 10, '2': 20 });
+  });
+});

package/src/implement/array/reduce.ts

@@ -0,0 +1,21 @@
+import curry from '../composition/curry';
+
+type Reduce = {
+  <T, R>(...args: [fn: (acc: R, value: T) => R]): (initial: R) => (arr: T[]) => R;
+  <T, R>(...args: [fn: (acc: R, value: T) => R, initial: R]): (arr: T[]) => R;
+  <T, R>(...args: [fn: (acc: R, value: T) => R, initial: R, arr: T[]]): R;
+};
+
+/**
+ * reduce - 누적 연산
+ */
+function reduce<T, R>(
+  fn: (acc: R, value: T) => R,
+  initial: R,
+  arr: T[]
+): R {
+  return arr.reduce(fn, initial);
+}
+
+const curriedReduce = curry(reduce) as Reduce;
+export default curriedReduce;

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

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import scan from './scan';
+
+describe('scan', () => {
+  it('returns accumulated values', () => {
+    expect(scan((acc: number, n: number) => acc + n, 0, [1, 2, 3])).toEqual([1, 3, 6]);
+  });
+
+  it('supports data-last usage', () => {
+    const runningSum = scan((acc: number, n: number) => acc + n, 0);
+    expect(runningSum([2, 2])).toEqual([2, 4]);
+  });
+});

package/src/implement/array/scan.ts

@@ -0,0 +1,23 @@
+import curry from '../composition/curry';
+
+type Scan = {
+  <T, R>(...args: [fn: (acc: R, value: T) => R]): (initial: R) => (arr: T[]) => R[];
+  <T, R>(...args: [fn: (acc: R, value: T) => R, initial: R]): (arr: T[]) => R[];
+  <T, R>(...args: [fn: (acc: R, value: T) => R, initial: R, arr: T[]]): R[];
+};
+
+/**
+ * scan - 누적 중간값을 배열로 반환
+ */
+function scan<T, R>(fn: (acc: R, value: T) => R, initial: R, arr: T[]): R[] {
+  const result: R[] = [];
+  let acc = initial;
+  for (const item of arr) {
+    acc = fn(acc, item);
+    result.push(acc);
+  }
+  return result;
+}
+
+const curriedScan = curry(scan) as Scan;
+export default curriedScan;

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

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import some from './some';
+
+describe('some', () => {
+  it('returns true if any element matches', () => {
+    const isEven = (n: number) => n % 2 === 0;
+    expect(some(isEven, [1, 3, 4])).toBe(true);
+  });
+
+  it('returns false if no element matches', () => {
+    const gtTen = (n: number) => n > 10;
+    expect(some(gtTen, [3, 5, 7])).toBe(false);
+  });
+
+  it('stops early on first match', () => {
+    const spy: number[] = [];
+    const track = (n: number) => {
+      spy.push(n);
+      return n === 3;
+    };
+
+    expect(some(track, [1, 2, 3, 4, 5])).toBe(true);
+    expect(spy).toEqual([1, 2, 3]); // 이후 요소는 검사 안 함
+  });
+});

package/src/implement/array/some.ts

@@ -0,0 +1,19 @@
+import curry from '../composition/curry';
+
+type Some = {
+  <T>(...args: [predicate: (value: T) => boolean]): (arr: T[]) => boolean;
+  <T>(...args: [predicate: (value: T) => boolean, arr: T[]]): boolean;
+};
+
+/**
+ * some - 조건 검사 (하나라도 만족)
+ */
+function some<T>(predicate: (value: T) => boolean, arr: T[]): boolean {
+  for (let i = 0; i < arr.length; i++) {
+    if (predicate(arr[i])) return true;
+  }
+  return false;
+}
+
+const curriedSome = curry(some) as Some;
+export default curriedSome;

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

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import sort from './sort';
+
+describe('sort', () => {
+  it('sorts numbers using comparator', () => {
+    const asc = (a: number, b: number) => a - b;
+    expect(sort(asc, [3, 1, 2])).toEqual([1, 2, 3]);
+  });
+
+  it('does not mutate the original array', () => {
+    const data = [2, 1, 3];
+    sort((a, b) => a - b, data);
+    expect(data).toEqual([2, 1, 3]);
+  });
+
+  it('sorts objects by field with custom comparator', () => {
+    const items = [
+      { id: 1, score: 30 },
+      { id: 2, score: 10 },
+      { id: 3, score: 20 },
+    ];
+    const result = sort((a, b) => a.score - b.score, items);
+    expect(result.map((x) => x.id)).toEqual([2, 3, 1]);
+  });
+});

package/src/implement/array/sort.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Sort = {
+  <T>(...args: [compare: (a: T, b: T) => number]): (arr: T[]) => T[];
+  <T>(...args: [compare: (a: T, b: T) => number, arr: T[]]): T[];
+};
+
+/**
+ * sort - 비교 함수로 정렬 (불변)
+ */
+function sort<T>(compare: (a: T, b: T) => number, arr: T[]): T[] {
+  return [...arr].sort(compare);
+}
+
+const curriedSort = curry(sort) as Sort;
+export default curriedSort;

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

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import sortBy from './sortBy';
+
+describe('sortBy', () => {
+  it('sorts numbers by identity', () => {
+    expect(sortBy((n: number) => n, [3, 1, 2])).toEqual([1, 2, 3]);
+  });
+
+  it('sorts objects by computed key', () => {
+    const users = [
+      { name: 'alice', age: 30 },
+      { name: 'bob', age: 20 },
+      { name: 'carol', age: 25 },
+    ];
+    const result = sortBy((u) => u.age, users);
+    expect(result.map((u) => u.name)).toEqual(['bob', 'carol', 'alice']);
+  });
+
+  it('is stable with equal keys', () => {
+    const items = [
+      { id: 1, group: 'a' },
+      { id: 2, group: 'b' },
+      { id: 3, group: 'a' },
+    ];
+    const result = sortBy((x) => x.group, items);
+    expect(result.map((x) => x.id)).toEqual([1, 3, 2]); // 원래 순서 유지
+  });
+});

package/src/implement/array/sortBy.ts

@@ -0,0 +1,22 @@
+import curry from '../composition/curry';
+
+type SortBy = {
+  <T>(...args: [fn: (value: T) => any]): (arr: T[]) => T[];
+  <T>(...args: [fn: (value: T) => any, arr: T[]]): T[];
+};
+
+/**
+ * sortBy - 기준 함수로 정렬
+ */
+function sortBy<T>(fn: (value: T) => any, arr: T[]): T[] {
+  return [...arr].sort((a, b) => {
+    const aKey = fn(a);
+    const bKey = fn(b);
+    if (aKey < bKey) return -1;
+    if (aKey > bKey) return 1;
+    return 0;
+  });
+}
+
+const curriedSortBy = curry(sortBy) as SortBy;
+export default curriedSortBy;

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

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import tail from './tail';
+
+describe('tail', () => {
+  it('returns all elements except the first', () => {
+    expect(tail([1, 2, 3])).toEqual([2, 3]);
+  });
+
+  it('returns empty array for arrays with 0 or 1 element', () => {
+    expect(tail([])).toEqual([]);
+    expect(tail([1])).toEqual([]);
+  });
+});

package/src/implement/array/tail.ts

@@ -0,0 +1,8 @@
+/**
+ * tail - 첫 요소 제외
+ */
+function tail<T>(arr: T[]): T[] {
+  return arr.slice(1);
+}
+
+export default tail;

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

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import take from './take';
+
+describe('take', () => {
+  it('takes first n elements', () => {
+    expect(take(2, [1, 2, 3, 4])).toEqual([1, 2]);
+  });
+
+  it('returns empty when n <= 0', () => {
+    expect(take(0, [1, 2, 3])).toEqual([]);
+    expect(take(-1, [1, 2, 3])).toEqual([]);
+  });
+
+  it('returns copy when n >= length', () => {
+    const arr = [1, 2];
+    const result = take(5, arr);
+    expect(result).toEqual([1, 2]);
+    expect(result).not.toBe(arr); // 불변성
+  });
+});

package/src/implement/array/take.ts

@@ -0,0 +1,18 @@
+import curry from '../composition/curry';
+
+type Take = {
+  (n: number): <T>(arr: T[]) => T[];
+  <T>(...args: [n: number, arr: T[]]): T[];
+};
+
+/**
+ * take - 앞에서 n개 선택
+ */
+function take<T>(n: number, arr: T[]): T[] {
+  if (n <= 0) return [];
+  if (n >= arr.length) return [...arr];
+  return arr.slice(0, n);
+}
+
+const curriedTake = curry(take) as Take;
+export default curriedTake;

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

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

package/src/implement/array/takeWhile.ts

@@ -0,0 +1,23 @@
+import curry from '../composition/curry';
+
+type TakeWhile = {
+  <T>(...args: [predicate: (value: T) => boolean]): (arr: T[]) => T[];
+  <T>(...args: [predicate: (value: T) => boolean, arr: T[]]): T[];
+};
+
+/**
+ * takeWhile - 조건이 유지되는 동안 앞에서 가져오기
+ */
+function takeWhile<T>(predicate: (value: T) => boolean, arr: T[]): T[] {
+  const result: T[] = [];
+  for (const item of arr) {
+    if (!predicate(item)) {
+      break;
+    }
+    result.push(item);
+  }
+  return result;
+}
+
+const curriedTakeWhile = curry(takeWhile) as TakeWhile;
+export default curriedTakeWhile;

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

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import uniq from './uniq';
+
+describe('uniq', () => {
+  it('removes duplicate primitives', () => {
+    expect(uniq([1, 2, 2, 3, 1])).toEqual([1, 2, 3]);
+  });
+
+  it('keeps first occurrence order', () => {
+    expect(uniq(['a', 'b', 'a', 'c', 'b'])).toEqual(['a', 'b', 'c']);
+  });
+
+  it('compares by reference for objects', () => {
+    const a = { id: 1 };
+    const b = { id: 1 };
+    expect(uniq([a, b, a])).toEqual([a, b]);
+  });
+});

package/src/implement/array/uniq.ts

@@ -0,0 +1,16 @@
+/**
+ * uniq - 중복 제거
+ */
+function uniq<T>(arr: T[]): T[] {
+  const seen = new Set<T>();
+  const result: T[] = [];
+  for (const item of arr) {
+    if (!seen.has(item)) {
+      seen.add(item);
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+export default uniq;

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

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import uniqBy from './uniqBy';
+
+describe('uniqBy', () => {
+  it('removes duplicates based on key selector', () => {
+    const items = [
+      { id: 1, v: 'a' },
+      { id: 2, v: 'b' },
+      { id: 3, v: 'a' },
+    ];
+    expect(uniqBy((x) => x.v, items)).toEqual([
+      { id: 1, v: 'a' },
+      { id: 2, v: 'b' },
+    ]);
+  });
+
+  it('preserves first occurrence order', () => {
+    const arr = ['aa', 'ab', 'ba', 'bb'];
+    const result = uniqBy((s) => s[0], arr); // key: first letter
+    expect(result).toEqual(['aa', 'ba']);
+  });
+});