fp-pack 0.1.0

package/src/implement/equality/includes.ts

@@ -0,0 +1,21 @@
+/** includes - 동등성 기반 포함 여부 (문자열 또는 배열) */
+import equals from './equals';
+
+function includes(search: string, target: string): boolean;
+function includes<T>(search: T, target: T[]): boolean;
+function includes(search: any, target: any): boolean {
+  if (typeof target === 'string' && typeof search === 'string') {
+    return target.includes(search);
+  }
+
+  if (Array.isArray(target)) {
+    for (let i = 0; i < target.length; i++) {
+      if (equals(target[i], search)) return true;
+    }
+    return false;
+  }
+
+  return false;
+}
+
+export default includes;

package/src/implement/equality/index.ts

@@ -0,0 +1,10 @@
+export { default as equals } from './equals';
+export { default as isNil } from './isNil';
+export { default as isEmpty } from './isEmpty';
+export { default as isType } from './isType';
+export { default as gt } from './gt';
+export { default as gte } from './gte';
+export { default as lt } from './lt';
+export { default as lte } from './lte';
+export { default as clamp } from './clamp';
+export { default as includes } from './includes';

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

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import isEmpty from './isEmpty';
+
+describe('isEmpty', () => {
+  it('returns true for null/undefined', () => {
+    expect(isEmpty(null)).toBe(true);
+    expect(isEmpty(undefined)).toBe(true);
+  });
+
+  it('checks strings and arrays', () => {
+    expect(isEmpty('')).toBe(true);
+    expect(isEmpty([])).toBe(true);
+    expect(isEmpty('a')).toBe(false);
+    expect(isEmpty([1])).toBe(false);
+  });
+
+  it('checks objects and maps/sets', () => {
+    expect(isEmpty({})).toBe(true);
+    expect(isEmpty({ a: 1 })).toBe(false);
+    expect(isEmpty(new Map())).toBe(true);
+    expect(isEmpty(new Set())).toBe(true);
+    expect(isEmpty(new Map([['a', 1]]))).toBe(false);
+  });
+});

package/src/implement/equality/isEmpty.ts

