fp-pack 0.1.0

package/src/implement/composition/memoize.ts

@@ -0,0 +1,31 @@
+/**
+ * memoize - 동일 입력에 대해 결과 캐싱
+ */
+type AnyFn = (...args: any[]) => any;
+
+function memoize<T extends AnyFn>(fn: T): T {
+  const cache = new Map<any, any>();
+  const RESULT = Symbol('result');
+
+  const memoized = function (this: any, ...args: any[]) {
+    let node = cache;
+    for (const arg of args) {
+      if (!node.has(arg)) {
+        node.set(arg, new Map());
+      }
+      node = node.get(arg);
+    }
+
+    if (node.has(RESULT)) {
+      return node.get(RESULT);
+    }
+
+    const value = fn.apply(this, args);
+    node.set(RESULT, value);
+    return value;
+  };
+
+  return memoized as T;
+}
+
+export default memoize;

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

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi } from 'vitest';
+import once from './once';
+
+describe('once', () => {
+  it('only calls the function once', () => {
+    const spy = vi.fn((n: number) => n * 2);
+    const o = once(spy);
+
+    expect(o(2)).toBe(4);
+    expect(o(3)).toBe(4);
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('preserves this binding', () => {
+    const ctx = { base: 5, fn(this: { base: number }, v: number) { return this.base + v; } };
+    const o = once(ctx.fn);
+
+    expect(o.call(ctx, 2)).toBe(7);
+    expect(o.call(ctx, 100)).toBe(7);
+  });
+
+  it('memoizes the first return value even if it is undefined', () => {
+    const spy = vi.fn(() => undefined);
+    const o = once(spy);
+
+    expect(o()).toBeUndefined();
+    expect(o()).toBeUndefined();
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/implement/composition/once.ts

@@ -0,0 +1,21 @@
+/**
+ * once - 한 번만 실행되는 함수
+ */
+type AnyFn = (...args: any[]) => any;
+
+function once<T extends AnyFn>(fn: T): T {
+  let called = false;
+  let value: any;
+
+  const wrapped = function (this: any, ...args: any[]) {
+    if (!called) {
+      called = true;
+      value = fn.apply(this, args);
+    }
+    return value;
+  };
+
+  return wrapped as T;
+}
+
+export default once;

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

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import partial from './partial';
+
+describe('partial', () => {
+  it('binds leading arguments', () => {
+    const add = (a: number, b: number, c: number) => a + b + c;
+    const addOne = partial(add, 1);
+    const addOneTwo = partial(add, 1, 2);
+
+    expect(addOne(2, 3)).toBe(6);
+    expect(addOneTwo(3)).toBe(6);
+  });
+
+  it('preserves this binding', () => {
+    const ctx = { base: 10, fn(this: { base: number }, a: number, b: number) { return this.base + a + b; } };
+    const addWithBase = partial(ctx.fn, 1);
+    expect(addWithBase.call(ctx, 2)).toBe(13);
+  });
+
+  it('works with no preset arguments', () => {
+    const mul = (a: number, b: number) => a * b;
+    const same = partial(mul);
+    expect(same(2, 4)).toBe(8);
+  });
+});

package/src/implement/composition/partial.ts

@@ -0,0 +1,14 @@
+/**
+ * partial - 인자를 미리 고정한 함수 생성
+ */
+function partial<Args extends any[], Rest extends any[], R>(
+  fn: (...args: [...Args, ...Rest]) => R,
+  ...preset: Args
+): (...rest: Rest) => R {
+  return function partiallyApplied(this: unknown, ...rest: Rest) {
+    const all = [...preset, ...rest] as [...Args, ...Rest];
+    return fn.apply(this as any, all);
+  };
+}
+
+export default partial;

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

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import pipe from './pipe';
+
+describe('pipe', () => {
+  it('applies functions left-to-right', () => {
+    const addOne = (n: number) => n + 1;
+    const double = (n: number) => n * 2;
+    const toString = (n: number) => `${n}`;
+
+    const fn = pipe(addOne, double, toString);
+    expect(fn(3)).toBe('8'); // (3 + 1) * 2 => 8
+  });
+
+  it('supports mixed types through the chain', () => {
+    const trim = (s: string) => s.trim();
+    const splitComma = (s: string) => s.split(',');
+    const count = (arr: any[]) => arr.length;
+    const isMoreThanTwo = (n: number) => n > 2;
+
+    const fn = pipe(trim, splitComma, count, isMoreThanTwo);
+    expect(fn('a, b, c')).toBe(true);
+    expect(fn('x, y')).toBe(false);
+  });
+
+  it('works with a single function', () => {
+    const square = (n: number) => n * n;
+    const fn = pipe(square);
+    expect(fn(5)).toBe(25);
+  });
+
+});

package/src/implement/composition/pipe.ts

@@ -0,0 +1,39 @@
+type UnaryFn<A, R> = (a: A) => R;
+type PipeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, any>, ...UnaryFn<any, any>[]]
+  ? A
+  : never;
+type PipeOutput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<any, infer R>]
+  ? R
+  : Fns extends [UnaryFn<any, infer R>, ...infer Rest]
+    ? Rest extends [UnaryFn<R, any>, ...UnaryFn<any, any>[]]
+      ? PipeOutput<Rest>
+      : never
+    : never;
+type Pipe<Fns extends UnaryFn<any, any>[]> = (input: PipeInput<Fns>) => PipeOutput<Fns>;
+
+function pipe<A, R>(ab: UnaryFn<A, R>): (a: A) => R;
+function pipe<A, B, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, R>): (a: A) => R;
+function pipe<A, B, C, R>(ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, R>): (a: A) => R;
+function pipe<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 pipe<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 pipe<Fns extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): Pipe<Fns>;
+function pipe(...funcs: Array<UnaryFn<any, any>>): (input: any) => any;
+function pipe(...funcs: Array<(input: any) => any>) {
+  return (init: any) => {
+    return funcs.reduce((acc, fn) => fn(acc), init);
+  };
+}
+
+export default pipe;

package/src/implement/composition/pipe.type-test.ts

@@ -0,0 +1,54 @@
+import SideEffect from './sideEffect';
+import pipe from './pipe';
+import pipeSideEffect from './pipeSideEffect';
+import pipeAsync from '../async/pipeAsync';
+import pipeAsyncSideEffect from '../async/pipeAsyncSideEffect';
+
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+  ? true
+  : false;
+type Expect<T extends true> = T;
+
+export const sideEffectInput = SideEffect.of(() => 0);
+
+export const purePipe = pipe(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => `n:${value}`
+);
+
+type PurePipeExpected = (input: number) => string;
+export type PipePureIsStrict = Expect<Equal<typeof purePipe, PurePipeExpected>>;
+
+export const pipeWithSideEffectInput = pipeSideEffect(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => `n:${value}`
+);
+
+export const pipeWithSideEffectValue = pipeWithSideEffectInput(sideEffectInput);
+
+type PipeExpected = (input: number | SideEffect<any>) => string | SideEffect<any>;
+export type PipeAcceptsSideEffectInput = Expect<Equal<typeof pipeWithSideEffectInput, PipeExpected>>;
+
+export const purePipeAsync = pipeAsync(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => `n:${value}`
+);
+
+type PurePipeAsyncExpected = (input: number) => Promise<string>;
+export type PipeAsyncPureIsStrict = Expect<Equal<typeof purePipeAsync, PurePipeAsyncExpected>>;
+
+export const pipeAsyncWithSideEffectInput = pipeAsyncSideEffect(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => `n:${value}`
+);
+
+export const pipeAsyncWithSideEffectValue = pipeAsyncWithSideEffectInput(sideEffectInput);
+
+type PipeAsyncExpected = (input: number | SideEffect<any>) => Promise<string | SideEffect<any>>;
+export type PipeAsyncAcceptsSideEffectInput = Expect<
+  Equal<typeof pipeAsyncWithSideEffectInput, PipeAsyncExpected>
+>;

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

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

package/src/implement/composition/pipeSideEffect.ts

@@ -0,0 +1,60 @@
+import SideEffect, { isSideEffect } from './sideEffect';
+
+type MaybeSideEffect<T> = T | SideEffect<any>;
+type NonSideEffect<T> = Exclude<T, SideEffect<any>>;
+type UnaryFn<A, R> = (a: A) => MaybeSideEffect<R>;
+type PipeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, any>, ...UnaryFn<any, any>[]]
+  ? A
+  : never;
+type PipeOutput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<any, infer R>]
+  ? MaybeSideEffect<R>
+  : Fns extends [UnaryFn<any, infer R>, ...infer Rest]
+    ? Rest extends [UnaryFn<NonSideEffect<R>, any>, ...UnaryFn<any, any>[]]
+      ? PipeOutput<Rest>
+      : never
+    : never;
+type Resolve<T> = T extends infer R ? R : never;
+type PipeSideEffect<Fns extends UnaryFn<any, any>[]> = (
+  input: PipeInput<Fns> | SideEffect<any>
+) => Resolve<PipeOutput<Fns>>;
+
+function pipeSideEffect<A, R>(ab: UnaryFn<A, R>): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<A, B, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, R>
+): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<A, B, C, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, R>
+): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<A, B, C, D, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, R>
+): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<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 | SideEffect<any>) => MaybeSideEffect<R>;
+
+function pipeSideEffect<Fns extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): PipeSideEffect<Fns>;
+function pipeSideEffect(...funcs: Array<UnaryFn<any, any>>): (input: any) => any;
+function pipeSideEffect(...funcs: Array<(input: any) => any>) {
+  return (init: any) => {
+    let acc = init;
+    for (const fn of funcs) {
+      if (isSideEffect(acc)) {
+        return acc;
+      }
+      acc = fn(acc);
+    }
+    return acc;
+  };
+}
+
+export default pipeSideEffect;

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

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi } from 'vitest';
+import SideEffect, { matchSideEffect, runPipeResult } from './sideEffect';
+
+describe('SideEffect', () => {
+  it('does not execute effect automatically', () => {
+    const effect = vi.fn(() => 'done');
+    const sideEffect = SideEffect.of(effect);
+
+    expect(effect).not.toHaveBeenCalled();
+    expect(sideEffect).toBeInstanceOf(SideEffect);
+  });
+
+  it('stores an optional label', () => {
+    const effect = () => 'ok';
+    const sideEffect = SideEffect.of(effect, 'TEST_LABEL');
+
+    expect(sideEffect.label).toBe('TEST_LABEL');
+  });
+
+  it('matchSideEffect routes values', () => {
+    const effect = new SideEffect(() => 'run');
+    const valueResult = matchSideEffect(3, {
+      value: (v) => v + 1,
+      effect: () => 0,
+    });
+    const effectResult = matchSideEffect(effect, {
+      value: () => 0,
+      effect: (s) => s,
+    });
+
+    expect(valueResult).toBe(4);
+    expect(effectResult).toBe(effect);
+  });
+
+  it('runPipeResult executes SideEffect explicitly', () => {
+    const effect = vi.fn(() => 'ran');
+    const sideEffect = SideEffect.of(effect);
+
+    expect(runPipeResult(sideEffect)).toBe('ran');
+    expect(runPipeResult(5)).toBe(5);
+    expect(effect).toHaveBeenCalledTimes(1);
+  });
+});

