fp-pack 0.1.0

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

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import maybe from './maybe';
+
+describe('maybe', () => {
+  it('applies the function when value exists', () => {
+    const toUpper = maybe((value: string) => value.toUpperCase());
+    expect(toUpper('fp')).toBe('FP');
+  });
+
+  it('returns null for null or undefined', () => {
+    const toUpper = maybe((value: string) => value.toUpperCase());
+    expect(toUpper(null)).toBeNull();
+    expect(toUpper(undefined)).toBeNull();
+  });
+});

package/src/implement/nullable/maybe.ts

@@ -0,0 +1,10 @@
+/** maybe - null-safe 연산 */
+function maybe<T, R>(fn: (value: T) => R): (value: T | null | undefined) => R | null {
+  return (value: T | null | undefined) => {
+    if (value === null || value === undefined) {
+      return null;
+    }
+    return fn(value);
+  };
+}
+export default maybe;

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

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import result from './result';
+
+describe('result', () => {
+  it('wraps success', () => {
+    const wrapped = result(() => 1 + 1);
+    expect(wrapped).toEqual({ ok: true, value: 2 });
+  });
+
+  it('wraps failures', () => {
+    const wrapped = result(() => {
+      throw new Error('fail');
+    });
+
+    expect(wrapped.ok).toBe(false);
+  });
+});

package/src/implement/nullable/result.ts

@@ -0,0 +1,10 @@
+/** result - 성공 / 실패 래핑 */
+function result<T, E = Error>(fn: () => T): { ok: true; value: T } | { ok: false; error: E } {
+  // TODO: implement
+  try {
+    return { ok: true, value: fn() };
+  } catch (error) {
+    return { ok: false, error: error as E };
+  }
+}
+export default result;

package/src/implement/object/assoc.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import assoc from './assoc';
+
+describe('assoc', () => {
+  it('sets a property immutably', () => {
+    const user = { id: 1, name: 'A' };
+    const updated = assoc('name', 'B', user);
+
+    expect(updated).toEqual({ id: 1, name: 'B' });
+    expect(user).toEqual({ id: 1, name: 'A' });
+  });
+
+  it('adds a new key', () => {
+    const user = { id: 1, name: 'A' };
+    const updated = assoc('age', 20, user);
+
+    expect(updated).toEqual({ id: 1, name: 'A', age: 20 });
+  });
+
+  it('updates array indices immutably', () => {
+    const items = ['a', 'b'];
+    const updated = assoc(1, 'c', items);
+
+    expect(updated).toEqual(['a', 'c']);
+    expect(items).toEqual(['a', 'b']);
+  });
+});

package/src/implement/object/assoc.ts

@@ -0,0 +1,43 @@
+import curry from '../composition/curry';
+
+type AssocKey = string | number | symbol;
+
+type AssocValue<T, K extends AssocKey, V> = K extends keyof T
+  ? (T[K] extends V ? T : Omit<T, K> & Record<K, V>)
+  : T & Record<K, V>;
+
+type AssocResult<T, K extends AssocKey, V> =
+  T extends readonly (infer U)[]
+    ? K extends number | `${number}`
+      ? Array<V | U>
+      : AssocValue<T, K, V>
+    : AssocValue<T, K, V>;
+
+type Assoc = {
+  <K extends AssocKey>(...args: [key: K]): <V>(value: V) => <T>(obj: T) => AssocResult<T, K, V>;
+  <K extends AssocKey, V>(...args: [key: K, value: V]): <T>(obj: T) => AssocResult<T, K, V>;
+  <T, K extends AssocKey, V>(...args: [key: K, value: V, obj: T]): AssocResult<T, K, V>;
+};
+
+/**
+ * assoc - 불변 객체 속성 설정
+ */
+function assoc<T, K extends AssocKey, V>(key: K, value: V, obj: T): AssocResult<T, K, V> {
+  if (Array.isArray(obj)) {
+    const result = obj.slice();
+    (result as any)[key] = value;
+    return result as AssocResult<T, K, V>;
+  }
+
+  if (obj && typeof obj === 'object') {
+    return {
+      ...(obj as object),
+      [key]: value,
+    } as AssocResult<T, K, V>;
+  }
+
+  return { [key]: value } as AssocResult<T, K, V>;
+}
+
+const curriedAssoc = curry(assoc) as Assoc;
+export default curriedAssoc;

