fp-pack 0.1.0 → 0.2.0

package/dist/skills/fp-pack.md

@@ -1,6 +1,6 @@
 # fp-pack AI Agent Skills
 
-Document Version: 0.1.0
+Document Version: 0.2.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.
 
@@ -11,7 +11,7 @@ fp-pack is a TypeScript functional programming library focused on:
 1. **Function Composition**: Use `pipe` and `pipeAsync` as the primary tools for combining operations
 2. **Declarative Code**: Prefer function composition over imperative loops and mutations
 3. **No Monad Pattern**: Traditional FP monads (Option, Either, etc.) are NOT used - they don't compose well with `pipe`
-4. **SideEffect Pattern**: Handle errors and side effects using `SideEffect` with `pipeSideEffect` / `pipeAsyncSideEffect` pipelines
+4. **SideEffect Pattern**: Handle errors and side effects using `SideEffect` with `pipeSideEffect` / `pipeAsyncSideEffect` pipelines (use `pipeSideEffectStrict` / `pipeAsyncSideEffectStrict` for strict unions)
 5. **Lazy Evaluation**: Use `stream/*` functions for efficient iterable processing
 
 ## Core Composition Functions
@@ -43,7 +43,7 @@ const processUsers = (users: User[]) => {
 };
 ```
 
-> For SideEffect-based early exits, use `pipeSideEffect`.
+> For SideEffect-based early exits, use `pipeSideEffect` (or `pipeSideEffectStrict` when you want strict unions).
 
 ### pipeAsync - Asynchronous Function Composition
 
@@ -67,7 +67,7 @@ const fetchUserData = async (userId: string) => {
 };
 ```
 
-> For SideEffect-aware async pipelines, use `pipeAsyncSideEffect`.
+> For SideEffect-aware async pipelines, use `pipeAsyncSideEffect` (or `pipeAsyncSideEffectStrict` for strict unions).
 
 ## SideEffect Pattern - For Special Cases Only
 