package/src/implement/composition/sideEffect.ts

@@ -0,0 +1,44 @@
+/**
+ * SideEffect - side effect container (never auto-executed)
+ */
+export class SideEffect<T = unknown> {
+  readonly effect: () => T;
+  readonly label?: string;
+
+  constructor(effect: () => T, label?: string) {
+    this.effect = effect;
+    this.label = label;
+  }
+
+  static of<T>(effect: () => T, label?: string): SideEffect<T> {
+    return new SideEffect(effect, label);
+  }
+}
+
+type MatchHandlers<T, RValue, REffect> = {
+  value: (value: T) => RValue;
+  effect: (sideEffect: SideEffect) => REffect;
+};
+
+export function matchSideEffect<T, RValue, REffect = any>(
+  result: T | SideEffect,
+  handlers: MatchHandlers<T, RValue, REffect>
+): RValue | REffect {
+  if (result instanceof SideEffect) {
+    return handlers.effect(result);
+  }
+  return handlers.value(result as T);
+}
+
+export function runPipeResult<T, R=any>(result: T | SideEffect<R>): T | R {
+  if (isSideEffect(result)) {
+    return result.effect() as R;
+  }
+  return result as T;
+}
+
+export function isSideEffect(value: unknown): value is SideEffect<any> {
+  return value instanceof SideEffect;
+}
+
+export default SideEffect;

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

