fp-pack 0.5.0 → 0.7.0

package/dist/skills/fp-pack/SKILL.md

@@ -7,7 +7,7 @@ metadata:
 
 # fp-pack AI Agent Skills
 
-Document Version: 0.5.0
+Document Version: 0.7.0
 
 This document provides guidelines for AI coding assistants when working in projects that use fp-pack. Follow these instructions to write clean, declarative, functional code using fp-pack's utilities.
 
@@ -129,7 +129,7 @@ const finalValue = runPipeResult(processDataPipeline(input));
 **Key SideEffect functions:**
 - `SideEffect.of(fn, label?)` - Create a side effect container
 - `isSideEffect(value)` - Type guard for **runtime checking** whether a value is a SideEffect
-- `runPipeResult<T, R>(result)` - Execute SideEffect or return value (call **OUTSIDE** pipelines, provide generics for type safety). **⚠️ CRITICAL:** `runPipeResult<T, R=any>` has default `R=any`, so using it without generics returns `any` type. Always provide generics for type safety
+- `runPipeResult<T, R>(result)` - Execute SideEffect or return value (call **OUTSIDE** pipelines). If the input type is precise, inference is preserved. If the input is widened to `SideEffect<any>` or `any`, the result becomes `any` unless you provide generics.
 - `matchSideEffect(result, { value, effect })` - Pattern match on result
 
 **Type-safe result handling:**