@@ -0,0 +1,19 @@
+/** isEmpty - 비어있는지 검사 */
+function isEmpty(value: any): boolean {
+  if (value == null) return true;
+
+  if (typeof value === 'string' || Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (value instanceof Map || value instanceof Set) {
+    return value.size === 0;
+  }
+
+  if (typeof value === 'object') {
+    return Object.keys(value).length === 0;
+  }
+
+  return false;
+}
+export default isEmpty;

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

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import isNil from './isNil';
+
+describe('isNil', () => {
+  it('returns true for null or undefined', () => {
+    expect(isNil(null)).toBe(true);
+    expect(isNil(undefined)).toBe(true);
+  });
+
+  it('returns false for other values', () => {
+    expect(isNil(0)).toBe(false);
+    expect(isNil('')).toBe(false);
+    expect(isNil(false)).toBe(false);
+    expect(isNil({})).toBe(false);
+  });
+});

package/src/implement/equality/isNil.ts

@@ -0,0 +1,5 @@
+/** isNil - null or undefined 체크 */
+function isNil(value: any): boolean {
+  return value === null || value === undefined;
+}
+export default isNil;

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

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import isType from './isType';
+
+describe('isType', () => {
+  it('checks primitives', () => {
+    expect(isType('string')('hello')).toBe(true);
+    expect(isType('number')(123)).toBe(true);
+    expect(isType('boolean')(false)).toBe(true);
+    expect(isType('symbol')(Symbol('x'))).toBe(true);
+    expect(isType('bigint')(BigInt(1))).toBe(true);
+  });
+
+  it('checks null and undefined explicitly', () => {
+    expect(isType('null')(null)).toBe(true);
+    expect(isType('undefined')(undefined)).toBe(true);
+  });
+
+  it('checks objects by toString tag', () => {
+    expect(isType('array')([])).toBe(true);
+    expect(isType('date')(new Date())).toBe(true);
+    expect(isType('map')(new Map())).toBe(true);
+    expect(isType('set')(new Set())).toBe(true);
+  });
+
+  it('is case-insensitive on target type', () => {
+    expect(isType('ArRaY')([])).toBe(true);
+  });
+});

package/src/implement/equality/isType.ts

@@ -0,0 +1,13 @@
+/** isType - 타입 체크 유틸 */
+function isType(type: string): (value: any) => boolean {
+  const target = type.toLowerCase();
+  return (value: any) => {
+    if (value === null) return target === 'null';
+    if (value === undefined) return target === 'undefined';
+    const actual = typeof value;
+    if (actual !== 'object') return actual === target;
+    const tag = Object.prototype.toString.call(value).slice(8, -1).toLowerCase(); // e.g., 'array', 'date'
+    return tag === target;
+  };
+}
+export default isType;

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

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

package/src/implement/equality/lt.ts

@@ -0,0 +1,5 @@
+/** lt - 미만 비교 */
+function lt(a: number): (b: number) => boolean {
+  return (b: number) => b < a;
+}
+export default lt;

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

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

package/src/implement/equality/lte.ts

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

package/src/implement/math/add.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import add from './add';
+
+describe('add', () => {
+  it('adds two numbers', () => {
+    expect(add(1, 2)).toBe(3);
+    expect(add(-1, 1)).toBe(0);
+  });
+});

package/src/implement/math/add.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** add - 덧셈 */
+function add(a: number, b: number): number {
+  return a + b;
+}
+export default curry(add);

package/src/implement/math/ceil.test.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import ceil from './ceil';
+
+describe('ceil', () => {
+  it('rounds up to nearest integer', () => {
+    expect(ceil(1.1)).toBe(2);
+    expect(ceil(-1.1)).toBe(-1);
+    expect(ceil(2)).toBe(2);
+  });
+});

package/src/implement/math/ceil.ts

@@ -0,0 +1,5 @@
+/** ceil - 올림 */
+function ceil(value: number): number {
+  return Math.ceil(value);
+}
+export default ceil;

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

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import add from './add';
+import sub from './sub';
+import mul from './mul';
+import div from './div';
+import randomInt from './randomInt';
+
+describe('math (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(add(1, 2)).toBe(3);
+    expect(add(1)(2)).toBe(3);
+
+    expect(sub(5, 2)).toBe(3);
+    expect(sub(5)(2)).toBe(3);
+
+    expect(mul(2, 3)).toBe(6);
+    expect(mul(2)(3)).toBe(6);
+
+    expect(div(6, 2)).toBe(3);
+    expect(div(6)(2)).toBe(3);
+
+    const directValue = randomInt(1, 3);
+    expect(directValue).toBeGreaterThanOrEqual(1);
+    expect(directValue).toBeLessThanOrEqual(3);
+
+    const curriedValue = randomInt(1)(3);
+    expect(curriedValue).toBeGreaterThanOrEqual(1);
+    expect(curriedValue).toBeLessThanOrEqual(3);
+  });
+});

package/src/implement/math/div.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import div from './div';
+
+describe('div', () => {
+  it('divides two numbers', () => {
+    expect(div(6, 3)).toBe(2);
+    expect(div(1, 2)).toBe(0.5);
+  });
+});

package/src/implement/math/div.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** div - 나눗셈 */
+function div(a: number, b: number): number {
+  return a / b;
+}
+export default curry(div);

package/src/implement/math/floor.test.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import floor from './floor';
+
+describe('floor', () => {
+  it('rounds down to nearest integer', () => {
+    expect(floor(1.9)).toBe(1);
+    expect(floor(-1.1)).toBe(-2);
+    expect(floor(2)).toBe(2);
+  });
+});

package/src/implement/math/floor.ts

@@ -0,0 +1,5 @@
+/** floor - 내림 */
+function floor(value: number): number {
+  return Math.floor(value);
+}
+export default floor;

package/src/implement/math/index.ts

@@ -0,0 +1,12 @@
+export { default as add } from './add';
+export { default as sub } from './sub';
+export { default as mul } from './mul';
+export { default as div } from './div';
+export { default as sum } from './sum';
+export { default as mean } from './mean';
+export { default as min } from './min';
+export { default as max } from './max';
+export { default as round } from './round';
+export { default as floor } from './floor';
+export { default as ceil } from './ceil';
+export { default as randomInt } from './randomInt';

package/src/implement/math/max.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import max from './max';
+
+describe('max', () => {
+  it('returns maximum value in array', () => {
+    expect(max([1, 5, 3])).toBe(5);
+    expect(max([-10, -5, -7])).toBe(-5);
+  });
+
+  it('returns -Infinity for empty array', () => {
+    expect(max([])).toBe(-Infinity);
+  });
+});

package/src/implement/math/max.ts

@@ -0,0 +1,6 @@
+/** max - 최대값 */
+function max(arr: number[]): number {
+  if (arr.length === 0) return -Infinity;
+  return Math.max(...arr);
+}
+export default max;