package/src/implement/object/assoc.type-test.ts

@@ -0,0 +1,38 @@
+import assoc from './assoc';
+
+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;
+type Simplify<T> = { [K in keyof T]: T[K] };
+
+const base: { a: number; b: number } = { a: 1, b: 2 };
+const addKey = assoc('c', 3, base);
+const updateKey = assoc('a', 'x', base);
+
+const list: string[] = ['a', 'b', 'c'];
+const updateIndex = assoc(1, 'x', list);
+const updateIndexMixed = assoc(1, 1, list);
+
+export type Assoc_AddKey = Expect<
+  Equal<Simplify<typeof addKey>, { a: number; b: number; c: number }>
+>;
+export type Assoc_UpdateKey = Expect<
+  Equal<Simplify<typeof updateKey>, { a: string; b: number }>
+>;
+export type Assoc_UpdateIndex = Expect<Equal<Simplify<typeof updateIndex>, string[]>>;
+export type Assoc_UpdateIndexMixed = Expect<
+  Equal<Simplify<typeof updateIndexMixed>, Array<string | number>>
+>;
+
+// Generic curry inference (4-5 arity)
+import curry from '../composition/curry';
+
+const generic4 = <A, B, C, D>(a: A, b: B, c: C, d: D) => [a, b, c, d] as const;
+const curried4 = curry(generic4<number, string, boolean, null>);
+export const curry4Result: readonly [number, string, boolean, null] = curried4(1)('two')(true)(null);
+
+const generic5 = <A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E) => [a, b, c, d, e] as const;
+const curried5 = curry(generic5<number, string, boolean, null, undefined>);
+export const curry5Result: readonly [number, string, boolean, null, undefined] =
+  curried5(1)('two')(true)(null)(undefined);

package/src/implement/object/assocPath.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import assocPath from './assocPath';
+
+describe('assocPath', () => {
+  it('updates a nested value', () => {
+    const data = { a: { b: { c: 0 } } };
+    const updated = assocPath(['a', 'b', 'c'], 42, data);
+
+    expect(updated).toEqual({ a: { b: { c: 42 } } });
+    expect(data).toEqual({ a: { b: { c: 0 } } });
+  });
+
+  it('overrides non-object values on the path', () => {
+    const data = { a: 5 };
+    const updated = assocPath<{ a: { b: { c: number } } }>(['a', 'b', 'c'], 42, data);
+
+    expect(updated).toEqual({ a: { b: { c: 42 } } });
+  });
+
+  it('handles array indices and creates missing entries', () => {
+    const data = { a: [] as Array<{ c: number }> };
+    const updated = assocPath(['a', 1, 'c'], 42, data);
+
+    expect(updated).toEqual({ a: [undefined, { c: 42 }] });
+  });
+
+  it('supports negative array indices', () => {
+    const data = { a: [1, 2] };
+    const updated = assocPath(['a', -1], 42, data);
+
+    expect(updated).toEqual({ a: [1, 42] });
+  });
+});

package/src/implement/object/assocPath.ts