@@ -147,32 +147,34 @@ const processNumbers = pipeSideEffect(
 
 const result = processNumbers([1, 2, 3, 4, 5]);
 
-// ✅ CORRECT: Use isSideEffect for runtime checking + provide generics to runPipeResult
+// ✅ CORRECT: Use isSideEffect for runtime checking
 if (!isSideEffect(result)) {
   // TypeScript knows: result is number[]
   const sum: number = result.reduce((a, b) => a + b, 0);
 } else {
   // TypeScript knows: result is SideEffect<string>
-  // But runPipeResult still returns number[] | string (not fully narrowed)
-  const error = runPipeResult<number[], string>(result);  // error: number[] | string
+  // runPipeResult returns number[] | string (not fully narrowed)
+  const error = runPipeResult(result);  // number[] | string
 }
 
-// ❌ WRONG: runPipeResult without generics
-const value = runPipeResult(result);  // result: any (no type information!)
+// ⚠️ If the result type is widened to SideEffect<any>, inference is lost
+const widened: number[] | SideEffect<any> = result;
+const unsafeValue = runPipeResult(widened);  // number[] | any
 
-// ✅ CORRECT: Provide generics to runPipeResult
-const value = runPipeResult<number[], string>(result);  // result: number[] | string (union type - safe but not narrowed)
+// ✅ CORRECT: Provide generics to recover a safe union
+const safeValue = runPipeResult<number[], string>(result);  // result: number[] | string (union type - safe but not narrowed)
 ```
 
 **⚠️ CRITICAL: runPipeResult Type Safety**
 
 `runPipeResult<T, R=any>` has a default type parameter `R=any`. This means:
 
-- ❌ **Without generics**: `const result = runPipeResult(pipeline(data));` returns `any` type (unsafe!)
-- ✅ **With generics**: `runPipeResult<SuccessType, ErrorType>(result)` returns union type `SuccessType | ErrorType` (type-safe)
-- ✅ **With isSideEffect**: Use for runtime checking whether a value is SideEffect
+- ✅ **Precise input types**: `T | SideEffect<'E'>` preserves `T | 'E'` without extra annotations.
+- ⚠️ **Widened inputs**: `T | SideEffect<any>` (or `any`) collapses to `any`.
+- ✅ **With generics**: `runPipeResult<SuccessType, ErrorType>(result)` restores a safe union when inference is lost.
+- ✅ **With isSideEffect**: Prefer for runtime narrowing when you need branch-specific types.
 
-**Always provide generics to `runPipeResult`** for type safety. Use `isSideEffect` for runtime type checking.
+Provide generics when inference is lost; prefer `isSideEffect` for precise narrowing.
 
 ## Stream Functions - Lazy Iterable Processing
 
@@ -219,6 +221,7 @@ const result = Array.from({ length: 1000000 }, (_, i) => i + 1)
 - `constant` - Always return the same value
 - `from` - Ignore input and return a fixed value
 - `tap` - Execute side effect and return original value
+- `tap0` - Execute side effect without input
 - `once` - Execute function only once
 - `memoize` - Cache function results
 - `SideEffect` - Side effect container
@@ -527,7 +530,7 @@ const gradeToLetter = cond([
 
 - `prop` returns `T[K] | undefined`. Use `propOr` (or guard) before array operations.
 - `ifElse` expects **functions** for both branches. If you already have a value, wrap it: `() => value` or use `from(value)` for cleaner constant branches.
-- Use `from(value)` when you need a unary function that ignores input (handy for `ifElse`/`cond` branches and data-first patterns).
+- Use `from(value)` when you need a unary function that ignores input (handy for `ifElse`/`cond` branches and data-first patterns). Pipelines that start with `from(...)` can be called without an initial input value.
 - `cond` returns `R | undefined`. Add a default branch and coalesce when you need a strict result.
 - In `pipeSideEffect`, keep step return types aligned to avoid wide unions.
 
@@ -680,8 +683,8 @@ const updateUser = assoc('lastLogin', new Date());
 - **Pure async operations**: `pipeAsync`
 - **Error handling with SideEffect**: `pipeSideEffect` (sync) / `pipeAsyncSideEffect` (async)
 - **Strict SideEffect unions**: `pipeSideEffectStrict` (sync) / `pipeAsyncSideEffectStrict` (async)
-- **Type-safe result handling**: `isSideEffect` for precise type narrowing (⚠️ **ALWAYS prefer this over bare `runPipeResult`** to avoid `any` types)
-- **Execute SideEffect**: `runPipeResult` (call OUTSIDE pipelines). **⚠️ CRITICAL:** Returns `any` type without type narrowing due to default `R=any` parameter
+- **Type-safe result handling**: `isSideEffect` for precise type narrowing (prefer this when you need branch-specific types)
+- **Execute SideEffect**: `runPipeResult` (call OUTSIDE pipelines). If the input is widened to `SideEffect<any>`/`any`, the result becomes `any`; provide generics to recover
 - **Large datasets**: `stream/*` functions
 - **Conditionals**: `ifElse`, `when`, `unless`, `cond`
 - **Object access**: `prop`, `propStrict`, `path`, `pick`, `omit`

package/dist/skills/fp-pack.md

@@ -1,6 +1,6 @@
 # fp-pack AI Agent Skills
 
-Document Version: 0.5.0
+Document Version: 0.7.0
 
 This document provides guidelines for AI coding assistants when working in projects that use fp-pack. Follow these instructions to write clean, declarative, functional code using fp-pack's utilities.
 
@@ -122,7 +122,7 @@ const finalValue = runPipeResult(processDataPipeline(input));
 **Key SideEffect functions:**
 - `SideEffect.of(fn, label?)` - Create a side effect container
 - `isSideEffect(value)` - Type guard for **runtime checking** whether a value is a SideEffect
-- `runPipeResult<T, R>(result)` - Execute SideEffect or return value (call **OUTSIDE** pipelines, provide generics for type safety). **⚠️ CRITICAL:** `runPipeResult<T, R=any>` has default `R=any`, so using it without generics returns `any` type. Always provide generics for type safety
+- `runPipeResult<T, R>(result)` - Execute SideEffect or return value (call **OUTSIDE** pipelines). If the input type is precise, inference is preserved. If the input is widened to `SideEffect<any>` or `any`, the result becomes `any` unless you provide generics.
 - `matchSideEffect(result, { value, effect })` - Pattern match on result
 
 **Type-safe result handling:**
@@ -140,32 +140,34 @@ const processNumbers = pipeSideEffect(
 
 const result = processNumbers([1, 2, 3, 4, 5]);
 
-// ✅ CORRECT: Use isSideEffect for runtime checking + provide generics to runPipeResult
+// ✅ CORRECT: Use isSideEffect for runtime checking
 if (!isSideEffect(result)) {
   // TypeScript knows: result is number[]
   const sum: number = result.reduce((a, b) => a + b, 0);
 } else {
   // TypeScript knows: result is SideEffect<string>
-  // But runPipeResult still returns number[] | string (not fully narrowed)
-  const error = runPipeResult<number[], string>(result);  // error: number[] | string
+  // runPipeResult returns number[] | string (not fully narrowed)
+  const error = runPipeResult(result);  // number[] | string
 }
 
-// ❌ WRONG: runPipeResult without generics
-const value = runPipeResult(result);  // result: any (no type information!)
+// ⚠️ If the result type is widened to SideEffect<any>, inference is lost
+const widened: number[] | SideEffect<any> = result;
+const unsafeValue = runPipeResult(widened);  // number[] | any
 
-// ✅ CORRECT: Provide generics to runPipeResult
-const value = runPipeResult<number[], string>(result);  // result: number[] | string (union type - safe but not narrowed)
+// ✅ CORRECT: Provide generics to recover a safe union
+const safeValue = runPipeResult<number[], string>(result);  // result: number[] | string (union type - safe but not narrowed)
 ```
 
 **⚠️ CRITICAL: runPipeResult Type Safety**
 
 `runPipeResult<T, R=any>` has a default type parameter `R=any`. This means:
 
-- ❌ **Without generics**: `const result = runPipeResult(pipeline(data));` returns `any` type (unsafe!)
-- ✅ **With generics**: `runPipeResult<SuccessType, ErrorType>(result)` returns union type `SuccessType | ErrorType` (type-safe)
-- ✅ **With isSideEffect**: Use for runtime checking whether a value is SideEffect
+- ✅ **Precise input types**: `T | SideEffect<'E'>` preserves `T | 'E'` without extra annotations.
+- ⚠️ **Widened inputs**: `T | SideEffect<any>` (or `any`) collapses to `any`.
+- ✅ **With generics**: `runPipeResult<SuccessType, ErrorType>(result)` restores a safe union when inference is lost.
+- ✅ **With isSideEffect**: Prefer for runtime narrowing when you need branch-specific types.
 
-**Always provide generics to `runPipeResult`** for type safety. Use `isSideEffect` for runtime type checking.
+Provide generics when inference is lost; prefer `isSideEffect` for precise narrowing.
 
 ## Stream Functions - Lazy Iterable Processing
 
@@ -212,6 +214,7 @@ const result = Array.from({ length: 1000000 }, (_, i) => i + 1)
 - `constant` - Always return the same value
 - `from` - Ignore input and return a fixed value
 - `tap` - Execute side effect and return original value
+- `tap0` - Execute side effect without input
 - `once` - Execute function only once
 - `memoize` - Cache function results
 - `SideEffect` - Side effect container
@@ -520,7 +523,7 @@ const gradeToLetter = cond([
 
 - `prop` returns `T[K] | undefined`. Use `propOr` (or guard) before array operations.
 - `ifElse` expects **functions** for both branches. If you already have a value, wrap it: `() => value` or use `from(value)` for cleaner constant branches.
-- Use `from(value)` when you need a unary function that ignores input (handy for `ifElse`/`cond` branches and data-first patterns).
+- Use `from(value)` when you need a unary function that ignores input (handy for `ifElse`/`cond` branches and data-first patterns). Pipelines that start with `from(...)` can be called without an initial input value.
 - `cond` returns `R | undefined`. Add a default branch and coalesce when you need a strict result.
 - In `pipeSideEffect`, keep step return types aligned to avoid wide unions.
 
@@ -673,8 +676,8 @@ const updateUser = assoc('lastLogin', new Date());
 - **Pure async operations**: `pipeAsync`
 - **Error handling with SideEffect**: `pipeSideEffect` (sync) / `pipeAsyncSideEffect` (async)
 - **Strict SideEffect unions**: `pipeSideEffectStrict` (sync) / `pipeAsyncSideEffectStrict` (async)
-- **Type-safe result handling**: `isSideEffect` for precise type narrowing (⚠️ **ALWAYS prefer this over bare `runPipeResult`** to avoid `any` types)
-- **Execute SideEffect**: `runPipeResult` (call OUTSIDE pipelines). **⚠️ CRITICAL:** Returns `any` type without type narrowing due to default `R=any` parameter
+- **Type-safe result handling**: `isSideEffect` for precise type narrowing (prefer this when you need branch-specific types)
+- **Execute SideEffect**: `runPipeResult` (call OUTSIDE pipelines). If the input is widened to `SideEffect<any>`/`any`, the result becomes `any`; provide generics to recover
 - **Large datasets**: `stream/*` functions
 - **Conditionals**: `ifElse`, `when`, `unless`, `cond`
 - **Object access**: `prop`, `propStrict`, `path`, `pick`, `omit`

package/dist/stream/index.d.ts

@@ -21,4 +21,5 @@ export { default as toArray } from './toArray';
 export { default as toAsync } from './toAsync';
 export { default as zip } from './zip';
 export { default as zipWith } from './zipWith';
+export type { AnyIterable, AnyIterableInput, PromiseLikeValue } from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/stream/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stream/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stream/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fp-pack",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "Functional programming utilities library for TypeScript",
   "keywords": [

package/src/implement/async/pipeAsync.ts

@@ -2,6 +2,7 @@ import type { FromFn } from '../composition/from';
 
 /** pipeAsync - 비동기 함수 합성 */
 type AsyncOrSync<A, R> = (a: A) => R | Promise<R>;
+type ZeroFn<R> = () => R | Promise<R>;
 type PipeInput<Fns extends AsyncOrSync<any, any>[]> = Fns extends [AsyncOrSync<infer A, any>, ...AsyncOrSync<any, any>[]]
   ? A
   : never;
@@ -17,6 +18,76 @@ type PipeAsyncFrom<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[]]> = (
   input?: PipeInput<Fns>
 ) => Promise<PipeOutput<Fns>>;
 