@@ -0,0 +1,17 @@
+import { vi, describe, it, expect } from 'vitest';
+import tap from './tap';
+
+describe('tap', () => {
+  it('passes through the value unchanged', () => {
+    const result = tap(() => {})(42);
+    expect(result).toBe(42);
+  });
+
+  it('runs the side effect with the value', () => {
+    const spy = vi.fn();
+    const result = tap(spy)('hello');
+
+    expect(spy).toHaveBeenCalledWith('hello');
+    expect(result).toBe('hello');
+  });
+});

package/src/implement/composition/tap.ts

@@ -0,0 +1,11 @@
+/**
+ * tap - 값을 그대로 흘리며 side-effect 실행
+ */
+function tap<T>(fn: (value: T) => void): (value: T) => T {
+  return (value: T) => {
+    fn(value);
+    return value;
+  };
+}
+
+export default tap;

package/src/implement/control/cond.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import cond from './cond';
+
+describe('cond', () => {
+  it('returns the first matching branch', () => {
+    const fn = cond<number, string>([
+      [(n) => n > 10, () => 'big'],
+      [(n) => n > 0, () => 'small'],
+    ]);
+
+    expect(fn(5)).toBe('small');
+    expect(fn(11)).toBe('big');
+  });
+
+  it('returns undefined when no predicate matches', () => {
+    const fn = cond<number, string>([
+      [(n) => n < 0, () => 'neg'],
+      [(n) => n > 5, () => 'gt5'],
+    ]);
+
+    expect(fn(0)).toBeUndefined();
+  });
+
+  it('passes the original value to handler', () => {
+    const fn = cond<number, number>([
+      [(n) => n % 2 === 0, (n) => n * 2],
+      [() => true, (n) => n + 1],
+    ]);
+
+    expect(fn(4)).toBe(8);
+    expect(fn(3)).toBe(4);
+  });
+});