@@ -0,0 +1,64 @@
+import curry from '../composition/curry';
+
+type PathKey = string | number | symbol;
+
+const isIndexKey = (key: PathKey): key is number | `${number}` => {
+  if (typeof key === 'number') {
+    return Number.isInteger(key);
+  }
+  if (typeof key === 'string') {
+    return /^-?\d+$/.test(key);
+  }
+  return false;
+};
+
+const normalizeIndex = (key: number | `${number}`, length: number) => {
+  const raw = typeof key === 'number' ? key : Number(key);
+  if (Number.isNaN(raw)) {
+    return -1;
+  }
+  if (raw < 0) {
+    return Math.max(length + raw, 0);
+  }
+  return raw;
+};
+
+const isObjectLike = (value: unknown): value is Record<PropertyKey, unknown> =>
+  value !== null && typeof value === 'object';
+
+type AssocPath = {
+  <T = unknown>(
+    ...args: [pathArray: PathKey[]]
+  ): (value: unknown) => (obj: unknown) => T;
+  <T = unknown>(...args: [pathArray: PathKey[], value: unknown]): (obj: unknown) => T;
+  <T = unknown>(...args: [pathArray: PathKey[], value: unknown, obj: unknown]): T;
+};
+
+/**
+ * assocPath - 경로 기반 값 설정 (불변)
+ */
+function assocPath<T = unknown>(pathArray: PathKey[], value: unknown, obj: unknown): T {
+  if (pathArray.length === 0) {
+    return value as T;
+  }
+
+  const [key, ...rest] = pathArray;
+  const useArray = isIndexKey(key);
+  const base = Array.isArray(obj) ? obj.slice() : isObjectLike(obj) ? { ...(obj as object) } : useArray ? [] : {};
+
+  if (Array.isArray(base) && isIndexKey(key)) {
+    const index = normalizeIndex(key, base.length);
+    const current = (base as unknown[])[index];
+    const nextValue = rest.length === 0 ? value : assocPath(rest, value, current);
+    (base as unknown[])[index] = nextValue;
+    return base as T;
+  }
+
+  const current = isObjectLike(base) ? (base as Record<PropertyKey, unknown>)[key] : undefined;
+  const nextValue = rest.length === 0 ? value : assocPath(rest, value, current);
+  (base as Record<PropertyKey, unknown>)[key] = nextValue;
+  return base as T;
+}
+
+const curriedAssocPath = curry(assocPath) as AssocPath;
+export default curriedAssocPath;

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

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import assoc from './assoc';
+import assocPath from './assocPath';
+import dissocPath from './dissocPath';
+import evolve from './evolve';
+import has from './has';
+import merge from './merge';
+import mergeDeep from './mergeDeep';
+import omit from './omit';
+import path from './path';
+import pick from './pick';
+import prop from './prop';
+
+describe('object (curried)', () => {
+  it('supports direct and data-last currying', () => {
+    expect(prop('name', { name: 'jane', age: 1 })).toBe('jane');
+    expect(prop('name')({ name: 'jane', age: 1 })).toBe('jane');
+
+    expect(path(['a', 'b'], { a: { b: 2 } })).toBe(2);
+    expect(path(['a', 'b'])({ a: { b: 2 } })).toBe(2);
+
+    expect(pick(['a', 'c'], { a: 1, b: 2, c: 3 })).toEqual({ a: 1, c: 3 });
+    expect(pick(['a', 'c'])({ a: 1, b: 2, c: 3 })).toEqual({ a: 1, c: 3 });
+
+    expect(omit(['b'], { a: 1, b: 2 })).toEqual({ a: 1 });
+    expect(omit(['b'])({ a: 1, b: 2 })).toEqual({ a: 1 });
+
+    expect(assoc('b', 2, { a: 1 })).toEqual({ a: 1, b: 2 });
+    expect(assoc('b', 2)({ a: 1 })).toEqual({ a: 1, b: 2 });
+
+    expect(assocPath(['a', 'b'], 2, {})).toEqual({ a: { b: 2 } });
+    expect(assocPath(['a', 'b'], 2)({})).toEqual({ a: { b: 2 } });
+
+    expect(dissocPath(['a', 'b'], { a: { b: 1, c: 2 } })).toEqual({ a: { c: 2 } });
+    expect(dissocPath(['a', 'b'])({ a: { b: 1, c: 2 } })).toEqual({ a: { c: 2 } });
+
+    expect(merge({ a: 1 }, { b: 2 })).toEqual({ a: 1, b: 2 });
+    expect(merge({ a: 1 })({ b: 2 })).toEqual({ a: 1, b: 2 });
+
+    expect(mergeDeep({ a: { b: 1 } }, { a: { c: 2 } })).toEqual({ a: { b: 1, c: 2 } });
+    expect(mergeDeep({ a: { b: 1 } })({ a: { c: 2 } })).toEqual({ a: { b: 1, c: 2 } });
+
+    expect(has('a', { a: 1 })).toBe(true);
+    expect(has('a')({ a: 1 })).toBe(true);
+
+    expect(evolve({ a: (value: number) => value + 1 }, { a: 1, b: 2 })).toEqual({ a: 2, b: 2 });
+    expect(evolve({ a: (value: number) => value + 1 })({ a: 1, b: 2 })).toEqual({ a: 2, b: 2 });
+  });
+});

