fp-pack 0.1.0

package/src/implement/array/uniqBy.ts

@@ -0,0 +1,25 @@
+import curry from '../composition/curry';
+
+type UniqBy = {
+  <T>(...args: [fn: (value: T) => any]): (arr: T[]) => T[];
+  <T>(...args: [fn: (value: T) => any, arr: T[]]): T[];
+};
+
+/**
+ * uniqBy - 기준 함수로 중복 제거
+ */
+function uniqBy<T>(fn: (value: T) => any, arr: T[]): T[] {
+  const seen = new Set<any>();
+  const result: T[] = [];
+  for (const item of arr) {
+    const key = fn(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+const curriedUniqBy = curry(uniqBy) as UniqBy;
+export default curriedUniqBy;

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

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import unzip from './unzip';
+
+describe('unzip', () => {
+  it('splits pairs into two arrays', () => {
+    const input: Array<[number, string]> = [
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c'],
+    ];
+
+    const [nums, strs] = unzip(input);
+    expect(nums).toEqual([1, 2, 3]);
+    expect(strs).toEqual(['a', 'b', 'c']);
+  });
+
+  it('handles empty arrays', () => {
+    const [nums, strs] = unzip([]);
+    expect(nums).toEqual([]);
+    expect(strs).toEqual([]);
+  });
+});

package/src/implement/array/unzip.ts

@@ -0,0 +1,16 @@
+/**
+ * unzip - 배열 분리
+ */
+function unzip<T, U>(arr: Array<[T, U]>): [T[], U[]] {
+  const left: T[] = [];
+  const right: U[] = [];
+
+  for (const [a, b] of arr) {
+    left.push(a);
+    right.push(b);
+  }
+
+  return [left, right];
+}
+
+export default unzip;

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

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import zip from './zip';
+
+describe('zip', () => {
+  it('pairs elements until the shortest length', () => {
+    expect(zip(['a', 'b'], [1, 2, 3])).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+    ]);
+  });
+
+  it('returns empty array when one side is empty', () => {
+    expect(zip([], [1, 2])).toEqual([]);
+    expect(zip(['a'], [])).toEqual([]);
+  });
+});

package/src/implement/array/zip.ts

@@ -0,0 +1,23 @@
+import curry from '../composition/curry';
+
+type Zip = {
+  <U>(...args: [arr2: U[]]): <T>(arr1: T[]) => Array<[T, U]>;
+  <T, U>(...args: [arr2: U[], arr1: T[]]): Array<[T, U]>;
+};
+
+/**
+ * zip - 배열 병합
+ */
+function zip<T, U>(arr2: U[], arr1: T[]): Array<[T, U]> {
+  const length = Math.min(arr1.length, arr2.length);
+  const result: Array<[T, U]> = [];
+
+  for (let i = 0; i < length; i += 1) {
+    result.push([arr1[i], arr2[i]]);
+  }
+
+  return result;
+}
+
+const curriedZip = curry(zip) as Zip;
+export default curriedZip;

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

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import zipIndex from './zipIndex';
+
+describe('zipIndex', () => {
+  it('pairs each element with its index', () => {
+    expect(zipIndex(['a', 'b', 'c'])).toEqual([
+      [0, 'a'],
+      [1, 'b'],
+      [2, 'c'],
+    ]);
+  });
+
+  it('returns an empty array for empty input', () => {
+    expect(zipIndex([])).toEqual([]);
+  });
+});

package/src/implement/array/zipIndex.ts

@@ -0,0 +1,8 @@
+/**
+ * zipIndex - 인덱스와 값을 쌍으로 묶기
+ */
+function zipIndex<T>(arr: T[]): Array<[number, T]> {
+  return arr.map((value, index) => [index, value]);
+}
+
+export default zipIndex;

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

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import zipWith from './zipWith';
+
+describe('zipWith', () => {
+  it('zips arrays with a function', () => {
+    expect(zipWith((a: number, b: number) => a + b, [10, 20], [1, 2, 3])).toEqual([11, 22]);
+  });
+
+  it('supports data-last usage', () => {
+    const zipper = zipWith((a: number, b: number) => a * b, [2, 3]);
+    expect(zipper([4, 5, 6])).toEqual([8, 15]);
+  });
+});

package/src/implement/array/zipWith.ts

@@ -0,0 +1,22 @@
+import curry from '../composition/curry';
+
+type ZipWith = {
+  <A, B, R>(...args: [fn: (a: A, b: B) => R]): (other: B[]) => (arr: A[]) => R[];
+  <A, B, R>(...args: [fn: (a: A, b: B) => R, other: B[]]): (arr: A[]) => R[];
+  <A, B, R>(...args: [fn: (a: A, b: B) => R, other: B[], arr: A[]]): R[];
+};
+
+/**
+ * zipWith - 두 배열을 함수로 결합
+ */
+function zipWith<A, B, R>(fn: (a: A, b: B) => R, other: B[], arr: A[]): R[] {
+  const length = Math.min(arr.length, other.length);
+  const result: R[] = [];
+  for (let i = 0; i < length; i += 1) {
+    result.push(fn(arr[i], other[i]));
+  }
+  return result;
+}
+
+const curriedZipWith = curry(zipWith) as ZipWith;
+export default curriedZipWith;

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

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi } from 'vitest';
+import debounce from './debounce';
+import debounceLeading from './debounceLeading';
+import debounceLeadingTrailing from './debounceLeadingTrailing';
+import retry from './retry';
+import throttle from './throttle';
+import timeout from './timeout';
+
+describe('async (curried)', () => {
+  it('supports debounce direct and currying', () => {
+    vi.useFakeTimers();
+    const fnCurried = vi.fn();
+    const fnDirect = vi.fn();
+    const debounced = debounce(fnCurried)(50);
+    const direct = debounce(fnDirect, 50);
+
+    debounced('a');
+    debounced('b');
+    direct('c');
+    direct('d');
+
+    expect(fnCurried).not.toHaveBeenCalled();
+    expect(fnDirect).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(50);
+    expect(fnCurried).toHaveBeenCalledTimes(1);
+    expect(fnCurried).toHaveBeenCalledWith('b');
+    expect(fnDirect).toHaveBeenCalledTimes(1);
+    expect(fnDirect).toHaveBeenCalledWith('d');
+
+    vi.useRealTimers();
+  });
+
+  it('supports debounceLeading direct and currying', () => {
+    vi.useFakeTimers();
+    const fnCurried = vi.fn();
+    const fnDirect = vi.fn();
+    const debounced = debounceLeading(fnCurried)(50);
+    const direct = debounceLeading(fnDirect, 50);
+
+    debounced('a');
+    debounced('b');
+    direct('c');
+    direct('d');
+
+    expect(fnCurried).toHaveBeenCalledTimes(1);
+    expect(fnCurried).toHaveBeenCalledWith('a');
+    expect(fnDirect).toHaveBeenCalledTimes(1);
+    expect(fnDirect).toHaveBeenCalledWith('c');
+
+    vi.advanceTimersByTime(50);
+    debounced('e');
+    direct('f');
+    expect(fnCurried).toHaveBeenCalledTimes(2);
+    expect(fnCurried).toHaveBeenCalledWith('e');
+    expect(fnDirect).toHaveBeenCalledTimes(2);
+    expect(fnDirect).toHaveBeenCalledWith('f');
+
+    vi.useRealTimers();
+  });
+
+  it('supports debounceLeadingTrailing direct and currying', () => {
+    vi.useFakeTimers();
+    const fnCurried = vi.fn();
+    const fnDirect = vi.fn();
+    const debounced = debounceLeadingTrailing(fnCurried)(50);
+    const direct = debounceLeadingTrailing(fnDirect, 50);
+
+    debounced('a');
+    debounced('b');
+    direct('c');
+    direct('d');
+
+    expect(fnCurried).toHaveBeenCalledTimes(1);
+    expect(fnCurried).toHaveBeenCalledWith('a');
+    expect(fnDirect).toHaveBeenCalledTimes(1);
+    expect(fnDirect).toHaveBeenCalledWith('c');
+
+    vi.advanceTimersByTime(50);
+    expect(fnCurried).toHaveBeenCalledTimes(2);
+    expect(fnCurried).toHaveBeenLastCalledWith('b');
+    expect(fnDirect).toHaveBeenCalledTimes(2);
+    expect(fnDirect).toHaveBeenLastCalledWith('d');
+
+    vi.useRealTimers();
+  });
+
+  it('supports throttle direct and currying', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+
+    const fnCurried = vi.fn();
+    const fnDirect = vi.fn();
+    const throttled = throttle(fnCurried)(50);
+    const direct = throttle(fnDirect, 50);
+
+    throttled('a');
+    throttled('b');
+    direct('c');
+    direct('d');
+
+    expect(fnCurried).not.toHaveBeenCalled();
+    expect(fnDirect).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(50);
+    expect(fnCurried).toHaveBeenCalledTimes(1);
+    expect(fnCurried).toHaveBeenCalledWith('b');
+    expect(fnDirect).toHaveBeenCalledTimes(1);
+    expect(fnDirect).toHaveBeenCalledWith('d');
+
+    vi.useRealTimers();
+  });
+
+  it('supports retry and timeout direct and currying', async () => {
+    let attempts = 0;
+    const task = () => {
+      attempts += 1;
+      return attempts > 1 ? Promise.resolve('ok') : Promise.reject(new Error('fail'));
+    };
+
+    const directResult = await retry(1, task);
+    expect(directResult).toBe('ok');
+
+    attempts = 0;
+    const curriedResult = await retry(1)(task);
+    expect(curriedResult).toBe('ok');
+
+    const directResolved = await timeout(10, Promise.resolve('done'));
+    expect(directResolved).toBe('done');
+
+    const curriedResolved = await timeout(10)(Promise.resolve('done'));
+    expect(curriedResolved).toBe('done');
+  });
+});