+function pipeAsync<R>(ab: ZeroFn<R>): () => Promise<Awaited<R>>;
+function pipeAsync<B, R>(ab: ZeroFn<B>, bc: AsyncOrSync<Awaited<B>, R>): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, R>
+): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, D, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, R>
+): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, D, E, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, R>
+): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, D, E, F, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, R>
+): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, D, E, F, G, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, R>
+): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, D, E, F, G, H, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, R>
+): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, D, E, F, G, H, I, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, I>,
+  ij: AsyncOrSync<Awaited<I>, R>
+): () => Promise<Awaited<R>>;
+function pipeAsync<B, C, D, E, F, G, H, I, J, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, I>,
+  ij: AsyncOrSync<Awaited<I>, J>,
+  jk: AsyncOrSync<Awaited<J>, R>
+): () => Promise<Awaited<R>>;
 function pipeAsync<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[]]>(...funcs: Fns): PipeAsyncFrom<Fns>;
 function pipeAsync<A, R>(ab: AsyncOrSync<A, R>): (a: A) => Promise<Awaited<R>>;
 function pipeAsync<A, B, R>(ab: AsyncOrSync<A, B>, bc: AsyncOrSync<Awaited<B>, R>): (a: A) => Promise<Awaited<R>>;

package/src/implement/async/pipeAsyncSideEffect.ts