package/src/implement/object/dissoc.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import dissoc from './dissoc';
+
+describe('dissoc', () => {
+  it('removes a key immutably', () => {
+    const user = { id: 1, name: 'A' };
+    const updated = dissoc('name', user);
+
+    expect(updated).toEqual({ id: 1 });
+    expect(user).toEqual({ id: 1, name: 'A' });
+  });
+
+  it('removes an array index immutably', () => {
+    const list = ['a', 'b', 'c'];
+    const updated = dissoc(1, list);
+
+    expect(updated).toEqual(['a', 'c']);
+    expect(list).toEqual(['a', 'b', 'c']);
+  });
+});

package/src/implement/object/dissoc.ts

@@ -0,0 +1,26 @@
+/**
+ * dissoc - 불변 객체 속성 제거
+ */
+function dissoc<T>(key: number, obj: readonly T[]): T[];
+function dissoc<T, K extends keyof T>(key: K, obj: T): Omit<T, K>;
+function dissoc<T, K extends keyof T>(key: K, obj: T): Omit<T, K> {
+  if (Array.isArray(obj)) {
+    const result = obj.slice();
+    const index = typeof key === 'number' ? key : Number.isNaN(Number(key)) ? -1 : Number(key);
+    if (index >= 0 && index < result.length) {
+      result.splice(index, 1);
+    } else {
+      delete (result as unknown as Record<PropertyKey, unknown>)[key as unknown as PropertyKey];
+    }
+    return result as unknown as Omit<T, K>;
+  }
+
+  if (obj && typeof obj === 'object') {
+    const { [key]: _removed, ...rest } = obj as Record<PropertyKey, unknown>;
+    return rest as Omit<T, K>;
+  }
+
+  return obj as Omit<T, K>;
+}
+
+export default dissoc;

package/src/implement/object/dissocPath.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import dissocPath from './dissocPath';
+
+describe('dissocPath', () => {
+  it('removes a nested value', () => {
+    const data = { a: { b: { c: 42 } } };
+    const updated = dissocPath<{ a: { b: { c: {} } } }>(['a', 'b', 'c'], data);
+
+    expect(updated).toEqual({ a: { b: {} } });
+  });
+
+  it('removes an array index', () => {
+    const data = { a: [1, 2, 3] };
+    const updated = dissocPath(['a', 1], data);
+
+    expect(updated).toEqual({ a: [1, 3] });
+  });
+});

package/src/implement/object/dissocPath.ts