@@ -79,6 +79,7 @@ const fetchUserData = async (userId: string) => {
 - Optional chaining patterns
 
 For regular error handling, standard try-catch or error propagation is perfectly fine.
+If you want precise SideEffect unions across branches, use `pipeSideEffectStrict` / `pipeAsyncSideEffectStrict`.
 
 ```typescript
 // MOST CASES: Just use pipe with regular error handling
@@ -201,6 +202,7 @@ const result = Array.from({ length: 1000000 }, (_, i) => i + 1)
 ### Composition
 - `pipe` - Left-to-right function composition (sync)
 - `pipeSideEffect` - Left-to-right composition with SideEffect short-circuiting
+- `pipeSideEffectStrict` - SideEffect composition with strict effect unions
 - `compose` - Right-to-left function composition
 - `curry` - Curry a function
 - `partial` - Partial application
@@ -208,6 +210,7 @@ const result = Array.from({ length: 1000000 }, (_, i) => i + 1)
 - `complement` - Logical negation
 - `identity` - Return input unchanged
 - `constant` - Always return the same value
+- `from` - Ignore input and return a fixed value
 - `tap` - Execute side effect and return original value
 - `once` - Execute function only once
 - `memoize` - Cache function results
@@ -219,6 +222,7 @@ const result = Array.from({ length: 1000000 }, (_, i) => i + 1)
 ### Async
 - `pipeAsync` - Async function composition
 - `pipeAsyncSideEffect` - Async composition with SideEffect short-circuiting
+- `pipeAsyncSideEffectStrict` - Async SideEffect composition with strict effect unions
 - `delay` - Delay execution
 - `timeout` - Add timeout to promise
 - `retry` - Retry failed operations
@@ -386,8 +390,10 @@ Most data transformations are pure and don't need SideEffect handling. Use `pipe
 - **`pipeAsync`** - Async, **pure** transformations (99% of cases)
 - **`pipeSideEffect`** - **Only when you need** SideEffect short-circuiting (sync)
 - **`pipeAsyncSideEffect`** - **Only when you need** SideEffect short-circuiting (async)
+- **`pipeSideEffectStrict`** - Sync SideEffect pipelines with strict effect unions
+- **`pipeAsyncSideEffectStrict`** - Async SideEffect pipelines with strict effect unions
 
-**Important:** `pipe` and `pipeAsync` are for **pure** functions only—they don't handle `SideEffect`. If your pipeline can return `SideEffect`, use `pipeSideEffect` or `pipeAsyncSideEffect` instead.
+**Important:** `pipe` and `pipeAsync` are for **pure** functions only—they don't handle `SideEffect`. If your pipeline can return `SideEffect`, use `pipeSideEffect` or `pipeAsyncSideEffect` instead. Choose the strict variants when you need precise unions for SideEffect results.
 
 ```typescript
 // Sync: use pipe
@@ -408,7 +414,7 @@ const processUsers = pipeAsync(
 
 **🔄 Critical Rule: SideEffect Contagion**
 
-Once you use `pipeSideEffect` or `pipeAsyncSideEffect`, the result is **always `T | SideEffect`** (or `Promise<T | SideEffect>` for async).
+Once you use `pipeSideEffect` or `pipeAsyncSideEffect`, the result is **always `T | SideEffect`** (or `Promise<T | SideEffect>` for async). The same rule applies to strict variants.
 
 If you want to continue composing this result, you **MUST** keep using SideEffect-aware pipes. You **CANNOT** switch back to `pipe` or `pipeAsync` because they don't handle `SideEffect`.
 
@@ -510,6 +516,47 @@ 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).
+- `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';
+
+// propOr keeps the type strict for array ops
+const addTodo = (text: string, state: AppState) =>
+  pipe(
+    propOr([], 'todos'),
+    append(createTodo(text)),
+    (todos) => assoc('todos', todos, state)
+  )(state);
+
+// ifElse expects functions, not values
+const toggleTodo = (id: string) => ifElse(
+  (todo: Todo) => todo.id === id,
+  assoc('completed', true),
+  (todo) => todo
+);
+
+// from is useful for constant branches
+const statusLabel = ifElse(
+  (score: number) => score >= 60,
+  from('pass'),
+  from('fail')
+);
+
+// cond still returns R | undefined, so coalesce if needed
+const grade = (score: number) =>
+  cond([
+    [(n: number) => n >= 90, () => 'A'],
+    [() => true, () => 'F']
+  ])(score) ?? 'F';
+```
+
 ### 7. Object Transformations
 
 ```typescript
@@ -610,18 +657,19 @@ const updateUser = assoc('lastLogin', new Date());
 ### Import Paths
 - Main functions: `import { pipe, map, filter } from 'fp-pack'`
 - Async: `import { pipeAsync, delay, retry } from 'fp-pack'`
-- SideEffect: `import { pipeSideEffect, pipeAsyncSideEffect, SideEffect } from 'fp-pack'`
+- SideEffect: `import { pipeSideEffect, pipeSideEffectStrict, pipeAsyncSideEffect, pipeAsyncSideEffectStrict, SideEffect } from 'fp-pack'`
 - Stream: `import { map, filter, toArray } from 'fp-pack/stream'`
 
 ### When to Use What
 - **Pure sync transformations**: `pipe` + array/object functions
 - **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
 - **Large datasets**: `stream/*` functions
 - **Conditionals**: `ifElse`, `when`, `unless`, `cond`
-- **Object access**: `prop`, `path`, `pick`, `omit`
+- **Object access**: `prop`, `propStrict`, `path`, `pick`, `omit`
 - **Object updates**: `assoc`, `merge`, `evolve`
 
 ## UI Framework Integration Patterns

package/package.json

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

package/src/implement/async/index.ts

@@ -1,5 +1,6 @@
 export { default as pipeAsync } from './pipeAsync';
 export { default as pipeAsyncSideEffect } from './pipeAsyncSideEffect';
+export { default as pipeAsyncSideEffectStrict } from './pipeAsyncSideEffectStrict';
 export { default as delay } from './delay';
 export { default as timeout } from './timeout';
 export { default as retry } from './retry';

package/src/implement/async/pipeAsyncSideEffectStrict.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import pipeAsyncSideEffectStrict from './pipeAsyncSideEffectStrict';
+import SideEffect from '../composition/sideEffect';
+
+describe('pipeAsyncSideEffectStrict', () => {
+  it('short-circuits when SideEffect is returned', async () => {
+    const effect = new SideEffect(() => 'effect');
+    const stop = async (_value: number) => effect;
+    const after = async (_value: number) => _value + 1;
+
+    const fn = pipeAsyncSideEffectStrict(async (n: number) => n + 1, stop, after);
+    const result = await fn(1);
+
+    expect(result).toBe(effect);
+  });
+
+  it('returns SideEffect inputs without executing the pipeline', async () => {
+    const effect = new SideEffect(() => 'effect');
+    const fn = pipeAsyncSideEffectStrict(async (n: number) => n + 1);
+
+    await expect(fn(effect)).resolves.toBe(effect);
+  });
+});

package/src/implement/async/pipeAsyncSideEffectStrict.ts

@@ -0,0 +1,140 @@
+import SideEffect, { isSideEffect } from '../composition/sideEffect';
+
+type AnyFn = (...args: any[]) => any;
+type MaybeSideEffect<T, E> = T | SideEffect<E>;
+type NonSideEffect<T> = Exclude<T, SideEffect<any>>;
+type AsyncOrSync<A, R> = (a: A) => R | Promise<R>;
+type ZeroFn<R> = () => R | Promise<R>;
+
+type EffectOfReturn<R> = R extends SideEffect<infer E> ? E : never;
+type EffectOfFn<F> = F extends (...args: any[]) => infer R ? EffectOfReturn<Awaited<R>> : never;
+type EffectsOf<Fns extends AnyFn[]> = EffectOfFn<Fns[number]>;
+
+type PipeValueOutputUnary<Fns extends AsyncOrSync<any, any>[]> = Fns extends [AsyncOrSync<any, infer R>]
+  ? NonSideEffect<Awaited<R>>
+  : Fns extends [AsyncOrSync<any, infer R>, ...infer Rest]
+    ? Rest extends [AsyncOrSync<NonSideEffect<Awaited<R>>, any>, ...AsyncOrSync<any, any>[]]
+      ? PipeValueOutputUnary<Rest>
+      : never
+    : never;
+
+type PipeValueOutputStrict<Fns extends [AnyFn, ...AnyFn[]]> =
+  Fns extends [ZeroFn<infer R>]
+    ? NonSideEffect<Awaited<R>>
+    : Fns extends [ZeroFn<infer R>, ...infer Rest]
+      ? Rest extends [AsyncOrSync<NonSideEffect<Awaited<R>>, any>, ...AsyncOrSync<any, any>[]]
+        ? PipeValueOutputUnary<Rest>
+        : never
+      : Fns extends [AsyncOrSync<any, any>, ...AsyncOrSync<any, any>[]]
+        ? PipeValueOutputUnary<Fns>
+        : never;
+
+type PipeInputStrict<Fns extends [AnyFn, ...AnyFn[]]> = Fns extends [ZeroFn<any>, ...AnyFn[]]
+  ? never
+  : Fns extends [AsyncOrSync<infer A, any>, ...AnyFn[]]
+    ? A
+    : never;
+
+type Resolve<T> = T extends infer R ? R : never;
+
+type PipeAsyncSideEffectStrictUnary<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>>>>
+  : PipeAsyncSideEffectStrictUnary<Fns>;
+
+function pipeAsyncSideEffectStrict<R>(ab: ZeroFn<R>): PipeAsyncSideEffectStrict<[ZeroFn<R>]>;
+function pipeAsyncSideEffectStrict<B, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, R>
+): PipeAsyncSideEffectStrict<[ZeroFn<B>, AsyncOrSync<NonSideEffect<Awaited<B>>, R>]>;
+function pipeAsyncSideEffectStrict<B, C, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, R>
+): PipeAsyncSideEffectStrict<[ZeroFn<B>, AsyncOrSync<NonSideEffect<Awaited<B>>, C>, AsyncOrSync<NonSideEffect<Awaited<C>>, R>]>;
+function pipeAsyncSideEffectStrict<B, C, D, R>(
+  ab: ZeroFn<B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, R>
+): PipeAsyncSideEffectStrict<[
+  ZeroFn<B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, R>
+]>;
+function pipeAsyncSideEffectStrict<B, C, D, E, 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>>, R>
+): PipeAsyncSideEffectStrict<[
+  ZeroFn<B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, R>
+]>;
+function pipeAsyncSideEffectStrict<A, R>(
+  ab: AsyncOrSync<A, R>
+): PipeAsyncSideEffectStrict<[AsyncOrSync<A, R>]>;
+function pipeAsyncSideEffectStrict<A, B, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, R>
+): PipeAsyncSideEffectStrict<[AsyncOrSync<A, B>, AsyncOrSync<NonSideEffect<Awaited<B>>, R>]>;
+function pipeAsyncSideEffectStrict<A, B, C, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, R>
+): PipeAsyncSideEffectStrict<[
+  AsyncOrSync<A, B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, R>
+]>;
+function pipeAsyncSideEffectStrict<A, B, C, D, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  cd: AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  de: AsyncOrSync<NonSideEffect<Awaited<D>>, R>
+): PipeAsyncSideEffectStrict<[
+  AsyncOrSync<A, B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, R>
+]>;
+function pipeAsyncSideEffectStrict<A, B, C, D, E, 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>>, R>
+): PipeAsyncSideEffectStrict<[
+  AsyncOrSync<A, B>,
+  AsyncOrSync<NonSideEffect<Awaited<B>>, C>,
+  AsyncOrSync<NonSideEffect<Awaited<C>>, D>,
+  AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
+  AsyncOrSync<NonSideEffect<Awaited<E>>, R>
+]>;
+
+function pipeAsyncSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]>(...funcs: Fns): PipeAsyncSideEffectStrict<Fns>;
+function pipeAsyncSideEffectStrict(...funcs: Array<AsyncOrSync<any, any>>) {
+  return async (value?: any) => {
+    let acc = value;
+    for (const fn of funcs) {
+      if (isSideEffect(acc)) {
+        return acc;
+      }
+      acc = await fn(acc);
+    }
+    return acc;
+  };
+}
+
+export default pipeAsyncSideEffectStrict;

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

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import from from './from';
+
+describe('from', () => {
+  it('returns the same value regardless of input', () => {
+    const getFive = from(5);
+    expect(getFive('x')).toBe(5);
+    expect(getFive(123)).toBe(5);
+  });
+
+  it('preserves reference identity', () => {
+    const obj = { a: 1 };
+    const getObj = from(obj);
+    expect(getObj(null)).toBe(obj);
+  });
+});