package/src/implement/control/cond.ts

@@ -0,0 +1,17 @@
+/**
+ * cond - 다중 조건 분기 (switch 대체)
+ */
+function cond<T, R>(
+  conditions: Array<[(value: T) => boolean, (value: T) => R]>
+): (value: T) => R | undefined {
+  return (value: T) => {
+    for (const [predicate, handler] of conditions) {
+      if (predicate(value)) {
+        return handler(value);
+      }
+    }
+    return undefined;
+  };
+}
+
+export default cond;

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

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import guard from './guard';
+import ifElse from './ifElse';
+import tryCatch from './tryCatch';
+import unless from './unless';
+import when from './when';
+
+describe('control (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(guard((value: number) => value > 0, 0, -1)).toBe(0);
+    expect(guard((value: number) => value > 0, 0, 2)).toBe(2);
+
+    const guardPositive = guard((value: number) => value > 0)(0);
+    expect(guardPositive(-1)).toBe(0);
+    expect(guardPositive(2)).toBe(2);
+
+    expect(
+      ifElse(
+        (value: number) => value > 0,
+        (value: number) => value * 2,
+        (value: number) => value - 2,
+        2
+      )
+    ).toBe(4);
+    expect(
+      ifElse(
+        (value: number) => value > 0,
+        (value: number) => value * 2,
+        (value: number) => value - 2,
+        -1
+      )
+    ).toBe(-3);
+
+    const choose = ifElse((value: number) => value > 0)((value: number) => value * 2)((value: number) => value - 2);
+    expect(choose(2)).toBe(4);
+    expect(choose(-1)).toBe(-3);
+
+    expect(
+      tryCatch(
+        (value: string) => JSON.parse(value) as { ok: boolean },
+        () => ({ ok: false }),
+        '{"ok":true}'
+      )
+    ).toEqual({ ok: true });
+    expect(
+      tryCatch(
+        (value: string) => JSON.parse(value) as { ok: boolean },
+        () => ({ ok: false }),
+        'bad'
+      )
+    ).toEqual({ ok: false });
+
+    const safeParse = tryCatch((value: string) => JSON.parse(value) as { ok: boolean })(() => ({ ok: false }));
+    expect(safeParse('{"ok":true}')).toEqual({ ok: true });
+    expect(safeParse('bad')).toEqual({ ok: false });
+
+    expect(unless((value: number) => value > 10, (value: number) => value + 1, 5)).toBe(6);
+    expect(unless((value: number) => value > 10, (value: number) => value + 1, 20)).toBe(20);
+
+    const applyUnless = unless((value: number) => value > 10)((value: number) => value + 1);
+    expect(applyUnless(5)).toBe(6);
+    expect(applyUnless(20)).toBe(20);
+
+    expect(when((value: number) => value > 10, (value: number) => value + 1, 5)).toBe(5);
+    expect(when((value: number) => value > 10, (value: number) => value + 1, 20)).toBe(21);
+
+    const applyWhen = when((value: number) => value > 10)((value: number) => value + 1);
+    expect(applyWhen(5)).toBe(5);
+    expect(applyWhen(20)).toBe(21);
+  });
+});