package/src/implement/math/mean.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import mean from './mean';
+
+describe('mean', () => {
+  it('returns the average of numbers', () => {
+    expect(mean([1, 2, 3, 4])).toBe(2.5);
+  });
+
+  it('returns NaN for empty arrays', () => {
+    expect(Number.isNaN(mean([]))).toBe(true);
+  });
+});

package/src/implement/math/mean.ts

@@ -0,0 +1,7 @@
+/** mean - 평균 */
+function mean(arr: number[]): number {
+  if (arr.length === 0) return NaN;
+  const total = arr.reduce((acc, value) => acc + value, 0);
+  return total / arr.length;
+}
+export default mean;

package/src/implement/math/min.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import min from './min';
+
+describe('min', () => {
+  it('returns the minimum value in an array', () => {
+    expect(min([3, 1, 5])).toBe(1);
+  });
+
+  it('returns Infinity for empty arrays', () => {
+    expect(min([])).toBe(Infinity);
+  });
+});

package/src/implement/math/min.ts

@@ -0,0 +1,6 @@
+/** min - 최소값 */
+function min(arr: number[]): number {
+  if (arr.length === 0) return Infinity;
+  return Math.min(...arr);
+}
+export default min;

package/src/implement/math/mul.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import mul from './mul';
+
+describe('mul', () => {
+  it('multiplies two numbers', () => {
+    expect(mul(2, 3)).toBe(6);
+    expect(mul(-1, 5)).toBe(-5);
+  });
+});

package/src/implement/math/mul.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** mul - 곱셈 */
+function mul(a: number, b: number): number {
+  return a * b;
+}
+export default curry(mul);

package/src/implement/math/randomInt.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect, vi } from 'vitest';
+import randomInt from './randomInt';
+
+describe('randomInt', () => {
+  it('returns lower bound when random is 0', () => {
+    const spy = vi.spyOn(Math, 'random').mockReturnValue(0);
+
+    expect(randomInt(1, 3)).toBe(1);
+    expect(randomInt(1.2, 3.8)).toBe(2);
+
+    spy.mockRestore();
+  });
+
+  it('returns upper bound when random is near 1', () => {
+    const spy = vi.spyOn(Math, 'random').mockReturnValue(0.999999);
+
+    expect(randomInt(1, 3)).toBe(3);
+    expect(randomInt(1.2, 3.8)).toBe(3);
+
+    spy.mockRestore();
+  });
+});

package/src/implement/math/randomInt.ts

@@ -0,0 +1,14 @@
+import curry from '../composition/curry';
+
+/** randomInt - 범위 랜덤 정수 */
+function randomInt(min: number, max: number): number {
+  const lower = Math.ceil(min);
+  const upper = Math.floor(max);
+
+  if (upper < lower) {
+    return lower;
+  }
+
+  return Math.floor(Math.random() * (upper - lower + 1)) + lower;
+}
+export default curry(randomInt);

package/src/implement/math/round.test.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import round from './round';
+
+describe('round', () => {
+  it('rounds to the nearest integer', () => {
+    expect(round(1.4)).toBe(1);
+    expect(round(1.5)).toBe(2);
+    expect(round(-1.5)).toBe(-1);
+  });
+});

package/src/implement/math/round.ts

@@ -0,0 +1,5 @@
+/** round - 반올림 */
+function round(value: number): number {
+  return Math.round(value);
+}
+export default round;

package/src/implement/math/sub.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import sub from './sub';
+
+describe('sub', () => {
+  it('subtracts two numbers', () => {
+    expect(sub(5, 3)).toBe(2);
+    expect(sub(1, 2)).toBe(-1);
+  });
+});

package/src/implement/math/sub.ts

@@ -0,0 +1,7 @@
+import curry from '../composition/curry';
+
+/** sub - 뺄셈 */
+function sub(a: number, b: number): number {
+  return a - b;
+}
+export default curry(sub);

package/src/implement/math/sum.test.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import sum from './sum';
+
+describe('sum', () => {
+  it('sums array values', () => {
+    expect(sum([1, 2, 3])).toBe(6);
+    expect(sum([-1, 2, -3])).toBe(-2);
+    expect(sum([])).toBe(0);
+  });
+});

package/src/implement/math/sum.ts

