fp-pack 0.1.0

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

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import ifElse from './ifElse';
+
+describe('ifElse', () => {
+  it('runs onTrue when predicate is true', () => {
+    const result = ifElse(
+      (n: number) => n > 0,
+      (n) => `positive ${n}`,
+      (n) => `non-positive ${n}`,
+      3
+    );
+    expect(result).toBe('positive 3');
+  });
+
+  it('runs onFalse when predicate is false', () => {
+    const result = ifElse(
+      (n: number) => n > 0,
+      () => 'yes',
+      () => 'no',
+      -1
+    );
+    expect(result).toBe('no');
+  });
+
+  it('supports different return types for onTrue/onFalse', () => {
+    const trueResult = ifElse(
+      (flag: boolean) => flag,
+      () => ({ ok: true }),
+      () => 'nope',
+      true
+    );
+
+    const falseResult = ifElse(
+      (flag: boolean) => flag,
+      () => ({ ok: true }),
+      () => 'nope',
+      false
+    );
+
+    expect(trueResult).toEqual({ ok: true });
+    expect(falseResult).toBe('nope');
+  });
+
+  it('passes the original value to handlers', () => {
+    const spyTrue = vi.fn((n: number) => n * 2);
+    const spyFalse = vi.fn((n: number) => n * -1);
+    const trueResult = ifElse(
+      (n: number) => n % 2 === 0,
+      spyTrue,
+      spyFalse,
+      4
+    );
+
+    expect(trueResult).toBe(8);
+    expect(spyTrue).toHaveBeenCalledWith(4);
+    expect(spyFalse).not.toHaveBeenCalled();
+
+    const falseResult = ifElse(
+      (n: number) => n % 2 === 0,
+      spyTrue,
+      spyFalse,
+      3
+    );
+
+    expect(falseResult).toBe(-3);
+    expect(spyFalse).toHaveBeenCalledWith(3);
+  });
+});

package/src/implement/control/ifElse.ts

@@ -0,0 +1,40 @@
+import curry from '../composition/curry';
+
+type IfElse = {
+  <T, RTrue, RFalse>(
+    ...args: [predicate: (value: T) => boolean]
+  ): (onTrue: (value: T) => RTrue) => (onFalse: (value: T) => RFalse) => (value: T) => RTrue | RFalse;
+  <T, RTrue, RFalse>(
+    ...args: [predicate: (value: T) => boolean, onTrue: (value: T) => RTrue]
+  ): (onFalse: (value: T) => RFalse) => (value: T) => RTrue | RFalse;
+  <T, RTrue, RFalse>(
+    ...args: [
+      predicate: (value: T) => boolean,
+      onTrue: (value: T) => RTrue,
+      onFalse: (value: T) => RFalse
+    ]
+  ): (value: T) => RTrue | RFalse;
+  <T, RTrue, RFalse>(
+    ...args: [
+      predicate: (value: T) => boolean,
+      onTrue: (value: T) => RTrue,
+      onFalse: (value: T) => RFalse,
+      value: T
+    ]
+  ): RTrue | RFalse;
+};
+
+/**
+ * ifElse - 조건에 따라 다른 함수 실행
+ */
+function ifElse<T, RTrue, RFalse>(
+  predicate: (value: T) => boolean,
+  onTrue: (value: T) => RTrue,
+  onFalse: (value: T) => RFalse,
+  value: T
+): RTrue | RFalse {
+  return predicate(value) ? onTrue(value) : onFalse(value);
+}
+
+const curriedIfElse = curry(ifElse) as IfElse;
+export default curriedIfElse;

package/src/implement/control/index.ts

@@ -0,0 +1,6 @@
+export { default as ifElse } from './ifElse';
+export { default as when } from './when';
+export { default as unless } from './unless';
+export { default as cond } from './cond';
+export { default as tryCatch } from './tryCatch';
+export { default as guard } from './guard';

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

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import tryCatch from './tryCatch';
+
+describe('tryCatch', () => {
+  it('returns tryFn result when no error', () => {
+    const result = tryCatch(
+      (n: number) => n * 2,
+      () => -1,
+      3
+    );
+    expect(result).toBe(6);
+  });
+
+  it('calls catchFn on thrown error', () => {
+    const result = tryCatch(
+      () => {
+        throw new Error('boom');
+      },
+      (err) => err.message,
+      0
+    );
+    expect(result).toBe('boom');
+  });
+
+  it('wraps non-Error throw values', () => {
+    const result = tryCatch(
+      () => {
+        throw 'oops';
+      },
+      (err) => err.message,
+      0
+    );
+    expect(result).toBe('oops');
+  });
+});

package/src/implement/control/tryCatch.ts