@@ -5,6 +5,7 @@ import SideEffect, { isSideEffect } from '../composition/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 ZeroFn<R> = () => MaybeSideEffect<R> | Promise<MaybeSideEffect<R>>;
 type PipeInput<Fns extends AsyncOrSync<any, any>[]> = Fns extends [
   AsyncOrSync<infer A, any>,
   ...AsyncOrSync<any, any>[]
@@ -29,6 +30,79 @@ type PipeAsyncSideEffectFrom<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[
 function pipeAsyncSideEffect<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[]]>(
   ...funcs: Fns
 ): PipeAsyncSideEffectFrom<Fns>;
+function pipeAsyncSideEffect<R>(ab: ZeroFn<R>): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, H, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, H, I, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, I>,
+  ij: AsyncOrSync<Awaited<I>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<B, C, D, E, F, G, H, I, J, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, G>,
+  gh: AsyncOrSync<Awaited<G>, H>,
+  hi: AsyncOrSync<Awaited<H>, I>,
+  ij: AsyncOrSync<Awaited<I>, J>,
+  jk: AsyncOrSync<Awaited<J>, R>
+): () => Promise<MaybeSideEffect<Awaited<R>>>;
 function pipeAsyncSideEffect<A, R>(
   ab: AsyncOrSync<A, R>
 ): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;

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

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import compose from './compose';
+import from from './from';
 
 describe('compose', () => {
   it('applies functions right-to-left', () => {
@@ -27,4 +28,17 @@ describe('compose', () => {
     expect(fn(4)).toBe(16);
   });
 
+  it('supports zero-arity tail functions', () => {
+    const addOne = (n: number) => n + 1;
+    const fn = compose(addOne, () => 2);
+    expect(fn()).toBe(3);
+  });
+
+  it('supports from() as a constant source', () => {
+    const addOne = (n: number) => n + 1;
+    const fn = compose(addOne, from(2));
+    expect(fn()).toBe(3);
+    expect(fn(10)).toBe(3);
+  });
+
 });

package/src/implement/composition/compose.ts

@@ -2,46 +2,158 @@
  * compose - 함수를 우→좌로 합성
  */
 
+import type { FromFn } from './from';
+
 type UnaryFn<A, R> = (a: A) => R;
+type ZeroFn<R> = () => 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>
+type ComposeOutput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<any, infer R>]
+  ? 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>
+    ? Rest extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]
+      ? ComposeOutput<Rest> extends A
+        ? R
         : never
       : never
     : never;