@@ -0,0 +1,5 @@
+/** sum - 합계 */
+function sum(arr: number[]): number {
+  return arr.reduce((total, value) => total + value, 0);
+}
+export default sum;

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

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import fold from './fold';
+
+describe('maybe (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(fold(() => 'none', (value: number) => `value:${value}`, null)).toBe('none');
+    expect(fold(() => 'none', (value: number) => `value:${value}`, 3)).toBe('value:3');
+
+    const toLabel = fold(() => 'none')((value: number) => `value:${value}`);
+    expect(toLabel(null)).toBe('none');
+    expect(toLabel(3)).toBe('value:3');
+  });
+});

package/src/implement/nullable/fold.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import fold from './fold';
+
+describe('fold', () => {
+  it('returns onNone for nullish values', () => {
+    expect(
+      fold(
+        () => 'none',
+        (value: number) => `value:${value}`,
+        null
+      )
+    ).toBe('none');
+    expect(
+      fold(
+        () => 'none',
+        (value: number) => `value:${value}`,
+        undefined
+      )
+    ).toBe('none');
+  });
+
+  it('returns onSome for non-null values', () => {
+    expect(
+      fold(
+        () => 'none',
+        (value: number) => `value:${value}`,
+        3
+      )
+    ).toBe('value:3');
+  });
+});

package/src/implement/nullable/fold.ts

@@ -0,0 +1,27 @@
+import curry from '../composition/curry';
+
+type Fold = {
+  <R>(...args: [onNone: () => R]): <T>(
+    onSome: (value: T) => R
+  ) => (value: T | null | undefined) => R;
+  <T, R>(
+    ...args: [onNone: () => R, onSome: (value: T) => R]
+  ): (value: T | null | undefined) => R;
+  <T, R>(
+    ...args: [onNone: () => R, onSome: (value: T) => R, value: T | null | undefined]
+  ): R;
+};
+
+/** fold - Maybe/Result 처리 */
+function fold<T, R>(
+  onNone: () => R,
+  onSome: (value: T) => R,
+  value: T | null | undefined
+): R {
+  if (value === null || value === undefined) {
+    return onNone();
+  }
+  return onSome(value);
+}
+const curriedFold = curry(fold) as Fold;
+export default curriedFold;

package/src/implement/nullable/getOrElse.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import getOrElse from './getOrElse';
+
+describe('getOrElse', () => {
+  it('returns default for nullish values', () => {
+    const fallback = getOrElse('default');
+
+    expect(fallback(null)).toBe('default');
+    expect(fallback(undefined)).toBe('default');
+  });
+
+  it('returns the value when present', () => {
+    const fallback = getOrElse('default');
+
+    expect(fallback('value')).toBe('value');
+  });
+});

package/src/implement/nullable/getOrElse.ts

@@ -0,0 +1,10 @@
+/** getOrElse - 기본값 제공 */
+function getOrElse<T>(defaultValue: T): (value: T | null | undefined) => T {
+  return (value: T | null | undefined) => {
+    if (value === null || value === undefined) {
+      return defaultValue;
+    }
+    return value;
+  };
+}
+export default getOrElse;

package/src/implement/nullable/index.ts

@@ -0,0 +1,5 @@
+export { default as maybe } from './maybe';
+export { default as mapMaybe } from './mapMaybe';
+export { default as getOrElse } from './getOrElse';
+export { default as result } from './result';
+export { default as fold } from './fold';

package/src/implement/nullable/mapMaybe.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import mapMaybe from './mapMaybe';
+
+describe('mapMaybe', () => {
+  it('filters out nullish mapped values', () => {
+    const users = [
+      { id: 1, name: 'A' },
+      { id: 2 },
+      { id: 3, name: 'C' },
+    ];
+
+    const names = mapMaybe((user: { name?: string }) => user.name)(users);
+
+    expect(names).toEqual(['A', 'C']);
+  });
+
+  it('returns an empty array when nothing matches', () => {
+    const values = [1, 2, 3];
+    const odds = mapMaybe((value: number) => (value % 2 === 0 ? null : undefined))(values);
+
+    expect(odds).toEqual([]);
+  });
+});

package/src/implement/nullable/mapMaybe.ts

@@ -0,0 +1,18 @@
+/** mapMaybe - 값이 있는 항목만 변환 */
+function mapMaybe<T, R>(
+  fn: (value: T) => R | null | undefined
+): (values: T[]) => R[] {
+  return (values: T[]) => {
+    const results: R[] = [];
+
+    for (const value of values) {
+      const mapped = fn(value);
+      if (mapped !== null && mapped !== undefined) {
+        results.push(mapped);
+      }
+    }
+
+    return results;
+  };
+}
+export default mapMaybe;