fp-pack 0.3.0 → 0.5.0

package/dist/skills/fp-pack.md

@@ -1,6 +1,6 @@
 # fp-pack AI Agent Skills
 
-Document Version: 0.3.0
+Document Version: 0.5.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.
 
@@ -519,13 +519,13 @@ const gradeToLetter = cond([
 ### 6.1 Type-Safety Tips (prop/ifElse/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`.
-- Use `from(value)` when you need a unary function that ignores input (handy for `ifElse` branches).
+- `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).
 - `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.
 
 ```typescript
-import { pipe, propOr, append, assoc, ifElse, cond, from } from 'fp-pack';
+import { pipe, propOr, append, assoc, ifElse, cond, from, filter, map } from 'fp-pack';
 
 // propOr keeps the type strict for array ops
 const addTodo = (text: string, state: AppState) =>
@@ -542,13 +542,21 @@ const toggleTodo = (id: string) => ifElse(
   (todo) => todo
 );
 
-// from is useful for constant branches
+// from is useful for constant branches - cleaner than () => value
 const statusLabel = ifElse(
   (score: number) => score >= 60,
-  from('pass'),
+  from('pass'),    // Constant value
   from('fail')
 );
 
+// Data-first pattern with from: inject data into pipeline
+const processData = pipe(
+  from([1, 2, 3, 4, 5]),
+  filter((n: number) => n % 2 === 0),
+  map(n => n * 2)
+);
+const result = processData(); // [4, 8]
+
 // cond still returns R | undefined, so coalesce if needed
 const grade = (score: number) =>
   cond([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fp-pack",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "description": "Functional programming utilities library for TypeScript",
   "keywords": [
@@ -73,7 +73,8 @@
     "preview": "vite preview",
     "test": "vitest",
     "test:ui": "vitest --ui",
-    "test:run": "vitest run",
+    "test:run": "pnpm test:types && vitest run",
+    "test:types": "tsc --noEmit",
     "clean": "pnpm clean:dist && pnpm clean:module",
     "clean:dist": "rm -rf dist docs/dist",
     "clean:module": "rm -rf dist docs/dist node_modules",

package/src/implement/async/pipeAsync.ts

@@ -1,3 +1,5 @@
+import type { FromFn } from '../composition/from';
+
 /** pipeAsync - 비동기 함수 합성 */
 type AsyncOrSync<A, R> = (a: A) => R | Promise<R>;
 type PipeInput<Fns extends AsyncOrSync<any, any>[]> = Fns extends [AsyncOrSync<infer A, any>, ...AsyncOrSync<any, any>[]]
@@ -11,7 +13,11 @@ type PipeOutput<Fns extends AsyncOrSync<any, any>[]> = Fns extends [AsyncOrSync<
       : never
     : never;
 type PipeAsync<Fns extends AsyncOrSync<any, any>[]> = (input: PipeInput<Fns>) => Promise<PipeOutput<Fns>>;
+type PipeAsyncFrom<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[]]> = (
+  input?: PipeInput<Fns>
+) => Promise<PipeOutput<Fns>>;
 
+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>>;
 function pipeAsync<A, B, C, R>(
@@ -40,6 +46,48 @@ function pipeAsync<A, B, C, D, E, F, R>(
   ef: AsyncOrSync<Awaited<E>, F>,
   fg: AsyncOrSync<Awaited<F>, R>
 ): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, D, E, F, G, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, D, E, F, G, H, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, D, E, F, G, H, I, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, D, E, F, G, H, I, J, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A) => Promise<Awaited<R>>;
 
 function pipeAsync<Fns extends [AsyncOrSync<any, any>, ...AsyncOrSync<any, any>[]]>(...funcs: Fns): PipeAsync<Fns>;
 function pipeAsync(...funcs: Array<AsyncOrSync<any, any>>): (value: any) => Promise<any>;

package/src/implement/async/pipeAsyncSideEffect.ts

@@ -1,3 +1,4 @@
+import type { FromFn } from '../composition/from';
 import SideEffect, { isSideEffect } from '../composition/sideEffect';
 
 /** pipeAsyncSideEffect - SideEffect를 허용하는 비동기 함수 합성 */
@@ -21,7 +22,13 @@ type Resolve<T> = T extends infer R ? R : never;
 type PipeAsyncSideEffect<Fns extends AsyncOrSync<any, any>[]> = (
   input: PipeInput<Fns> | SideEffect<any>
 ) => Promise<Resolve<PipeOutput<Fns>>>;
+type PipeAsyncSideEffectFrom<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[]]> = (
+  input?: PipeInput<Fns> | SideEffect<any>
+) => Promise<Resolve<PipeOutput<Fns>>>;
 
+function pipeAsyncSideEffect<Fns extends [FromFn<any>, ...AsyncOrSync<any, any>[]]>(
+  ...funcs: Fns
+): PipeAsyncSideEffectFrom<Fns>;
 function pipeAsyncSideEffect<A, R>(
   ab: AsyncOrSync<A, R>
 ): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
@@ -55,6 +62,48 @@ function pipeAsyncSideEffect<A, B, C, D, E, F, R>(
   ef: AsyncOrSync<Awaited<E>, F>,
   fg: AsyncOrSync<Awaited<F>, R>
 ): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<A, B, C, D, E, F, G, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<A, B, C, D, E, F, G, H, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<A, B, C, D, E, F, G, H, I, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<A, B, C, D, E, F, G, H, I, J, R>(
+  ab: AsyncOrSync<A, 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>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
 
 function pipeAsyncSideEffect<Fns extends [AsyncOrSync<any, any>, ...AsyncOrSync<any, any>[]]>(
   ...funcs: Fns

package/src/implement/async/pipeAsyncSideEffectStrict.ts

@@ -1,3 +1,4 @@
+import type { FromFn } from '../composition/from';
 import SideEffect, { isSideEffect } from '../composition/sideEffect';
 
 type AnyFn = (...args: any[]) => any;
@@ -43,6 +44,12 @@ type PipeAsyncSideEffectStrictUnary<Fns extends [AnyFn, ...AnyFn[]]> = {
     input: PipeInputStrict<Fns> | SideEffect<EIn>
   ): Promise<Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns> | EIn>>>;
 };
+type PipeAsyncSideEffectStrictUnaryOptional<Fns extends [AnyFn, ...AnyFn[]]> = {
+  (input?: PipeInputStrict<Fns>): Promise<Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>>;
+  <EIn>(
+    input?: PipeInputStrict<Fns> | SideEffect<EIn>
+  ): Promise<Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns> | EIn>>>;
+};
 
 type PipeAsyncSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]> = Fns extends [ZeroFn<any>, ...AnyFn[]]
   ? () => Promise<Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>>
@@ -97,6 +104,89 @@ function pipeAsyncSideEffectStrict<B, C, D, E, F, R>(
   AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
   AsyncOrSync<NonSideEffect<Awaited<F>>, R>
 ]>;
+function pipeAsyncSideEffectStrict<B, C, D, E, F, G, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, R>
+): PipeAsyncSideEffectStrict<[
+  ZeroFn<B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, R>
+]>;
+function pipeAsyncSideEffectStrict<B, C, D, E, F, G, H, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  hi: AsyncOrSync<NonSideEffect<Awaited<H>>, R>
+): PipeAsyncSideEffectStrict<[
+  ZeroFn<B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  AsyncOrSync<NonSideEffect<Awaited<H>>, R>
+]>;
+function pipeAsyncSideEffectStrict<B, C, D, E, F, G, H, I, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  hi: AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  ij: AsyncOrSync<NonSideEffect<Awaited<I>>, R>
+): PipeAsyncSideEffectStrict<[
+  ZeroFn<B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  AsyncOrSync<NonSideEffect<Awaited<I>>, R>
+]>;
+function pipeAsyncSideEffectStrict<B, C, D, E, F, G, H, I, J, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  hi: AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  ij: AsyncOrSync<NonSideEffect<Awaited<I>>, J>,
+  jk: AsyncOrSync<NonSideEffect<Awaited<J>>, R>
+): PipeAsyncSideEffectStrict<[
+  ZeroFn<B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  AsyncOrSync<NonSideEffect<Awaited<I>>, J>,
+  AsyncOrSync<NonSideEffect<Awaited<J>>, R>
+]>;
+function pipeAsyncSideEffectStrict<Fns extends [FromFn<any>, ...AnyFn[]]>(
+  ...funcs: Fns
+): PipeAsyncSideEffectStrictUnaryOptional<Fns>;
 function pipeAsyncSideEffectStrict<A, R>(
   ab: AsyncOrSync<A, R>
 ): PipeAsyncSideEffectStrict<[AsyncOrSync<A, R>]>;
@@ -152,6 +242,86 @@ function pipeAsyncSideEffectStrict<A, B, C, D, E, F, R>(
   AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
   AsyncOrSync<NonSideEffect<Awaited<F>>, R>
 ]>;
+function pipeAsyncSideEffectStrict<A, B, C, D, E, F, G, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, R>
+): PipeAsyncSideEffectStrict<[
+  AsyncOrSync<A, B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, R>
+]>;
+function pipeAsyncSideEffectStrict<A, B, C, D, E, F, G, H, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  hi: AsyncOrSync<NonSideEffect<Awaited<H>>, R>
+): PipeAsyncSideEffectStrict<[
+  AsyncOrSync<A, B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  AsyncOrSync<NonSideEffect<Awaited<H>>, R>
+]>;
+function pipeAsyncSideEffectStrict<A, B, C, D, E, F, G, H, I, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  hi: AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  ij: AsyncOrSync<NonSideEffect<Awaited<I>>, R>
+): PipeAsyncSideEffectStrict<[
+  AsyncOrSync<A, B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  AsyncOrSync<NonSideEffect<Awaited<I>>, R>
+]>;
+function pipeAsyncSideEffectStrict<A, B, C, D, E, F, G, H, I, J, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  ef: AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  fg: AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  gh: AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  hi: AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  ij: AsyncOrSync<NonSideEffect<Awaited<I>>, J>,
+  jk: AsyncOrSync<NonSideEffect<Awaited<J>>, R>
+): PipeAsyncSideEffectStrict<[
+  AsyncOrSync<A, B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, F>,
+  AsyncOrSync<NonSideEffect<Awaited<F>>, G>,
+  AsyncOrSync<NonSideEffect<Awaited<G>>, H>,
+  AsyncOrSync<NonSideEffect<Awaited<H>>, I>,
+  AsyncOrSync<NonSideEffect<Awaited<I>>, J>,
+  AsyncOrSync<NonSideEffect<Awaited<J>>, R>
+]>;
 
 function pipeAsyncSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]>(...funcs: Fns): PipeAsyncSideEffectStrict<Fns>;
 function pipeAsyncSideEffectStrict(...funcs: Array<AsyncOrSync<any, any>>) {

package/src/implement/composition/from.ts

@@ -1,8 +1,15 @@
 /**
  * from - 입력을 무시하고 고정 값을 반환
  */
-function from<T>(value: T) {
-  return <I>(_input: I) => value;
+export type FromFn<T> = {
+  <I>(_input: I): T;
+  readonly __from: true;
+};
+
+function from<T>(value: T): FromFn<T> {
+  const fn = (_input: unknown) => value;
+  Object.defineProperty(fn, '__from', { value: true });
+  return fn as FromFn<T>;
 }
 
 export default from;

package/src/implement/composition/pipe.ts

@@ -31,6 +31,48 @@ function pipe<B, C, D, E, F, R>(
   ef: UnaryFn<E, F>,
   fg: UnaryFn<F, R>
 ): () => R;
+function pipe<B, C, D, E, F, G, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, R>
+): () => R;
+function pipe<B, C, D, E, F, G, H, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, H>,
+  hi: UnaryFn<H, R>
+): () => R;
+function pipe<B, C, D, E, F, G, H, I, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, H>,
+  hi: UnaryFn<H, I>,
+  ij: UnaryFn<I, R>
+): () => R;
+function pipe<B, C, D, E, F, G, H, I, J, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, H>,
+  hi: UnaryFn<H, I>,
+  ij: UnaryFn<I, J>,
+  jk: UnaryFn<J, R>
+): () => R;
 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;
@@ -55,6 +97,48 @@ function pipe<A, B, C, D, E, F, R>(
   ef: UnaryFn<E, F>,
   fg: UnaryFn<F, R>
 ): (a: A) => R;
+function pipe<A, B, C, D, E, F, G, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, R>
+): (a: A) => R;
+function pipe<A, B, C, D, E, F, G, H, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, H>,
+  hi: UnaryFn<H, R>
+): (a: A) => R;
+function pipe<A, B, C, D, E, F, G, H, I, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, H>,
+  hi: UnaryFn<H, I>,
+  ij: UnaryFn<I, R>
+): (a: A) => R;
+function pipe<A, B, C, D, E, F, G, H, I, J, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, F>,
+  fg: UnaryFn<F, G>,
+  gh: UnaryFn<G, H>,
+  hi: UnaryFn<H, I>,
+  ij: UnaryFn<I, J>,
+  jk: UnaryFn<J, 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;