@@ -0,0 +1,36 @@
+import curry from '../composition/curry';
+
+type TryCatch = {
+  <T, R>(...args: [tryFn: (value: T) => R]): (
+    catchFn: (error: Error, value: T) => R
+  ) => (value: T) => R;
+  <T, R>(
+    ...args: [tryFn: (value: T) => R, catchFn: (error: Error, value: T) => R]
+  ): (value: T) => R;
+  <T, R>(
+    ...args: [
+      tryFn: (value: T) => R,
+      catchFn: (error: Error, value: T) => R,
+      value: T
+    ]
+  ): R;
+};
+
+/**
+ * tryCatch - 예외를 함수형으로 처리
+ */
+function tryCatch<T, R>(
+  tryFn: (value: T) => R,
+  catchFn: (error: Error, value: T) => R,
+  value: T
+): R {
+  try {
+    return tryFn(value);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    return catchFn(error, value);
+  }
+}
+
+const curriedTryCatch = curry(tryCatch) as TryCatch;
+export default curriedTryCatch;

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

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import unless from './unless';
+
+describe('unless', () => {
+  it('applies fn when predicate is false', () => {
+    const result = unless(
+      (n: number) => n > 0,
+      (n) => n * -1,
+      -3
+    );
+    expect(result).toBe(3);
+  });
+
+  it('returns original value when predicate is true', () => {
+    const result = unless(
+      (n: number) => n > 0,
+      (n) => n * -1,
+      5
+    );
+    expect(result).toBe(5);
+  });
+});

package/src/implement/control/unless.ts

@@ -0,0 +1,29 @@
+import curry from '../composition/curry';
+
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+
+type Unless = {
+  <T>(...args: [predicate: (value: Widen<T>) => boolean]): (
+    fn: (value: Widen<T>) => Widen<T>
+  ) => (value: Widen<T>) => Widen<T>;
+  <T>(
+    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>]
+  ): (value: Widen<T>) => Widen<T>;
+  <T>(
+    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>, value: Widen<T>]
+  ): Widen<T>;
+};
+
+/**
+ * unless - 조건이 false일 때만 적용
+ */
+function unless<T>(
+  predicate: (value: T) => boolean,
+  fn: (value: T) => T,
+  value: T
+): T {
+  return predicate(value) ? value : fn(value);
+}
+
+const curriedUnless = curry(unless) as Unless;
+export default curriedUnless;

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

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import when from './when';
+
+describe('when', () => {
+  it('applies fn when predicate is true', () => {
+    const result = when(
+      (n: number) => n > 0,
+      (n) => n * 2,
+      3
+    );
+    expect(result).toBe(6);
+  });
+
+  it('returns original value when predicate is false', () => {
+    const result = when(
+      (n: number) => n > 0,
+      (n) => n * 2,
+      -2
+    );
+    expect(result).toBe(-2);
+  });
+});

package/src/implement/control/when.ts

@@ -0,0 +1,29 @@
+import curry from '../composition/curry';
+
+type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+
+type When = {
+  <T>(...args: [predicate: (value: Widen<T>) => boolean]): (
+    fn: (value: Widen<T>) => Widen<T>
+  ) => (value: Widen<T>) => Widen<T>;
+  <T>(
+    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>]
+  ): (value: Widen<T>) => Widen<T>;
+  <T>(
+    ...args: [predicate: (value: Widen<T>) => boolean, fn: (value: Widen<T>) => Widen<T>, value: Widen<T>]
+  ): Widen<T>;
+};
+
+/**
+ * when - 조건이 true일 때만 적용
+ */
+function when<T>(
+  predicate: (value: T) => boolean,
+  fn: (value: T) => T,
+  value: T
+): T {
+  return predicate(value) ? fn(value) : value;
+}
+
+const curriedWhen = curry(when) as When;
+export default curriedWhen;

package/src/implement/debug/assert.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import assert from './assert';
+
+describe('assert', () => {
+  it('does nothing when condition is true', () => {
+    expect(() => assert(true)(undefined)).not.toThrow();
+  });
+
+  it('throws when condition is false', () => {
+    expect(() => assert(false)(undefined)).toThrow('Assertion failed');
+  });
+
+  it('uses a custom message when provided', () => {
+    expect(() => assert(false)('boom')).toThrow('boom');
+  });
+});

package/src/implement/debug/assert.ts

@@ -0,0 +1,9 @@
+import curry from '../composition/curry';
+
+/** assert - 조건 검증 */
+function assert(condition: boolean, message: string | undefined): void {
+  if (!condition) {
+    throw new Error(message ?? 'Assertion failed');
+  }
+}
+export default curry(assert);

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

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import assert from './assert';
+import invariant from './invariant';
+
+describe('debug (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(() => assert(true, 'ok')).not.toThrow();
+    expect(() => assert(false, 'fail')).toThrow('fail');
+    expect(() => assert(true)('ok')).not.toThrow();
+    expect(() => assert(false)('fail')).toThrow('fail');
+
+    expect(() => invariant(true, 'ok')).not.toThrow();
+    expect(() => invariant(false, 'bad')).toThrow('bad');
+    expect(() => invariant(true)('ok')).not.toThrow();
+    expect(() => invariant(false)('bad')).toThrow('bad');
+  });
+});