package/src/implement/async/debounce.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect, vi } from 'vitest';
+import debounce from './debounce';
+
+describe('debounce', () => {
+  it('runs only once after the last call', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+
+    debounced('a');
+    debounced('b');
+    debounced('c');
+
+    expect(fn).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(100);
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith('c');
+
+    vi.useRealTimers();
+  });
+});

package/src/implement/async/debounce.ts

@@ -0,0 +1,26 @@
+import curry from '../composition/curry';
+
+type Debounce = {
+  <T extends (...args: any[]) => any>(...args: [fn: T]): (ms: number) => T;
+  <T extends (...args: any[]) => any>(...args: [fn: T, ms: number]): T;
+};
+
+/** debounce - 호출 제어 (디바운스) */
+function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const debounced = function (this: unknown, ...args: Parameters<T>) {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    const context = this;
+    timer = setTimeout(() => {
+      timer = undefined;
+      fn.apply(context, args);
+    }, ms);
+  };
+
+  return debounced as T;
+}
+const curriedDebounce = curry(debounce) as Debounce;
+export default curriedDebounce;

package/src/implement/async/debounceLeading.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect, vi } from 'vitest';
+import debounceLeading from './debounceLeading';
+
+describe('debounceLeading', () => {
+  it('runs only on the first call within the window', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounceLeading(fn, 100);
+
+    debounced('a');
+    debounced('b');
+    debounced('c');
+
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith('a');
+
+    vi.advanceTimersByTime(100);
+    debounced('d');
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(fn).toHaveBeenCalledWith('d');
+
+    vi.useRealTimers();
+  });
+});

