fp-pack 0.1.0

package/src/implement/async/pipeAsyncSideEffect.ts

@@ -0,0 +1,68 @@
+import SideEffect, { isSideEffect } from '../composition/sideEffect';
+
+/** pipeAsyncSideEffect - SideEffect를 허용하는 비동기 함수 합성 */
+type MaybeSideEffect<T> = T | SideEffect<any>;
+type NonSideEffect<T> = Exclude<T, SideEffect<any>>;
+type AsyncOrSync<A, R> = (a: A) => MaybeSideEffect<R> | Promise<MaybeSideEffect<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>]
+  ? MaybeSideEffect<Awaited<R>>
+  : Fns extends [AsyncOrSync<any, infer R>, ...infer Rest]
+    ? Rest extends [AsyncOrSync<Awaited<NonSideEffect<R>>, any>, ...AsyncOrSync<any, any>[]]
+      ? PipeOutput<Rest>
+      : never
+    : never;
+type Resolve<T> = T extends infer R ? R : never;
+type PipeAsyncSideEffect<Fns extends AsyncOrSync<any, any>[]> = (
+  input: PipeInput<Fns> | SideEffect<any>
+) => Promise<Resolve<PipeOutput<Fns>>>;
+
+function pipeAsyncSideEffect<A, R>(
+  ab: AsyncOrSync<A, R>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<A, B, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<Awaited<B>, R>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<A, B, C, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, R>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<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 | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<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 | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+
+function pipeAsyncSideEffect<Fns extends [AsyncOrSync<any, any>, ...AsyncOrSync<any, any>[]]>(
+  ...funcs: Fns
+): PipeAsyncSideEffect<Fns>;
+function pipeAsyncSideEffect(...funcs: Array<AsyncOrSync<any, any>>): (value: any) => Promise<any>;
+function pipeAsyncSideEffect(...funcs: Array<(arg: any) => any>) {
+  return async (value: any) => {
+    let acc = value;
+    for (const fn of funcs) {
+      if (isSideEffect(acc)) {
+        return acc;
+      }
+      acc = await fn(acc);
+    }
+    return acc;
+  };
+}
+
+export default pipeAsyncSideEffect;

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

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from 'vitest';
+import retry from './retry';
+
+describe('retry', () => {
+  it('retries until success', async () => {
+    let count = 0;
+    const fn = vi.fn(async () => {
+      count += 1;
+      if (count < 3) throw new Error('fail');
+      return 'ok';
+    });
+
+    await expect(retry<string>(5, fn)).resolves.toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  it('fails after max retries', async () => {
+    const fn = vi.fn(async () => {
+      throw new Error('always');
+    });
+
+    await expect(retry(2, fn)).rejects.toThrow('always');
+    expect(fn).toHaveBeenCalledTimes(3); // initial + 2 retries
+  });
+
+  it('waits between retries when delayMs is provided', async () => {
+    vi.useFakeTimers();
+    const fn = vi
+      .fn(async () => 'ok' as const)
+      .mockRejectedValueOnce(new Error('fail1'))
+      .mockRejectedValueOnce(new Error('fail2'));
+
+    const promise = retry(2, fn, 50);
+
+    // first call, then schedule delay before second attempt
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    // finish first delay -> second attempt
+    await vi.advanceTimersByTimeAsync(50);
+    expect(fn).toHaveBeenCalledTimes(2);
+
+    // finish second delay -> third attempt (success)
+    await vi.advanceTimersByTimeAsync(50);
+    await promise;
+    expect(fn).toHaveBeenCalledTimes(3);
+
+    vi.useRealTimers();
+  });
+});

package/src/implement/async/retry.ts

@@ -0,0 +1,27 @@
+/** retry - 실패 시 재시도 (옵션 대기 시간 포함) */
+import delay from './delay';
+import curry from '../composition/curry';
+
+type Retry = {
+  (times: number): <T>(fn: () => Promise<T>, delayMs?: number) => Promise<T>;
+  <T>(...args: [times: number, fn: () => Promise<T>, delayMs?: number]): Promise<T>;
+};
+
+function retry<T>(times: number, fn: () => Promise<T>, delayMs = 0): Promise<T> {
+  return (async () => {
+    let attempt = 0;
+    while (true) {
+      try {
+        return await fn();
+      } catch (err) {
+        attempt += 1;
+        if (attempt > times) throw err;
+        if (delayMs > 0) {
+          await delay(delayMs);
+        }
+      }
+    }
+  })();
+}
+const curriedRetry = curry(retry) as Retry;
+export default curriedRetry;

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

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi } from 'vitest';
+import throttle from './throttle';
+
+describe('throttle', () => {
+  it('invokes immediately and then throttles', async () => {
+    vi.useFakeTimers();
+    const spy = vi.fn();
+    const fn = throttle(spy, 100);
+
+    fn();
+    fn();
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    vi.advanceTimersByTime(100);
+    await Promise.resolve();
+    expect(spy).toHaveBeenCalledTimes(2); // trailing
+    vi.useRealTimers();
+  });
+
+  it('drops intermediate calls and runs trailing once', async () => {
+    vi.useFakeTimers();
+    const spy = vi.fn();
+    const fn = throttle(spy, 50);
+
+    fn(1);
+    fn(2);
+    fn(3);
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith(1);
+
+    vi.advanceTimersByTime(50);
+    await Promise.resolve();
+    expect(spy).toHaveBeenCalledTimes(2);
+    expect(spy).toHaveBeenCalledWith(3); // trailing call
+
+    vi.useRealTimers();
+  });
+});

package/src/implement/async/throttle.ts

@@ -0,0 +1,47 @@
+import curry from '../composition/curry';
+
+type Throttle = {
+  <T extends (...args: any[]) => any>(...args: [fn: T]): (ms: number) => T;
+  <T extends (...args: any[]) => any>(...args: [fn: T, ms: number]): T;
+};
+
+/** throttle - 호출 제어 (쓰로틀) */
+function throttle<T extends (...args: any[]) => any>(fn: T, ms: number): T {
+  let lastCall = 0;
+  let trailingArgs: any[] | null = null;
+  let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+  const invoke = (ctx: any, args: any[]) => {
+    lastCall = Date.now();
+    fn.apply(ctx, args);
+  };
+
+  const throttled = function (this: any, ...args: any[]) {
+    const now = Date.now();
+    const remaining = ms - (now - lastCall);
+
+    if (remaining <= 0) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      trailingArgs = null;
+      invoke(this, args);
+    } else {
+      trailingArgs = args;
+      if (!timeoutId) {
+        timeoutId = setTimeout(() => {
+          timeoutId = null;
+          if (trailingArgs) {
+            invoke(this, trailingArgs);
+            trailingArgs = null;
+          }
+        }, remaining);
+      }
+    }
+  } as T;
+
+  return throttled;
+}
+const curriedThrottle = curry(throttle) as Throttle;
+export default curriedThrottle;

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

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import timeout from './timeout';
+
+describe('timeout', () => {
+  it('resolves when promise finishes before timeout', async () => {
+    const result = await timeout<string>(50, Promise.resolve('ok'));
+    expect(result).toBe('ok');
+  });
+
+  it('rejects when promise exceeds timeout', async () => {
+    await expect(
+      timeout(
+        10,
+        new Promise((resolve) => {
+          setTimeout(() => resolve('late'), 30);
+        })
+      )
+    ).rejects.toThrow('Timed out after 10ms');
+  });
+});

package/src/implement/async/timeout.ts

@@ -0,0 +1,24 @@
+import curry from '../composition/curry';
+
+type Timeout = {
+  (ms: number): <T>(promise: Promise<T>) => Promise<T>;
+  <T>(...args: [ms: number, promise: Promise<T>]): Promise<T>;
+};
+
+/** timeout - 제한 시간 내 실행 */
+function timeout<T>(ms: number, promise: Promise<T>): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Timed out after ${ms}ms`)), ms);
+    promise
+      .then((val) => {
+        clearTimeout(timer);
+        resolve(val);
+      })
+      .catch((err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+  });
+}
+const curriedTimeout = curry(timeout) as Timeout;
+export default curriedTimeout;

package/src/implement/composition/complement.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import complement from './complement';
+
+describe('complement', () => {
+  it('negates predicate results', () => {
+    const isEven = (n: number) => n % 2 === 0;
+    expect(complement(isEven, 2)).toBe(false);
+    expect(complement(isEven, 3)).toBe(true);
+  });
+
+  it('supports data-last usage', () => {
+    const isEven = (n: number) => n % 2 === 0;
+    const isOdd = complement(isEven);
+    expect(isOdd(1)).toBe(true);
+    expect(isOdd(2)).toBe(false);
+  });
+});

package/src/implement/composition/complement.ts

@@ -0,0 +1,13 @@
+/**
+ * complement - 조건 함수 반전
+ */
+function complement<T extends any[]>(predicate: (...args: T) => boolean): (...args: T) => boolean;
+function complement<T extends any[]>(predicate: (...args: T) => boolean, ...args: T): boolean;
+function complement<T extends any[]>(predicate: (...args: T) => boolean, ...args: T) {
+  if (args.length === 0) {
+    return (...nextArgs: T) => !predicate(...nextArgs);
+  }
+  return !predicate(...args);
+}
+
+export default complement;

package/src/implement/composition/compose.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import compose from './compose';
+
+describe('compose', () => {
+  it('applies functions right-to-left', () => {
+    const double = (n: number) => n * 2;
+    const addOne = (n: number) => n + 1;
+
+    const fn = compose(double, addOne);
+    expect(fn(3)).toBe(8); // double(addOne(3))
+  });
+
+  it('supports mixed types across the chain', () => {
+    const toString = (n: number) => `${n}`;
+    const trim = (s: string) => s.trim();
+    const length = (s: string) => s.length;
+    const isLong = (len: number) => len > 2;
+
+    const fn = compose(isLong, length, trim, toString);
+    expect(fn(123)).toBe(true);
+    expect(fn(5)).toBe(false);
+  });
+
+  it('works with a single function', () => {
+    const square = (n: number) => n * n;
+    const fn = compose(square);
+    expect(fn(4)).toBe(16);
+  });
+
+});

package/src/implement/composition/compose.ts

@@ -0,0 +1,48 @@
+/**
+ * compose - 함수를 우→좌로 합성
+ */
+
+type UnaryFn<A, R> = (a: A) => R;
+type ComposeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [...UnaryFn<any, any>[], UnaryFn<infer A, any>]
+  ? A
+  : never;
+type ComposeChain<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, infer R>]
+  ? UnaryFn<A, R>
+  : Fns extends [UnaryFn<infer A, infer R>, ...infer Rest]
+    ? Rest extends [UnaryFn<R, any>, ...UnaryFn<any, any>[]]
+      ? ComposeChain<Rest> extends UnaryFn<any, infer NextR>
+        ? UnaryFn<A, NextR>
+        : never
+      : never
+    : never;
+type Compose<Fns extends UnaryFn<any, any>[]> = (input: ComposeInput<Fns>) => ComposeChain<Fns> extends UnaryFn<
+  any,
+  infer R
+>
+  ? R
+  : never;
+
+function compose<A, R>(ab: UnaryFn<A, R>): (a: A) => R;
+function compose<A, B, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, R>): (a: A) => R;
+function compose<A, B, C, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, R>): (a: A) => R;
+function compose<A, B, C, D, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, R>
+): (a: A) => R;
+function compose<A, B, C, D, E, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, R>
+): (a: A) => R;
+
+function compose<Fns extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): Compose<Fns>;
+function compose(...funcs: Array<UnaryFn<any, any>>): (input: any) => any;
+function compose(...funcs: Array<(input: any) => any>) {
+  return (value: any) => funcs.reduceRight((acc, fn) => fn(acc), value);
+}
+
+export default compose;

package/src/implement/composition/constant.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import constant from './constant';
+
+describe('constant', () => {
+  it('returns a function that always returns the same value', () => {
+    const alwaysFive = constant(5);
+    expect(alwaysFive()).toBe(5);
+    expect(alwaysFive()).toBe(5);
+  });
+
+  it('preserves reference identity', () => {
+    const obj = { a: 1 };
+    const alwaysObj = constant(obj);
+    expect(alwaysObj()).toBe(obj);
+  });
+});

package/src/implement/composition/constant.ts

@@ -0,0 +1,8 @@
+/**
+ * constant (always) - 항상 같은 값을 반환
+ */
+function constant<T>(value: T): () => T {
+  return () => value;
+}
+
+export default constant;

package/src/implement/composition/curry.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import curry from './curry';
+
+describe('curry', () => {
+  it('curries a binary function', () => {
+    const add = (a: number, b: number) => a + b;
+    const curriedAdd = curry(add);
+
+    expect(curriedAdd(1, 2)).toBe(3);
+    expect(curriedAdd(1)(2)).toBe(3);
+  });
+
+  it('curries a ternary function across multiple calls', () => {
+    const combine = (a: string, b: string, c: string) => `${a}-${b}-${c}`;
+    const curriedCombine = curry(combine);
+
+    expect(curriedCombine('x')('y')('z')).toBe('x-y-z');
+    expect(curriedCombine('x', 'y')('z')).toBe('x-y-z');
+  });
+
+  it('reuses partial applications', () => {
+    const sum3 = (a: number, b: number, c: number) => a + b + c;
+    const curried = curry(sum3);
+
+    const addOne = curried(1);
+    const addOneAndTwo = addOne(2);
+
+    expect(addOneAndTwo(3)).toBe(6);
+    expect(addOneAndTwo(5)).toBe(8);
+  });
+});

package/src/implement/composition/curry.ts

@@ -0,0 +1,71 @@
+/**
+ * Curry function with stable TypeScript types.
+ * Supports functions with 2-5 parameters and keeps data-last call order.
+ */
+
+type Curry2<Fn> = Fn extends (a: infer A, b: infer B) => infer R
+  ? {
+      (...args: [A]): (b: B) => R;
+      (...args: [A, B]): R;
+    }
+  : never;
+
+type Curry3<Fn> = Fn extends (a: infer A, b: infer B, c: infer C) => infer R
+  ? {
+      (...args: [A]): (b: B) => (c: C) => R;
+      (...args: [A, B]): (c: C) => R;
+      (...args: [A, B, C]): R;
+    }
+  : never;
+
+type Curry4<Fn> = Fn extends (a: infer A, b: infer B, c: infer C, d: infer D) => infer R
+  ? {
+      (...args: [A]): (b: B) => (c: C) => (d: D) => R;
+      (...args: [A, B]): (c: C) => (d: D) => R;
+      (...args: [A, B, C]): (d: D) => R;
+      (...args: [A, B, C, D]): R;
+    }
+  : never;
+
+type Curry5<Fn> = Fn extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E) => infer R
+  ? {
+      (...args: [A]): (b: B) => (c: C) => (d: D) => (e: E) => R;
+      (...args: [A, B]): (c: C) => (d: D) => (e: E) => R;
+      (...args: [A, B, C]): (d: D) => (e: E) => R;
+      (...args: [A, B, C, D]): (e: E) => R;
+      (...args: [A, B, C, D, E]): R;
+    }
+  : never;
+
+type CurryVariadic<Fn extends (...args: any[]) => any> = Fn extends (...args: infer P) => infer R
+  ? <T extends any[]>(
+      ...args: T
+    ) => T extends P ? R : P extends [...T, ...infer Rest] ? CurryVariadic<(...args: Rest) => R> : never
+  : never;
+
+type CurryByArity<Fn extends (...args: any[]) => any> = Parameters<Fn>['length'] extends 2
+  ? Curry2<Fn>
+  : Parameters<Fn>['length'] extends 3
+    ? Curry3<Fn>
+    : Parameters<Fn>['length'] extends 4
+      ? Curry4<Fn>
+      : Parameters<Fn>['length'] extends 5
+        ? Curry5<Fn>
+        : CurryVariadic<Fn>;
+
+type Curried<Fn extends (...args: any[]) => any> = CurryByArity<Fn>;
+
+function curry<Fn extends (...args: any[]) => any>(fn: Fn): Curried<Fn>;
+
+// Implementation
+function curry(fn: (...args: any[]) => any, ...args: any[]): any {
+  const curried = (accumulated: any[]) => {
+    return accumulated.length >= fn.length
+      ? fn(...accumulated)
+      : (...nextArgs: any[]) => curried([...accumulated, ...nextArgs]);
+  };
+
+  return args.length === 0 ? curried([]) : curried(args);
+}
+
+export default curry;

package/src/implement/composition/flip.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import flip from './flip';
+
+describe('flip', () => {
+  it('swaps the first two arguments of a binary function', () => {
+    const divide = (a: number, b: number) => a / b;
+    const flipped = flip(divide);
+
+    expect(flipped(2, 10)).toBe(5); // divide(10, 2)
+  });
+
+  it('reverses arguments for 3-arity functions', () => {
+    const concat = (a: string | number, b: string | number, c: string | number) => `${a}-${b}-${c}`;
+    const flipped = flip(concat);
+
+    expect(flipped(1, 'b', 'a')).toBe('a-b-1');
+  });
+
+  it('preserves this binding when used with call/apply', () => {
+    const obj = {
+      base: 10,
+      fn(this: { base: number }, a: number, b: number) {
+        return this.base + a - b;
+      },
+    };
+
+    const flipped = flip(obj.fn);
+    expect(flipped.call(obj, 2, 5)).toBe(13); // base + 5 - 2
+  });
+
+  it('supports 4-5 arity with reversed order', () => {
+    const format4 = (a: string, b: string, c: string, d: string) => `${a}-${b}-${c}-${d}`;
+    const flipped4 = flip(format4);
+    expect(flipped4('4', '3', '2', '1')).toBe('1-2-3-4');
+
+    const format5 = (a: number, b: number, c: number, d: number, e: number) => a + b * 2 + c * 3 + d * 4 + e * 5;
+    const flipped5 = flip(format5);
+    // reversed args: 5,4,3,2,1 => 5 + 4*2 + 3*3 + 2*4 + 1*5 = 5 + 8 + 9 + 8 + 5 = 35
+    expect(flipped5(1, 2, 3, 4, 5)).toBe(35);
+  });
+});

package/src/implement/composition/flip.ts

@@ -0,0 +1,16 @@
+/**
+ * flip - 함수 인자 순서를 뒤집음
+ */
+function flip<A, B, R>(fn: (a: A, b: B) => R): (b: B, a: A) => R;
+function flip<A, B, C, R>(fn: (a: A, b: B, c: C) => R): (c: C, b: B, a: A) => R;
+function flip<A, B, C, D, R>(fn: (a: A, b: B, c: C, d: D) => R): (d: D, c: C, b: B, a: A) => R;
+function flip<A, B, C, D, E, R>(fn: (a: A, b: B, c: C, d: D, e: E) => R): (e: E, d: D, c: C, b: B, a: A) => R;
+function flip<R>(fn: (...args: any[]) => R): (...reversed: any[]) => R;
+function flip<R>(fn: (...args: any[]) => R) {
+  return function flipped(this: unknown, ...args: any[]) {
+    const reversed = [...args].reverse();
+    return fn.apply(this, reversed);
+  };
+}
+
+export default flip;

package/src/implement/composition/identity.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import identity from './identity';
+
+describe('identity', () => {
+  it('returns the same value', () => {
+    expect(identity(5)).toBe(5);
+    expect(identity('fp')).toBe('fp');
+  });
+
+  it('preserves reference identity', () => {
+    const obj = { a: 1 };
+    expect(identity(obj)).toBe(obj);
+  });
+});

package/src/implement/composition/identity.ts

@@ -0,0 +1,8 @@
+/**
+ * identity (id) - 입력을 그대로 반환
+ */
+function identity<T>(x: T): T {
+  return x;
+}
+
+export default identity;

package/src/implement/composition/index.ts

@@ -0,0 +1,15 @@
+export { default as pipe } from './pipe';
+export { default as pipeSideEffect } from './pipeSideEffect';
+export { default as compose } from './compose';
+export { default as curry } from './curry';
+export { default as partial } from './partial';
+export { default as flip } from './flip';
+export { default as complement } from './complement';
+export { default as identity } from './identity';
+export { default as constant } from './constant';
+export { default as tap } from './tap';
+export { default as once } from './once';
+export { default as memoize } from './memoize';
+export { default as SideEffect } from './sideEffect';
+export { SideEffect as SideEffectClass } from './sideEffect';
+export { isSideEffect, matchSideEffect, runPipeResult } from './sideEffect';

package/src/implement/composition/memoize.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi } from 'vitest';
+import memoize from './memoize';
+
+describe('memoize', () => {
+  it('caches results for identical args', () => {
+    const spy = vi.fn((a: number, b: number) => a + b);
+    const m = memoize(spy);
+
+    expect(m(1, 2)).toBe(3);
+    expect(m(1, 2)).toBe(3);
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('distinguishes different args', () => {
+    const spy = vi.fn((a: number, b: number) => a * b);
+    const m = memoize(spy);
+
+    expect(m(2, 3)).toBe(6);
+    expect(m(3, 2)).toBe(6);
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  it('respects reference equality for object args', () => {
+    const spy = vi.fn((obj: { v: number }) => obj.v * 2);
+    const m = memoize(spy);
+
+    const ref = { v: 5 };
+    expect(m(ref)).toBe(10);
+    expect(m(ref)).toBe(10);
+    expect(m({ v: 5 })).toBe(10);
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  it('preserves this binding', () => {
+    const ctx = {
+      factor: 10,
+      fn(this: { factor: number }, x: number) {
+        return this.factor + x;
+      },
+    };
+
+    const m = memoize(ctx.fn);
+    expect(m.call(ctx, 5)).toBe(15);
+    expect(m.call(ctx, 5)).toBe(15);
+  });
+});