-type Compose<Fns extends UnaryFn<any, any>[]> = (input: ComposeInput<Fns>) => ComposeChain<Fns> extends UnaryFn<
-  any,
-  infer R
->
-  ? R
-  : never;
+type Compose<Fns extends UnaryFn<any, any>[]> = (input: ComposeInput<Fns>) => ComposeOutput<Fns>;
+type ComposeFrom<Fns extends [...UnaryFn<any, any>[], FromFn<any>]> = (input?: ComposeInput<Fns>) => ComposeOutput<Fns>;
+
+function compose<R>(ab: ZeroFn<R>): () => R;
+function compose<B, R>(ab: UnaryFn<B, R>, bc: ZeroFn<B>): () => R;
+function compose<C, B, R>(ab: UnaryFn<B, R>, bc: UnaryFn<C, B>, cd: ZeroFn<C>): () => R;
+function compose<D, C, B, R>(ab: UnaryFn<B, R>, bc: UnaryFn<C, B>, cd: UnaryFn<D, C>, de: ZeroFn<D>): () => R;
+function compose<E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: ZeroFn<E>
+): () => R;
+function compose<F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: ZeroFn<F>
+): () => R;
+function compose<G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: ZeroFn<G>
+): () => R;
+function compose<H, G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: UnaryFn<H, G>,
+  hi: ZeroFn<H>
+): () => R;
+function compose<I, H, G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: UnaryFn<H, G>,
+  hi: UnaryFn<I, H>,
+  ij: ZeroFn<I>
+): () => R;
+function compose<J, I, H, G, F, E, D, C, B, R>(
+  ab: UnaryFn<B, R>,
+  bc: UnaryFn<C, B>,
+  cd: UnaryFn<D, C>,
+  de: UnaryFn<E, D>,
+  ef: UnaryFn<F, E>,
+  fg: UnaryFn<G, F>,
+  gh: UnaryFn<H, G>,
+  hi: UnaryFn<I, H>,
+  ij: UnaryFn<J, I>,
+  jk: ZeroFn<J>
+): () => R;
 
+function compose<Fns extends [...UnaryFn<any, any>[], FromFn<any>]>(...funcs: Fns): ComposeFrom<Fns>;
 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, R>(ab: UnaryFn<B, R>, bc: UnaryFn<A, B>): (a: A) => R;
+function compose<A, B, C, R>(ab: UnaryFn<C, R>, bc: UnaryFn<B, C>, cd: UnaryFn<A, B>): (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>
+  ab: UnaryFn<D, R>,
+  bc: UnaryFn<C, D>,
+  cd: UnaryFn<B, C>,
+  de: UnaryFn<A, B>
 ): (a: A) => R;
 function compose<A, B, C, D, E, R>(
-  ab: UnaryFn<A, B>,
-  bc: UnaryFn<B, C>,
+  ab: UnaryFn<E, R>,
+  bc: UnaryFn<D, E>,
   cd: UnaryFn<C, D>,
+  de: UnaryFn<B, C>,
+  ef: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, R>(
+  ab: UnaryFn<F, R>,
+  bc: UnaryFn<E, F>,
+  cd: UnaryFn<D, E>,
+  de: UnaryFn<C, D>,
+  ef: UnaryFn<B, C>,
+  fg: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, R>(
+  ab: UnaryFn<G, R>,
+  bc: UnaryFn<F, G>,
+  cd: UnaryFn<E, F>,
   de: UnaryFn<D, E>,
-  ef: UnaryFn<E, R>
+  ef: UnaryFn<C, D>,
+  fg: UnaryFn<B, C>,
+  gh: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, H, R>(
+  ab: UnaryFn<H, R>,
+  bc: UnaryFn<G, H>,
+  cd: UnaryFn<F, G>,
+  de: UnaryFn<E, F>,
+  ef: UnaryFn<D, E>,
+  fg: UnaryFn<C, D>,
+  gh: UnaryFn<B, C>,
+  hi: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, H, I, R>(
+  ab: UnaryFn<I, R>,
+  bc: UnaryFn<H, I>,
+  cd: UnaryFn<G, H>,
+  de: UnaryFn<F, G>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<D, E>,
+  gh: UnaryFn<C, D>,
+  hi: UnaryFn<B, C>,
+  ij: UnaryFn<A, B>
+): (a: A) => R;
+function compose<A, B, C, D, E, F, G, H, I, J, R>(
+  ab: UnaryFn<J, R>,
+  bc: UnaryFn<I, J>,
+  cd: UnaryFn<H, I>,
+  de: UnaryFn<G, H>,
+  ef: UnaryFn<F, G>,
+  fg: UnaryFn<E, F>,
+  gh: UnaryFn<D, E>,
+  hi: UnaryFn<C, D>,
+  ij: UnaryFn<B, C>,
+  jk: UnaryFn<A, B>
 ): (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>) {
+function compose(...funcs: Array<(...args: any[]) => any>) {
   return (value: any) => funcs.reduceRight((acc, fn) => fn(acc), value);
 }