package/src/implement/control/guard.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import guard from './guard';
+
+describe('guard', () => {
+  it('returns value when predicate passes', () => {
+    expect(guard((n: number) => n > 0, 0, 5)).toBe(5);
+  });
+
+  it('returns default when predicate fails', () => {
+    expect(guard((n: number) => n > 0, 0, -3)).toBe(0);
+  });
+
+  it('works with objects', () => {
+    expect(guard((v: { ok?: boolean }) => v.ok === true, { ok: false }, { ok: true })).toEqual({ ok: true });
+    expect(guard((v: { ok?: boolean }) => v.ok === true, { ok: false }, { ok: false })).toEqual({ ok: false });
+  });
+});

package/src/implement/control/guard.ts

@@ -0,0 +1,27 @@
+import curry from '../composition/curry';
+
+type Guard = {
+  <T, U extends T>(
+    ...args: [predicate: (value: T) => boolean]
+  ): (defaultValue: U) => (value: T) => T;
+  <T, U extends T>(
+    ...args: [predicate: (value: T) => boolean, defaultValue: U]
+  ): (value: T) => T;
+  <T, U extends T>(
+    ...args: [predicate: (value: T) => boolean, defaultValue: U, value: T]
+  ): T;
+};
+
+/**
+ * guard - 조건 불만족 시 early return
+ */
+function guard<T, U extends T>(
+  predicate: (value: T) => boolean,
+  defaultValue: U,
+  value: T
+): T {
+  return predicate(value) ? value : defaultValue;
+}
+
+const curriedGuard = curry(guard) as Guard;
+export default curriedGuard;