@@ -0,0 +1,80 @@
+import curry from '../composition/curry';
+
+type PathKey = string | number | symbol;
+
+const isIndexKey = (key: PathKey): key is number | `${number}` => {
+  if (typeof key === 'number') {
+    return Number.isInteger(key);
+  }
+  if (typeof key === 'string') {
+    return /^-?\d+$/.test(key);
+  }
+  return false;
+};
+
+const normalizeIndex = (key: number | `${number}`, length: number) => {
+  const raw = typeof key === 'number' ? key : Number(key);
+  if (Number.isNaN(raw)) {
+    return -1;
+  }
+  if (raw < 0) {
+    return length + raw;
+  }
+  return raw;
+};
+
+const isObjectLike = (value: unknown): value is Record<PropertyKey, unknown> =>
+  value !== null && typeof value === 'object';
+
+type DissocPath = {
+  <T = unknown>(...args: [pathArray: PathKey[]]): (obj: T) => T;
+  <T = unknown>(...args: [pathArray: PathKey[], obj: T]): T;
+};
+
+/**
+ * dissocPath - 경로 기반 값 제거 (불변)
+ */
+function dissocPath<T = unknown>(pathArray: PathKey[], obj: T): T {
+  if (pathArray.length === 0) {
+    return obj;
+  }
+
+  if (!isObjectLike(obj)) {
+    return obj;
+  }
+
+  const [key, ...rest] = pathArray;
+
+  if (Array.isArray(obj) && isIndexKey(key)) {
+    const index = normalizeIndex(key, obj.length);
+    if (index < 0 || index >= obj.length) {
+      return obj;
+    }
+
+    const result = obj.slice();
+    if (rest.length === 0) {
+      result.splice(index, 1);
+      return result as unknown as T;
+    }
+
+    const nextValue = dissocPath(rest, result[index]);
+    result[index] = nextValue;
+    return result as unknown as T;
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+    return obj;
+  }
+
+  if (rest.length === 0) {
+    const { [key]: _removed, ...restObj } = obj as Record<PropertyKey, unknown>;
+    return restObj as T;
+  }
+
+  const result = { ...(obj as object) } as Record<PropertyKey, unknown>;
+  result[key] = dissocPath(rest, result[key]);
+  return result as T;
+}
+
+const curriedDissocPath = curry(dissocPath) as DissocPath;
+export default curriedDissocPath;

package/src/implement/object/entries.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import entries from './entries';
+
+describe('entries', () => {
+  it('returns entries', () => {
+    const user = { id: 1, name: 'A' };
+    expect(entries(user)).toEqual([
+      ['id', 1],
+      ['name', 'A'],
+    ]);
+  });
+});

package/src/implement/object/entries.ts

@@ -0,0 +1,8 @@
+/**
+ * entries - 객체 엔트리 배열
+ */
+function entries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]> {
+  return Object.entries(obj) as Array<[keyof T, T[keyof T]]>;
+}
+
+export default entries;

package/src/implement/object/evolve.test.ts

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import evolve from './evolve';
+
+describe('evolve', () => {
+  it('transforms values by schema', () => {
+    const user = { id: 1, name: 'A' };
+    const updated = evolve<{ id: number; name: string }>({
+      id: (value) => value + 1,
+      name: (value) => value.toLowerCase(),
+    }, user);
+
+    expect(updated).toEqual({ id: 2, name: 'a' });
+  });
+});

package/src/implement/object/evolve.ts

@@ -0,0 +1,31 @@
+import curry from '../composition/curry';
+
+type Evolve = {
+  (
+    transformations: Partial<Record<PropertyKey, (value: any) => any>>
+  ): <T extends object>(obj: T) => T;
+  <T extends object>(
+    transformations: Partial<{ [K in keyof T]: (value: T[K]) => any }>,
+    obj: T
+  ): T;
+};
+
+/**
+ * evolve - 구조 기반 변환
+ */
+function evolve<T extends object>(
+  transformations: Partial<{ [K in keyof T]: (value: T[K]) => any }>,
+  obj: T
+): T {
+  const result = { ...(obj as object) } as T;
+  for (const key of Object.keys(transformations) as Array<keyof T>) {
+    const transformer = transformations[key];
+    if (typeof transformer === 'function') {
+      result[key] = transformer(obj[key]);
+    }
+  }
+  return result;
+}
+
+const curriedEvolve = curry(evolve) as Evolve;
+export default curriedEvolve;

package/src/implement/object/has.test.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import has from './has';
+
+describe('has', () => {
+  it('checks for own properties', () => {
+    const user = { id: 1 };
+    expect(has('id', user)).toBe(true);
+    expect(has('id', { id: 2 })).toBe(true);
+  });
+});