package/src/implement/async/debounceLeading.ts

@@ -0,0 +1,25 @@
+import curry from '../composition/curry';
+
+type DebounceLeading = {
+  <T extends (...args: any[]) => any>(...args: [fn: T]): (ms: number) => T;
+  <T extends (...args: any[]) => any>(...args: [fn: T, ms: number]): T;
+};
+
+/** debounceLeading - 첫 호출만 실행하는 디바운스 */
+function debounceLeading<T extends (...args: any[]) => any>(fn: T, ms: number): T {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const debounced = function (this: unknown, ...args: Parameters<T>) {
+    if (!timer) {
+      fn.apply(this, args);
+      timer = setTimeout(() => {
+        timer = undefined;
+      }, ms);
+    }
+  };
+
+  return debounced as T;
+}
+
+const curriedDebounceLeading = curry(debounceLeading) as DebounceLeading;
+export default curriedDebounceLeading;

package/src/implement/async/debounceLeadingTrailing.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect, vi } from 'vitest';
+import debounceLeadingTrailing from './debounceLeadingTrailing';
+
+describe('debounceLeadingTrailing', () => {
+  it('runs on the first call and the last call in the window', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounceLeadingTrailing(fn, 100);
+
+    debounced('a');
+    debounced('b');
+    debounced('c');
+
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith('a');
+
+    vi.advanceTimersByTime(100);
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(fn).toHaveBeenCalledWith('c');
+
+    vi.useRealTimers();
+  });
+
+  it('does not run trailing if there is only one call', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounceLeadingTrailing(fn, 100);
+
+    debounced('x');
+    vi.advanceTimersByTime(100);
+
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith('x');
+
+    vi.useRealTimers();
+  });
+});