package/src/implement/composition/from.ts

@@ -0,0 +1,8 @@
+/**
+ * from - 입력을 무시하고 고정 값을 반환
+ */
+function from<T>(value: T) {
+  return <I>(_input: I) => value;
+}
+
+export default from;

package/src/implement/composition/index.ts

@@ -1,5 +1,6 @@
 export { default as pipe } from './pipe';
 export { default as pipeSideEffect } from './pipeSideEffect';
+export { default as pipeSideEffectStrict } from './pipeSideEffectStrict';
 export { default as compose } from './compose';
 export { default as curry } from './curry';
 export { default as partial } from './partial';
@@ -7,6 +8,7 @@ export { default as flip } from './flip';
 export { default as complement } from './complement';
 export { default as identity } from './identity';
 export { default as constant } from './constant';
+export { default as from } from './from';
 export { default as tap } from './tap';
 export { default as once } from './once';
 export { default as memoize } from './memoize';

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

@@ -28,4 +28,12 @@ describe('pipe', () => {
     expect(fn(5)).toBe(25);
   });
 
+  it('supports zero-arity starts', () => {
+    const start = () => 3;
+    const addOne = (n: number) => n + 1;
+    const fn = pipe(start, addOne);
+
+    expect(fn()).toBe(4);
+  });
+
 });