package/src/implement/object/has.ts

@@ -0,0 +1,16 @@
+import curry from '../composition/curry';
+
+type Has = {
+  <K extends PropertyKey>(...args: [key: K]): <T extends Record<K, unknown>>(obj: T) => boolean;
+  <T extends object>(...args: [key: keyof T, obj: T]): boolean;
+};
+
+/**
+ * has - 속성 존재 확인
+ */
+function has<T extends object>(key: keyof T, obj: T): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+const curriedHas = curry(has) as Has;
+export default curriedHas;

package/src/implement/object/hasPath.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import hasPath from './hasPath';
+
+describe('hasPath', () => {
+  it('checks for nested path', () => {
+    const user = { profile: { name: 'A' } };
+    const hasName = hasPath(['profile', 'name']);
+    const hasAge = hasPath(['profile', 'age']);
+
+    expect(hasName(user)).toBe(true);
+    expect(hasAge(user)).toBe(false);
+  });
+});

package/src/implement/object/hasPath.ts

@@ -0,0 +1,17 @@
+/**
+ * hasPath - 깊은 경로 존재 확인
+ */
+function hasPath(pathArray: string[]): (obj: any) => boolean {
+  return (obj: any) => {
+    let current = obj;
+    for (const key of pathArray) {
+      if (current == null || !Object.prototype.hasOwnProperty.call(current, key)) {
+        return false;
+      }
+      current = current[key];
+    }
+    return true;
+  };
+}
+
+export default hasPath;

package/src/implement/object/index.ts

@@ -0,0 +1,20 @@
+export { default as prop } from './prop';
+export { default as propOr } from './propOr';
+export { default as path } from './path';
+export { default as pathOr } from './pathOr';
+export { default as pick } from './pick';
+export { default as omit } from './omit';
+export { default as assoc } from './assoc';
+export { default as assocPath } from './assocPath';
+export { default as dissoc } from './dissoc';
+export { default as dissocPath } from './dissocPath';
+export { default as merge } from './merge';
+export { default as mergeDeep } from './mergeDeep';
+export { default as mergeAll } from './mergeAll';
+export { default as keys } from './keys';
+export { default as values } from './values';
+export { default as entries } from './entries';
+export { default as mapValues } from './mapValues';
+export { default as evolve } from './evolve';
+export { default as has } from './has';
+export { default as hasPath } from './hasPath';

package/src/implement/object/keys.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import keys from './keys';
+
+describe('keys', () => {
+  it('returns object keys', () => {
+    const user = { id: 1, name: 'A' };
+    expect(keys(user)).toEqual(['id', 'name']);
+  });
+});

package/src/implement/object/keys.ts

@@ -0,0 +1,8 @@
+/**
+ * keys - 객체 키 배열
+ */
+function keys<T extends object>(obj: T): Array<keyof T> {
+  return Object.keys(obj) as Array<keyof T>;
+}
+
+export default keys;

package/src/implement/object/mapValues.test.ts

@@ -0,0 +1,11 @@
+import { describe, it, expect } from 'vitest';
+import mapValues from './mapValues';
+
+describe('mapValues', () => {
+  it('maps values', () => {
+    const user = { id: 1, name: 'A' };
+    const lengths = mapValues((value) => String(value).length)(user);
+
+    expect(lengths).toEqual({ id: 1, name: 1 });
+  });
+});

package/src/implement/object/mapValues.ts

@@ -0,0 +1,16 @@
+/**
+ * mapValues - 값만 변환
+ */
+function mapValues<T extends object, R>(
+  fn: (value: T[keyof T]) => R
+): (obj: T) => Record<keyof T, R> {
+  return (obj: T) => {
+    const result: Record<keyof T, R> = {} as Record<keyof T, R>;
+    for (const [key, value] of Object.entries(obj) as Array<[keyof T, T[keyof T]]>) {
+      result[key] = fn(value);
+    }
+    return result;
+  };
+}
+
+export default mapValues;