package/src/implement/async/debounceLeadingTrailing.ts

@@ -0,0 +1,41 @@
+import curry from '../composition/curry';
+
+type DebounceLeadingTrailing = {
+  <T extends (...args: any[]) => any>(...args: [fn: T]): (ms: number) => T;
+  <T extends (...args: any[]) => any>(...args: [fn: T, ms: number]): T;
+};
+
+/** debounceLeadingTrailing - 처음과 마지막에만 실행하는 디바운스 */
+function debounceLeadingTrailing<T extends (...args: any[]) => any>(fn: T, ms: number): T {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let pending = false;
+  let lastArgs: Parameters<T> | undefined;
+  let lastThis: unknown;
+
+  const flush = () => {
+    timer = undefined;
+    if (pending && lastArgs) {
+      pending = false;
+      fn.apply(lastThis, lastArgs);
+    }
+  };
+
+  const debounced = function (this: unknown, ...args: Parameters<T>) {
+    if (!timer) {
+      fn.apply(this, args);
+      timer = setTimeout(flush, ms);
+      return;
+    }
+
+    pending = true;
+    lastArgs = args;
+    lastThis = this;
+    clearTimeout(timer);
+    timer = setTimeout(flush, ms);
+  };
+
+  return debounced as T;
+}
+
+const curriedDebounceLeadingTrailing = curry(debounceLeadingTrailing) as DebounceLeadingTrailing;
+export default curriedDebounceLeadingTrailing;

package/src/implement/async/delay.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect, vi } from 'vitest';
+import delay from './delay';
+
+describe('delay', () => {
+  it('resolves after given milliseconds', async () => {
+    vi.useFakeTimers();
+    const spy = vi.fn();
+
+    const promise = delay(100).then(spy);
+
+    expect(spy).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(99);
+    await Promise.resolve();
+    expect(spy).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(1);
+    await promise;
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    vi.useRealTimers();
+  });
+});

package/src/implement/async/delay.ts