package/src/implement/composition/pipe.ts

@@ -1,4 +1,5 @@
 type UnaryFn<A, R> = (a: A) => R;
+type ZeroFn<R> = () => R;
 type PipeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, any>, ...UnaryFn<any, any>[]]
   ? A
   : never;
@@ -11,6 +12,17 @@ type PipeOutput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<any, inf
     : never;
 type Pipe<Fns extends UnaryFn<any, any>[]> = (input: PipeInput<Fns>) => PipeOutput<Fns>;
 
+function pipe<R>(ab: ZeroFn<R>): () => R;
+function pipe<B, R>(ab: ZeroFn<B>, bc: UnaryFn<B, R>): () => R;
+function pipe<B, C, R>(ab: ZeroFn<B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, R>): () => R;
+function pipe<B, C, D, R>(ab: ZeroFn<B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, R>): () => R;
+function pipe<B, C, D, E, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, 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;

package/src/implement/composition/pipe.type-test.ts

@@ -1,13 +1,17 @@
 import SideEffect from './sideEffect';
 import pipe from './pipe';
 import pipeSideEffect from './pipeSideEffect';
+import pipeSideEffectStrict from './pipeSideEffectStrict';
 import pipeAsync from '../async/pipeAsync';
 import pipeAsyncSideEffect from '../async/pipeAsyncSideEffect';
+import pipeAsyncSideEffectStrict from '../async/pipeAsyncSideEffectStrict';
 
 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 EffectUnion<T> = Extract<T, SideEffect<any>> extends SideEffect<infer E> ? E : never;
+type ValueUnion<T> = Exclude<T, SideEffect<any>>;
 
 export const sideEffectInput = SideEffect.of(() => 0);
 
@@ -52,3 +56,48 @@ type PipeAsyncExpected = (input: number | SideEffect<any>) => Promise<string | S
 export type PipeAsyncAcceptsSideEffectInput = Expect<
   Equal<typeof pipeAsyncWithSideEffectInput, PipeAsyncExpected>
 >;