package/src/implement/debug/index.ts

@@ -0,0 +1,3 @@
+export { default as assert } from './assert';
+export { default as invariant } from './invariant';
+export { default as log } from './log';

package/src/implement/debug/invariant.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import invariant from './invariant';
+
+describe('invariant', () => {
+  it('does nothing when condition is true', () => {
+    expect(() => invariant(true)(undefined)).not.toThrow();
+  });
+
+  it('throws when condition is false', () => {
+    expect(() => invariant(false)(undefined)).toThrow('Invariant failed');
+  });
+
+  it('uses a custom message when provided', () => {
+    expect(() => invariant(false)('broken')).toThrow('broken');
+  });
+});

package/src/implement/debug/invariant.ts

@@ -0,0 +1,9 @@
+import curry from '../composition/curry';
+
+/** invariant - 계약 위반 체크 */
+function invariant(condition: boolean, message: string | undefined): void {
+  if (!condition) {
+    throw new Error(message ?? 'Invariant failed');
+  }
+}
+export default curry(invariant);

package/src/implement/debug/log.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect, vi } from 'vitest';
+import log from './log';
+
+describe('log', () => {
+  it('logs the value and returns it', () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const result = log<number>()(42);
+    expect(spy).toHaveBeenCalledWith(42);
+    expect(result).toBe(42);
+    spy.mockRestore();
+  });
+
+  it('logs the label and value when label is provided', () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const result = log('value')(7);
+    expect(spy).toHaveBeenCalledWith('value', 7);
+    expect(result).toBe(7);
+    spy.mockRestore();
+  });
+});

package/src/implement/debug/log.ts

@@ -0,0 +1,12 @@
+/** log - tap 기반 로깅 */
+function log<T>(label?: string): (value: T) => T {
+  return (value: T) => {
+    if (label) {
+      console.log(label, value);
+    } else {
+      console.log(value);
+    }
+    return value;
+  };
+}
+export default log;

package/src/implement/equality/clamp.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import clamp from './clamp';
+
+describe('clamp', () => {
+  it('returns value within bounds', () => {
+    expect(clamp(0, 10, 5)).toBe(5);
+  });
+
+  it('clips below min', () => {
+    expect(clamp(0, 10, -3)).toBe(0);
+  });
+
+  it('clips above max', () => {
+    expect(clamp(0, 10, 15)).toBe(10);
+  });
+});

package/src/implement/equality/clamp.ts

@@ -0,0 +1,9 @@
+import curry from '../composition/curry';
+
+/** clamp - 범위 제한 */
+function clamp(min: number, max: number, value: number): number {
+  if (value < min) return min;
+  if (value > max) return max;
+  return value;
+}
+export default curry(clamp);

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

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import clamp from './clamp';
+import equals from './equals';
+
+describe('equality (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(clamp(0, 10, 15)).toBe(10);
+    expect(clamp(0)(10)(15)).toBe(10);
+
+    expect(equals({ a: 1 }, { a: 1 })).toBe(true);
+    expect(equals({ a: 1 })({ a: 1 })).toBe(true);
+  });
+});