@@ -0,0 +1,7 @@
+/** delay - 일정 시간 대기 */
+function delay(ms: number): Promise<void> {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+export default delay;

package/src/implement/async/index.ts

@@ -0,0 +1,9 @@
+export { default as pipeAsync } from './pipeAsync';
+export { default as pipeAsyncSideEffect } from './pipeAsyncSideEffect';
+export { default as delay } from './delay';
+export { default as timeout } from './timeout';
+export { default as retry } from './retry';
+export { default as debounce } from './debounce';
+export { default as debounceLeading } from './debounceLeading';
+export { default as debounceLeadingTrailing } from './debounceLeadingTrailing';
+export { default as throttle } from './throttle';

package/src/implement/async/pipeAsync.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import pipeAsync from './pipeAsync';
+
+describe('pipeAsync', () => {
+  it('composes async functions left-to-right', async () => {
+    const fn = pipeAsync(
+      async (n: number) => n + 1,
+      async (n) => n * 2
+    );
+
+    await expect(fn(2)).resolves.toBe(6);
+  });
+
+  it('allows sync functions in the chain', async () => {
+    const fn = pipeAsync(
+      (n: number) => n + 1,
+      async (n) => n * 3
+    );
+
+    await expect(fn(1)).resolves.toBe(6);
+  });
+
+});

package/src/implement/async/pipeAsync.ts

@@ -0,0 +1,48 @@
+/** pipeAsync - 비동기 함수 합성 */
+type AsyncOrSync<A, R> = (a: A) => R | Promise<R>;
+type PipeInput<Fns extends AsyncOrSync<any, any>[]> = Fns extends [AsyncOrSync<infer A, any>, ...AsyncOrSync<any, any>[]]
+  ? A
+  : never;
+type PipeOutput<Fns extends AsyncOrSync<any, any>[]> = Fns extends [AsyncOrSync<any, infer R>]
+  ? Awaited<R>
+  : Fns extends [AsyncOrSync<any, infer R>, ...infer Rest]
+    ? Rest extends [AsyncOrSync<Awaited<R>, any>, ...AsyncOrSync<any, any>[]]
+      ? PipeOutput<Rest>
+      : never
+    : never;
+type PipeAsync<Fns extends AsyncOrSync<any, any>[]> = (input: PipeInput<Fns>) => Promise<PipeOutput<Fns>>;
+
+function pipeAsync<A, R>(ab: AsyncOrSync<A, R>): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, R>(ab: AsyncOrSync<A, B>, bc: AsyncOrSync<Awaited<B>, R>): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, R>
+): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, D, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, R>
+): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, D, E, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, R>
+): (a: A) => Promise<Awaited<R>>;
+
+function pipeAsync<Fns extends [AsyncOrSync<any, any>, ...AsyncOrSync<any, any>[]]>(...funcs: Fns): PipeAsync<Fns>;
+function pipeAsync(...funcs: Array<AsyncOrSync<any, any>>): (value: any) => Promise<any>;
+function pipeAsync(...funcs: Array<(arg: any) => any>) {
+  return async (value: any) => {
+    let acc = value;
+    for (const fn of funcs) {
+      acc = await fn(acc);
+    }
+    return acc;
+  };
+}
+
+export default pipeAsync;

package/src/implement/async/pipeAsyncSideEffect.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import pipeAsyncSideEffect from './pipeAsyncSideEffect';
+import SideEffect from '../composition/sideEffect';
+
+describe('pipeAsyncSideEffect', () => {
+  it('short-circuits when SideEffect is returned', async () => {
+    const effect = new SideEffect(() => 'effect');
+    const stop = async (_value: number) => effect;
+    const after = async (_value: number) => _value + 1;
+
+    const fn = pipeAsyncSideEffect(async (n: number) => n + 1, stop, after);
+    const result = await fn(1);
+
+    expect(result).toBe(effect);
+  });
+
+  it('returns SideEffect inputs without executing the pipeline', async () => {
+    const effect = new SideEffect(() => 'effect');
+    const fn = pipeAsyncSideEffect(async (n: number) => n + 1);
+
+    await expect(fn(effect)).resolves.toBe(effect);
+  });
+});