+
+export const strictPipeSideEffect = pipeSideEffectStrict(
+  (value: number) => value + 1,
+  (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => (value > 2 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeSideEffectResult = strictPipeSideEffect(1);
+
+type StrictSideEffectEffects = EffectUnion<typeof strictPipeSideEffectResult>;
+type StrictSideEffectEffectsExpected = 'LOW' | 0;
+export type PipeSideEffectStrictEffects = Expect<Equal<StrictSideEffectEffects, StrictSideEffectEffectsExpected>>;
+
+type StrictSideEffectValue = ValueUnion<typeof strictPipeSideEffectResult>;
+type StrictSideEffectValueExpected = number;
+export type PipeSideEffectStrictValue = Expect<Equal<StrictSideEffectValue, StrictSideEffectValueExpected>>;
+
+export const strictPipeSideEffectInput = strictPipeSideEffect(SideEffect.of(() => 'INPUT' as const));
+
+type StrictSideEffectInputEffects = EffectUnion<typeof strictPipeSideEffectInput>;
+type StrictSideEffectInputEffectsExpected = 'LOW' | 0 | 'INPUT';
+export type PipeSideEffectStrictInputEffects = Expect<
+  Equal<StrictSideEffectInputEffects, StrictSideEffectInputEffectsExpected>
+>;
+
+export const strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
+  (value: number) => value + 1,
+  async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => (value > 2 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeAsyncSideEffectResult = strictPipeAsyncSideEffect(1);
+
+type StrictPipeAsyncResolved = Awaited<typeof strictPipeAsyncSideEffectResult>;
+type StrictPipeAsyncEffects = EffectUnion<StrictPipeAsyncResolved>;
+type StrictPipeAsyncEffectsExpected = 'LOW' | 0;
+export type PipeAsyncSideEffectStrictEffects = Expect<
+  Equal<StrictPipeAsyncEffects, StrictPipeAsyncEffectsExpected>
+>;
+
+type StrictPipeAsyncValue = ValueUnion<StrictPipeAsyncResolved>;
+type StrictPipeAsyncValueExpected = number;
+export type PipeAsyncSideEffectStrictValue = Expect<
+  Equal<StrictPipeAsyncValue, StrictPipeAsyncValueExpected>
+>;

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

@@ -20,4 +20,12 @@ describe('pipeSideEffect', () => {
 
     expect(fn(effect)).toBe(effect);
   });
+
+  it('supports zero-arity starts', () => {
+    const start = () => 3;
+    const addOne = (n: number) => n + 1;
+    const fn = pipeSideEffect(start, addOne);
+
+    expect(fn()).toBe(4);
+  });
 });

package/src/implement/composition/pipeSideEffect.ts

@@ -3,6 +3,7 @@ import SideEffect, { isSideEffect } from './sideEffect';
 type MaybeSideEffect<T> = T | SideEffect<any>;
 type NonSideEffect<T> = Exclude<T, SideEffect<any>>;
 type UnaryFn<A, R> = (a: A) => MaybeSideEffect<R>;
+type ZeroFn<R> = () => MaybeSideEffect<R>;
 type PipeInput<Fns extends UnaryFn<any, any>[]> = Fns extends [UnaryFn<infer A, any>, ...UnaryFn<any, any>[]]
   ? A
   : never;
@@ -18,6 +19,22 @@ type PipeSideEffect<Fns extends UnaryFn<any, any>[]> = (
   input: PipeInput<Fns> | SideEffect<any>
 ) => Resolve<PipeOutput<Fns>>;
 
+function pipeSideEffect<R>(ab: ZeroFn<R>): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, R>(ab: ZeroFn<B>, bc: UnaryFn<B, R>): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, R>(ab: ZeroFn<B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, R>): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, D, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, R>
+): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, D, E, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  ef: UnaryFn<E, R>
+): () => MaybeSideEffect<R>;
 function pipeSideEffect<A, R>(ab: UnaryFn<A, R>): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
 function pipeSideEffect<A, B, R>(
   ab: UnaryFn<A, B>,

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

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import pipeSideEffectStrict from './pipeSideEffectStrict';
+import SideEffect from './sideEffect';
+
+describe('pipeSideEffectStrict', () => {
+  it('short-circuits when SideEffect is returned', () => {
+    const effect = new SideEffect(() => 'effect');
+    const stop = (_value: number) => effect;
+    const after = (_value: number) => _value + 1;
+
+    const fn = pipeSideEffectStrict((n: number) => n + 1, stop, after);
+    const result = fn(1);
+
+    expect(result).toBe(effect);
+  });
+
+  it('returns SideEffect inputs without executing the pipeline', () => {
+    const effect = new SideEffect(() => 'effect');
+    const fn = pipeSideEffectStrict((n: number) => n + 1);
+
+    expect(fn(effect)).toBe(effect);
+  });
+});