package/src/implement/equality/equals.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import equals from './equals';
+
+describe('equals', () => {
+  it('compares primitives and NaN', () => {
+    expect(equals(1, 1)).toBe(true);
+    expect(equals(1, 2)).toBe(false);
+    expect(equals(NaN, NaN)).toBe(true);
+  });
+
+  it('compares arrays deeply', () => {
+    expect(equals([1, 2], [1, 2])).toBe(true);
+    expect(equals([1, [2, 3]], [1, [2, 4]])).toBe(false);
+  });
+
+  it('compares objects deeply', () => {
+    expect(equals({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })).toBe(true);
+    expect(equals({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
+  });
+
+  it('compares dates by time value', () => {
+    expect(equals(new Date('2020-01-01'), new Date('2020-01-01'))).toBe(true);
+    expect(equals(new Date('2020-01-01'), new Date('2021-01-01'))).toBe(false);
+  });
+
+  it('handles circular references', () => {
+    const a: any = { v: 1 };
+    const b: any = { v: 1 };
+    a.self = a;
+    b.self = b;
+    expect(equals(a, b)).toBe(true);
+
+    const c: any = { v: 1 };
+    const d: any = { v: 2 };
+    c.self = c;
+    d.self = d;
+    expect(equals(c, d)).toBe(false);
+  });
+
+  it('compares maps by deep key/value', () => {
+    const a = new Map<any, any>([[{ k: 1 }, { v: 2 }]]);
+    const b = new Map<any, any>([[{ k: 1 }, { v: 2 }]]);
+    expect(equals(a, b)).toBe(true);
+
+    const c = new Map<any, any>([[{ k: 1 }, { v: 3 }]]);
+    expect(equals(a, c)).toBe(false);
+  });
+
+  it('compares sets ignoring order', () => {
+    const a = new Set([1, 2, 3]);
+    const b = new Set([3, 2, 1]);
+    expect(equals(a, b)).toBe(true);
+
+    const c = new Set([1, 2, 4]);
+    expect(equals(a, c)).toBe(false);
+  });
+
+  it('compares symbol-keyed properties', () => {
+    const sym = Symbol('x');
+    expect(equals({ [sym]: 1 }, { [sym]: 1 })).toBe(true);
+    expect(equals({ [sym]: 1 }, { [sym]: 2 })).toBe(false);
+  });
+});

package/src/implement/equality/equals.ts

@@ -0,0 +1,87 @@
+import curry from '../composition/curry';
+
+/** equals - 깊은 비교 */
+function equals(a: any, b: any): boolean {
+  return deepEqual(a, b, new WeakMap());
+}
+
+function deepEqual(a: any, b: any, seen: WeakMap<object, object>): boolean {
+  if (a === b) return true;
+
+  // Handle NaN
+  if (typeof a === 'number' && typeof b === 'number') {
+    if (Number.isNaN(a) && Number.isNaN(b)) return true;
+  }
+
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') {
+    return false;
+  }
+
+  // Prevent circular reference issues
+  if (seen.has(a)) return seen.get(a) === b;
+  seen.set(a, b);
+
+  // Date
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+
+  // Map
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    const bEntries = Array.from(b.entries());
+    for (const [aKey, aVal] of a.entries()) {
+      let found = false;
+      for (let i = 0; i < bEntries.length; i++) {
+        const [bKey, bVal] = bEntries[i];
+        if (deepEqual(aKey, bKey, seen) && deepEqual(aVal, bVal, seen)) {
+          bEntries.splice(i, 1);
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+    return true;
+  }
+
+  // Set
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    const bValues = Array.from(b.values());
+    for (const aVal of a.values()) {
+      let found = false;
+      for (let i = 0; i < bValues.length; i++) {
+        if (deepEqual(aVal, bValues[i], seen)) {
+          bValues.splice(i, 1);
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+    return true;
+  }
+
+  // Array
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i], seen)) return false;
+    }
+    return true;
+  }
+
+  // Object (including symbol keys)
+  const aKeys = Reflect.ownKeys(a);
+  const bKeys = Reflect.ownKeys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!deepEqual(a[key], b[key], seen)) return false;
+  }
+
+  return true;
+}
+
+export default curry(equals);

package/src/implement/equality/gt.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import gt from './gt';
+
+describe('gt', () => {
+  it('returns true when greater', () => {
+    expect(gt(3)(5)).toBe(true);
+  });
+
+  it('returns false when equal or less', () => {
+    expect(gt(3)(3)).toBe(false);
+    expect(gt(3)(2)).toBe(false);
+  });
+});

package/src/implement/equality/gt.ts

@@ -0,0 +1,5 @@
+/** gt - 초과 비교 */
+function gt(a: number): (b: number) => boolean {
+  return (b: number) => b > a;
+}
+export default gt;

package/src/implement/equality/gte.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import gte from './gte';
+
+describe('gte', () => {
+  it('returns true when greater or equal', () => {
+    expect(gte(3)(3)).toBe(true);
+    expect(gte(3)(4)).toBe(true);
+  });
+
+  it('returns false when less', () => {
+    expect(gte(3)(2)).toBe(false);
+  });
+});

package/src/implement/equality/gte.ts

@@ -0,0 +1,5 @@
+/** gte - 이상 비교 */
+function gte(a: number): (b: number) => boolean {
+  return (b: number) => b >= a;
+}
+export default gte;

package/src/implement/equality/includes.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import includes from './includes';
+
+describe('includes', () => {
+  it('checks substring in string', () => {
+    expect(includes('ba', 'banana')).toBe(true);
+    expect(includes('ac', 'banana')).toBe(false);
+  });
+
+  it('checks deep equality in arrays', () => {
+    expect(includes(3, [1, 2, 3])).toBe(true);
+    expect(includes(4, [1, 2, 3])).toBe(false);
+    expect(includes({ name: 'Fred' }, [{ name: 'Fred' }])).toBe(true);
+    expect(includes([42], [[42]])).toBe(true);
+  });
+});