fp-pack 0.6.0 → 0.7.0

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

@@ -25,6 +25,21 @@ export const purePipe = pipe(
 type PurePipeExpected = (input: number) => string;
 export type PipePureIsStrict = Expect<Equal<typeof purePipe, PurePipeExpected>>;
 
+export const purePipeZero = pipe(() => 3, (value: number) => value + 1);
+
+type PurePipeZeroExpected = () => number;
+export type PipePureZeroIsStrict = Expect<Equal<typeof purePipeZero, PurePipeZeroExpected>>;
+
+export const purePipeZeroValue = purePipeZero();
+
+type PurePipeZeroValueExpected = number;
+export type PipePureZeroValueIsStrict = Expect<Equal<typeof purePipeZeroValue, PurePipeZeroValueExpected>>;
+
+export const purePipeValue = purePipe(1);
+
+type PurePipeValueExpected = string;
+export type PipePureValueIsStrict = Expect<Equal<typeof purePipeValue, PurePipeValueExpected>>;
+
 export const purePipeSix = pipe(
   (value: number) => value + 1,
   (value) => value * 2,
@@ -78,6 +93,16 @@ export type PipeFromTenValueNoInputIsStrict = Expect<
   Equal<typeof pipeFromTenValueNoInput, PipeFromTenValueNoInputExpected>
 >;
 
+export const pipeFromNoInput = pipe(from(1));
+
+type PipeFromNoInputExpected = (input?: unknown) => number;
+export type PipeFromNoInputIsStrict = Expect<Equal<typeof pipeFromNoInput, PipeFromNoInputExpected>>;
+
+export const pipeFromNoInputValue = pipeFromNoInput();
+
+type PipeFromNoInputValueExpected = number;
+export type PipeFromNoInputValueIsStrict = Expect<Equal<typeof pipeFromNoInputValue, PipeFromNoInputValueExpected>>;
+
 export const pipeWithSideEffectInput = pipeSideEffect(
   (value: number) => value + 1,
   (value) => value * 2,
@@ -89,6 +114,25 @@ export const pipeWithSideEffectValue = pipeWithSideEffectInput(sideEffectInput);
 type PipeExpected = (input: number | SideEffect<any>) => string | SideEffect<any>;
 export type PipeAcceptsSideEffectInput = Expect<Equal<typeof pipeWithSideEffectInput, PipeExpected>>;
 
+export const pipeSideEffectZero = pipeSideEffect(() => 1, (value: number) => value + 1);
+
+type PipeSideEffectZeroExpected = () => number | SideEffect<any>;
+export type PipeSideEffectZeroIsStrict = Expect<Equal<typeof pipeSideEffectZero, PipeSideEffectZeroExpected>>;
+
+export const pipeSideEffectZeroValue = pipeSideEffectZero();
+
+type PipeSideEffectZeroValueExpected = number | SideEffect<any>;
+export type PipeSideEffectZeroValueIsStrict = Expect<
+  Equal<typeof pipeSideEffectZeroValue, PipeSideEffectZeroValueExpected>
+>;
+
+export const pipeWithSideEffectValueInput = pipeWithSideEffectInput(1);
+
+type PipeWithSideEffectValueInputExpected = string | SideEffect<any>;
+export type PipeSideEffectValueInputIsStrict = Expect<
+  Equal<typeof pipeWithSideEffectValueInput, PipeWithSideEffectValueInputExpected>
+>;
+
 export const pipeSideEffectSix = pipeSideEffect(
   (value: number) => value + 1,
   (value) => value * 2,
@@ -144,6 +188,20 @@ export type PipeSideEffectFromTenValueNoInputIsStrict = Expect<
   Equal<typeof pipeSideEffectFromTenValueNoInput, PipeSideEffectFromTenValueNoInputExpected>
 >;
 
+export const pipeSideEffectFromNoInput = pipeSideEffect(from(1));
+
+type PipeSideEffectFromNoInputExpected = (input?: unknown) => number | SideEffect<any>;
+export type PipeSideEffectFromNoInputIsStrict = Expect<
+  Equal<typeof pipeSideEffectFromNoInput, PipeSideEffectFromNoInputExpected>
+>;
+
+export const pipeSideEffectFromNoInputValue = pipeSideEffectFromNoInput();
+
+type PipeSideEffectFromNoInputValueExpected = number | SideEffect<any>;
+export type PipeSideEffectFromNoInputValueIsStrict = Expect<
+  Equal<typeof pipeSideEffectFromNoInputValue, PipeSideEffectFromNoInputValueExpected>
+>;
+
 export const purePipeAsync = pipeAsync(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -153,6 +211,23 @@ export const purePipeAsync = pipeAsync(
 type PurePipeAsyncExpected = (input: number) => Promise<string>;
 export type PipeAsyncPureIsStrict = Expect<Equal<typeof purePipeAsync, PurePipeAsyncExpected>>;
 
+export const purePipeAsyncZero = pipeAsync(() => 1, async (value: number) => value + 1);
+
+type PurePipeAsyncZeroExpected = () => Promise<number>;
+export type PipeAsyncPureZeroIsStrict = Expect<Equal<typeof purePipeAsyncZero, PurePipeAsyncZeroExpected>>;
+
+export const purePipeAsyncZeroValue = purePipeAsyncZero();
+
+type PurePipeAsyncZeroValueExpected = Promise<number>;
+export type PipeAsyncPureZeroValueIsStrict = Expect<
+  Equal<typeof purePipeAsyncZeroValue, PurePipeAsyncZeroValueExpected>
+>;
+
+export const purePipeAsyncValue = purePipeAsync(1);
+
+type PurePipeAsyncValueExpected = Promise<string>;
+export type PipeAsyncPureValueIsStrict = Expect<Equal<typeof purePipeAsyncValue, PurePipeAsyncValueExpected>>;
+
 export const purePipeAsyncSix = pipeAsync(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -208,6 +283,18 @@ export type PipeAsyncFromTenValueNoInputIsStrict = Expect<
   Equal<typeof pipeAsyncFromTenValueNoInput, PipeAsyncFromTenValueNoInputExpected>
 >;
 
+export const pipeAsyncFromNoInput = pipeAsync(from(1));
+
+type PipeAsyncFromNoInputExpected = (input?: unknown) => Promise<number>;
+export type PipeAsyncFromNoInputIsStrict = Expect<Equal<typeof pipeAsyncFromNoInput, PipeAsyncFromNoInputExpected>>;
+
+export const pipeAsyncFromNoInputValue = pipeAsyncFromNoInput();
+
+type PipeAsyncFromNoInputValueExpected = Promise<number>;
+export type PipeAsyncFromNoInputValueIsStrict = Expect<
+  Equal<typeof pipeAsyncFromNoInputValue, PipeAsyncFromNoInputValueExpected>
+>;
+
 export const pipeAsyncWithSideEffectInput = pipeAsyncSideEffect(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -221,6 +308,27 @@ export type PipeAsyncAcceptsSideEffectInput = Expect<
   Equal<typeof pipeAsyncWithSideEffectInput, PipeAsyncExpected>
 >;
 
+export const pipeAsyncSideEffectZero = pipeAsyncSideEffect(() => 1, async (value: number) => value + 1);
+
+type PipeAsyncSideEffectZeroExpected = () => Promise<number | SideEffect<any>>;
+export type PipeAsyncSideEffectZeroIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectZero, PipeAsyncSideEffectZeroExpected>
+>;
+
+export const pipeAsyncSideEffectZeroValue = pipeAsyncSideEffectZero();
+
+type PipeAsyncSideEffectZeroValueExpected = Promise<number | SideEffect<any>>;
+export type PipeAsyncSideEffectZeroValueIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectZeroValue, PipeAsyncSideEffectZeroValueExpected>
+>;
+
+export const pipeAsyncWithSideEffectValueInput = pipeAsyncWithSideEffectInput(1);
+
+type PipeAsyncWithSideEffectValueInputExpected = Promise<string | SideEffect<any>>;
+export type PipeAsyncSideEffectValueInputIsStrict = Expect<
+  Equal<typeof pipeAsyncWithSideEffectValueInput, PipeAsyncWithSideEffectValueInputExpected>
+>;
+
 export const pipeAsyncSideEffectSix = pipeAsyncSideEffect(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -280,6 +388,20 @@ export type PipeAsyncSideEffectFromTenValueNoInputIsStrict = Expect<
   Equal<typeof pipeAsyncSideEffectFromTenValueNoInput, PipeAsyncSideEffectFromTenValueNoInputExpected>
 >;
 
+export const pipeAsyncSideEffectFromNoInput = pipeAsyncSideEffect(from(1));
+
+type PipeAsyncSideEffectFromNoInputExpected = (input?: unknown) => Promise<number | SideEffect<any>>;
+export type PipeAsyncSideEffectFromNoInputIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectFromNoInput, PipeAsyncSideEffectFromNoInputExpected>
+>;
+
+export const pipeAsyncSideEffectFromNoInputValue = pipeAsyncSideEffectFromNoInput();
+
+type PipeAsyncSideEffectFromNoInputValueExpected = Promise<number | SideEffect<any>>;
+export type PipeAsyncSideEffectFromNoInputValueIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectFromNoInputValue, PipeAsyncSideEffectFromNoInputValueExpected>
+>;
+
 export const strictPipeSideEffect = pipeSideEffectStrict(
   (value: number) => value + 1,
   (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -288,6 +410,11 @@ export const strictPipeSideEffect = pipeSideEffectStrict(
 
 export const strictPipeSideEffectResult = strictPipeSideEffect(1);
 
+type StrictPipeSideEffectResultExpected = number | SideEffect<'LOW' | 0>;
+export type PipeSideEffectStrictResultIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectResult, StrictPipeSideEffectResultExpected>
+>;
+
 type StrictSideEffectEffects = EffectUnion<typeof strictPipeSideEffectResult>;
 type StrictSideEffectEffectsExpected = 'LOW' | 0;
 export type PipeSideEffectStrictEffects = Expect<Equal<StrictSideEffectEffects, StrictSideEffectEffectsExpected>>;
@@ -305,8 +432,30 @@ export type PipeSideEffectStrictRunPipeResultIsStrict = Expect<
   Equal<typeof strictPipeSideEffectRunResult, StrictPipeSideEffectRunExpected>
 >;
 
+export const strictPipeSideEffectZero = pipeSideEffectStrict(
+  () => 1,
+  (value: number) => (value > 0 ? value : SideEffect.of(() => 'LOW' as const))
+);
+
+type StrictPipeSideEffectZeroExpected = () => number | SideEffect<'LOW'>;
+export type PipeSideEffectStrictZeroIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectZero, StrictPipeSideEffectZeroExpected>
+>;
+
+export const strictPipeSideEffectZeroValue = strictPipeSideEffectZero();
+
+type StrictPipeSideEffectZeroValueExpected = number | SideEffect<'LOW'>;
+export type PipeSideEffectStrictZeroValueIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectZeroValue, StrictPipeSideEffectZeroValueExpected>
+>;
+
 export const strictPipeSideEffectInput = strictPipeSideEffect(SideEffect.of(() => 'INPUT' as const));
 
+type StrictPipeSideEffectInputExpected = number | SideEffect<'LOW' | 0 | 'INPUT'>;
+export type PipeSideEffectStrictInputIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectInput, StrictPipeSideEffectInputExpected>
+>;
+
 type StrictSideEffectInputEffects = EffectUnion<typeof strictPipeSideEffectInput>;
 type StrictSideEffectInputEffectsExpected = 'LOW' | 0 | 'INPUT';
 export type PipeSideEffectStrictInputEffects = Expect<
@@ -370,6 +519,11 @@ export const strictPipeSideEffectFromTen = pipeSideEffectStrict(
 
 export const strictPipeSideEffectFromTenResult = strictPipeSideEffectFromTen('input');
 
+type StrictSideEffectFromTenResultExpected = number | SideEffect<'LOW' | 'MID' | 0>;
+export type PipeSideEffectStrictFromTenResultIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectFromTenResult, StrictSideEffectFromTenResultExpected>
+>;
+
 type StrictFromTenEffects = EffectUnion<typeof strictPipeSideEffectFromTenResult>;
 type StrictFromTenEffectsExpected = 'LOW' | 'MID' | 0;
 export type PipeSideEffectStrictFromTenEffects = Expect<
@@ -382,6 +536,11 @@ export type PipeSideEffectStrictFromTenValue = Expect<Equal<StrictFromTenValue,
 
 export const strictPipeSideEffectFromTenResultNoInput = strictPipeSideEffectFromTen();
 
+type StrictSideEffectFromTenNoInputExpected = number | SideEffect<'LOW' | 'MID' | 0>;
+export type PipeSideEffectStrictFromTenNoInputIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectFromTenResultNoInput, StrictSideEffectFromTenNoInputExpected>
+>;
+
 type StrictFromTenNoInputEffects = EffectUnion<typeof strictPipeSideEffectFromTenResultNoInput>;
 type StrictFromTenNoInputEffectsExpected = 'LOW' | 'MID' | 0;
 export type PipeSideEffectStrictFromTenNoInputEffects = Expect<
@@ -394,6 +553,23 @@ export type PipeSideEffectStrictFromTenNoInputValue = Expect<
   Equal<StrictFromTenNoInputValue, StrictFromTenNoInputValueExpected>
 >;
 
+export const strictPipeSideEffectFromNoInput = pipeSideEffectStrict(from(1));
+
+type StrictPipeSideEffectFromNoInputExpected = {
+  (input?: unknown): number | SideEffect<never>;
+  <EIn>(input?: unknown | SideEffect<EIn>): number | SideEffect<EIn>;
+};
+export type PipeSideEffectStrictFromNoInputIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectFromNoInput, StrictPipeSideEffectFromNoInputExpected>
+>;
+
+export const strictPipeSideEffectFromNoInputValue = strictPipeSideEffectFromNoInput();
+
+type StrictPipeSideEffectFromNoInputValueExpected = number | SideEffect<never>;
+export type PipeSideEffectStrictFromNoInputValueIsStrict = Expect<
+  Equal<typeof strictPipeSideEffectFromNoInputValue, StrictPipeSideEffectFromNoInputValueExpected>
+>;
+
 export const strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
   (value: number) => value + 1,
   async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -402,6 +578,11 @@ export const strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
 
 export const strictPipeAsyncSideEffectResult = strictPipeAsyncSideEffect(1);
 
+type StrictPipeAsyncSideEffectResultExpected = Promise<number | SideEffect<'LOW' | 0>>;
+export type PipeAsyncSideEffectStrictResultIsStrict = Expect<
+  Equal<typeof strictPipeAsyncSideEffectResult, StrictPipeAsyncSideEffectResultExpected>
+>;
+
 type StrictPipeAsyncResolved = Awaited<typeof strictPipeAsyncSideEffectResult>;
 type StrictPipeAsyncEffects = EffectUnion<StrictPipeAsyncResolved>;
 type StrictPipeAsyncEffectsExpected = 'LOW' | 0;
@@ -415,6 +596,23 @@ export type PipeAsyncSideEffectStrictValue = Expect<
   Equal<StrictPipeAsyncValue, StrictPipeAsyncValueExpected>
 >;
 
+export const strictPipeAsyncSideEffectZero = pipeAsyncSideEffectStrict(
+  () => 1,
+  async (value: number) => (value > 0 ? value : SideEffect.of(() => 'LOW' as const))
+);
+
+type StrictPipeAsyncSideEffectZeroExpected = () => Promise<number | SideEffect<'LOW'>>;
+export type PipeAsyncSideEffectStrictZeroIsStrict = Expect<
+  Equal<typeof strictPipeAsyncSideEffectZero, StrictPipeAsyncSideEffectZeroExpected>
+>;
+
+export const strictPipeAsyncSideEffectZeroValue = strictPipeAsyncSideEffectZero();
+
+type StrictPipeAsyncSideEffectZeroValueExpected = Promise<number | SideEffect<'LOW'>>;
+export type PipeAsyncSideEffectStrictZeroValueIsStrict = Expect<
+  Equal<typeof strictPipeAsyncSideEffectZeroValue, StrictPipeAsyncSideEffectZeroValueExpected>
+>;
+
 export const strictPipeAsyncSideEffectSix = pipeAsyncSideEffectStrict(
   (value: number) => value + 1,
   async (value) => (value > 2 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -482,6 +680,11 @@ export const strictPipeAsyncSideEffectFromTen = pipeAsyncSideEffectStrict(
 
 export const strictPipeAsyncSideEffectFromTenResult = strictPipeAsyncSideEffectFromTen('input');
 
+type StrictAsyncFromTenResultExpected = Promise<number | SideEffect<'LOW' | 'MID' | 0>>;
+export type PipeAsyncSideEffectStrictFromTenResultIsStrict = Expect<
+  Equal<typeof strictPipeAsyncSideEffectFromTenResult, StrictAsyncFromTenResultExpected>
+>;
+
 type StrictAsyncFromTenResolved = Awaited<typeof strictPipeAsyncSideEffectFromTenResult>;
 type StrictAsyncFromTenEffects = EffectUnion<StrictAsyncFromTenResolved>;
 type StrictAsyncFromTenEffectsExpected = 'LOW' | 'MID' | 0;
@@ -497,6 +700,11 @@ export type PipeAsyncSideEffectStrictFromTenValue = Expect<
 
 export const strictPipeAsyncSideEffectFromTenResultNoInput = strictPipeAsyncSideEffectFromTen();
 
+type StrictAsyncFromTenNoInputResultExpected = Promise<number | SideEffect<'LOW' | 'MID' | 0>>;
+export type PipeAsyncSideEffectStrictFromTenNoInputIsStrict = Expect<
+  Equal<typeof strictPipeAsyncSideEffectFromTenResultNoInput, StrictAsyncFromTenNoInputResultExpected>
+>;
+
 type StrictAsyncFromTenNoInputResolved = Awaited<typeof strictPipeAsyncSideEffectFromTenResultNoInput>;
 type StrictAsyncFromTenNoInputEffects = EffectUnion<StrictAsyncFromTenNoInputResolved>;
 type StrictAsyncFromTenNoInputEffectsExpected = 'LOW' | 'MID' | 0;
@@ -509,3 +717,47 @@ type StrictAsyncFromTenNoInputValueExpected = number;
 export type PipeAsyncSideEffectStrictFromTenNoInputValue = Expect<
   Equal<StrictAsyncFromTenNoInputValue, StrictAsyncFromTenNoInputValueExpected>
 >;
+
+export const strictPipeAsyncSideEffectFromNoInput = pipeAsyncSideEffectStrict(from(1));
+
+type StrictAsyncSideEffectFromNoInputExpected = {
+  (input?: unknown): Promise<number | SideEffect<never>>;
+  <EIn>(input?: unknown | SideEffect<EIn>): Promise<number | SideEffect<EIn>>;
+};
+export type PipeAsyncSideEffectStrictFromNoInputIsStrict = Expect<
+  Equal<typeof strictPipeAsyncSideEffectFromNoInput, StrictAsyncSideEffectFromNoInputExpected>
+>;
+
+export const strictPipeAsyncSideEffectFromNoInputValue = strictPipeAsyncSideEffectFromNoInput();
+
+type StrictAsyncSideEffectFromNoInputValueExpected = Promise<number | SideEffect<never>>;
+export type PipeAsyncSideEffectStrictFromNoInputValueIsStrict = Expect<
+  Equal<typeof strictPipeAsyncSideEffectFromNoInputValue, StrictAsyncSideEffectFromNoInputValueExpected>
+>;
+
+// Negative cases: input required when not using from/zero-arity.
+// @ts-expect-error input required for unary pipe
+purePipe();
+// @ts-expect-error input required for unary pipeSideEffect
+pipeWithSideEffectInput();
+// @ts-expect-error input required for unary pipeSideEffectStrict
+strictPipeSideEffect();
+// @ts-expect-error input required for unary pipeAsync
+purePipeAsync();
+// @ts-expect-error input required for unary pipeAsyncSideEffect
+pipeAsyncWithSideEffectInput();
+// @ts-expect-error input required for unary pipeAsyncSideEffectStrict
+strictPipeAsyncSideEffect();
+
+// @ts-expect-error input required for direct pipe call
+pipe((value: number) => value + 1)();
+// @ts-expect-error input required for direct pipeSideEffect call
+pipeSideEffect((value: number) => value + 1)();
+// @ts-expect-error input required for direct pipeSideEffectStrict call
+pipeSideEffectStrict((value: number) => value + 1)();
+// @ts-expect-error input required for direct pipeAsync call
+pipeAsync((value: number) => value + 1)();
+// @ts-expect-error input required for direct pipeAsyncSideEffect call
+pipeAsyncSideEffect((value: number) => value + 1)();
+// @ts-expect-error input required for direct pipeAsyncSideEffectStrict call
+pipeAsyncSideEffectStrict((value: number) => value + 1)();

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

@@ -0,0 +1,256 @@
+import SideEffect from './sideEffect';
+import pipe from './pipe';
+import pipeSideEffect from './pipeSideEffect';
+import pipeSideEffectStrict from './pipeSideEffectStrict';
+import tap from './tap';
+import pipeAsync from '../async/pipeAsync';
+import pipeAsyncSideEffect from '../async/pipeAsyncSideEffect';
+import pipeAsyncSideEffectStrict from '../async/pipeAsyncSideEffectStrict';
+import filter from '../array/filter';
+import flattenDeep from '../array/flattenDeep';
+import map from '../array/map';
+import sum from '../math/sum';
+import gt from '../equality/gt';
+import isEmpty from '../equality/isEmpty';
+import when from '../control/when';
+import ifElse from '../control/ifElse';
+import log from '../debug/log';
+import prop from '../object/prop';
+import mergeAll from '../object/mergeAll';
+import getOrElse from '../nullable/getOrElse';
+import mapMaybe from '../nullable/mapMaybe';
+import join from '../string/join';
+import trim from '../string/trim';
+import toUpper from '../string/toUpper';
+import streamFilter from '../../stream/filter';
+import streamMap from '../../stream/map';
+import streamRange from '../../stream/range';
+import streamReduce from '../../stream/reduce';
+import streamToArray from '../../stream/toArray';
+
+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 User = {
+  name?: string;
+};
+
+type TagOwner = {
+  tags?: Array<string | null>;
+};
+
+type Config = {
+  value?: number;
+};
+
+const getName = prop('name') as (user: User) => string | undefined;
+const getTags = prop('tags') as (owner: TagOwner) => Array<string | null> | undefined;
+const mergeConfig = mergeAll as (configs: Config[]) => Config;
+const getValue = prop('value') as (config: Config) => number | undefined;
+const streamMapNumber = streamMap((value: number) => value + 1) as (iterable: Iterable<number>) => IterableIterator<
+  number
+>;
+const streamFilterNumber = streamFilter((value: number) => value > 1) as (
+  iterable: Iterable<number>
+) => IterableIterator<number>;
+const streamReduceNumber = streamReduce((acc: number, value: number) => acc + value, 0) as (
+  iterable: Iterable<number>
+) => number;
+const streamMapAsyncNumber = streamMap(async (value: number) => value + 1) as (
+  iterable: Iterable<number>
+) => IterableIterator<Promise<number>>;
+
+export const pipeArrayControlString = pipe(
+  flattenDeep<number>,
+  filter(gt(1)),
+  map((value: number) => value * 2),
+  sum,
+  when(gt(10), (value) => value + 1),
+  (value) => `${value}`,
+  trim,
+  toUpper,
+  log('total')
+);
+
+type PipeArrayControlStringExpected = (input: any[]) => string;
+export type PipeArrayControlStringIsStrict = Expect<
+  Equal<typeof pipeArrayControlString, PipeArrayControlStringExpected>
+>;
+
+export const pipeObjectNullableControl = pipe(
+  getName,
+  getOrElse(''),
+  ifElse(
+    (value: string) => value.length > 0,
+    toUpper,
+    () => 'UNKNOWN'
+  ),
+  tap((value: string) => value.length)
+);
+
+type PipeObjectNullableControlExpected = (input: User) => string;
+export type PipeObjectNullableControlIsStrict = Expect<
+  Equal<typeof pipeObjectNullableControl, PipeObjectNullableControlExpected>
+>;
+
+export const pipeSideEffectTags = pipeSideEffect(
+  getTags,
+  getOrElse<Array<string | null>>([]),
+  mapMaybe((tag) => (tag ? tag.trim() : null)),
+  map((tag) => tag.toUpperCase()),
+  join('|'),
+  (value) => (isEmpty(value) ? SideEffect.of(() => 'EMPTY' as const) : value)
+);
+
+type PipeSideEffectTagsExpected = (input: TagOwner | SideEffect<any>) => string | SideEffect<any>;
+export type PipeSideEffectTagsIsStrict = Expect<Equal<typeof pipeSideEffectTags, PipeSideEffectTagsExpected>>;
+
+export const pipeSideEffectStrictConfig = pipeSideEffectStrict(
+  mergeConfig,
+  getValue,
+  getOrElse(0),
+  when(gt(0), (value) => value + 1),
+  (value) => (value > 0 ? value : SideEffect.of(() => 'NO_VALUE' as const)),
+  (value) => value + 1
+);
+
+export const pipeSideEffectStrictConfigValue = pipeSideEffectStrictConfig([{ value: 1 }]);
+
+type PipeSideEffectStrictConfigValueExpected = number | SideEffect<'NO_VALUE'>;
+export type PipeSideEffectStrictConfigValueIsStrict = Expect<
+  Equal<typeof pipeSideEffectStrictConfigValue, PipeSideEffectStrictConfigValueExpected>
+>;
+
+export const pipeSideEffectStrictConfigInput = pipeSideEffectStrictConfig(SideEffect.of(() => 'INPUT' as const));
+
+type PipeSideEffectStrictConfigInputExpected = number | SideEffect<'NO_VALUE' | 'INPUT'>;
+export type PipeSideEffectStrictConfigInputIsStrict = Expect<
+  Equal<typeof pipeSideEffectStrictConfigInput, PipeSideEffectStrictConfigInputExpected>
+>;
+
+export const pipeAsyncUserLabel = pipeAsync(
+  getName,
+  getOrElse(''),
+  async (value) => value.trim(),
+  ifElse(
+    (value: string) => value.length > 0,
+    toUpper,
+    () => 'UNKNOWN'
+  ),
+  log('label')
+);
+
+type PipeAsyncUserLabelExpected = (input: User) => Promise<string>;
+export type PipeAsyncUserLabelIsStrict = Expect<Equal<typeof pipeAsyncUserLabel, PipeAsyncUserLabelExpected>>;
+
+export const pipeAsyncSideEffectTags = pipeAsyncSideEffect(
+  getTags,
+  getOrElse<Array<string | null>>([]),
+  mapMaybe((tag) => (tag ? tag.trim() : null)),
+  async (tags) => tags.map((tag) => tag.toUpperCase()),
+  join('|'),
+  (value) => (isEmpty(value) ? SideEffect.of(() => 'EMPTY' as const) : value)
+);
+
+type PipeAsyncSideEffectTagsExpected = (input: TagOwner | SideEffect<any>) => Promise<string | SideEffect<any>>;
+export type PipeAsyncSideEffectTagsIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectTags, PipeAsyncSideEffectTagsExpected>
+>;
+
+export const pipeAsyncSideEffectStrictConfig = pipeAsyncSideEffectStrict(
+  mergeConfig,
+  getValue,
+  getOrElse(0),
+  async (value) => value + 1,
+  (value) => (value > 0 ? value : SideEffect.of(() => 'NO_VALUE' as const)),
+  async (value) => value + 1
+);
+
+export const pipeAsyncSideEffectStrictConfigValue = pipeAsyncSideEffectStrictConfig([{ value: 1 }]);
+
+type PipeAsyncSideEffectStrictConfigValueExpected = Promise<number | SideEffect<'NO_VALUE'>>;
+export type PipeAsyncSideEffectStrictConfigValueIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectStrictConfigValue, PipeAsyncSideEffectStrictConfigValueExpected>
+>;
+
+export const pipeAsyncSideEffectStrictConfigInput = pipeAsyncSideEffectStrictConfig(
+  SideEffect.of(() => 'INPUT' as const)
+);
+
+type PipeAsyncSideEffectStrictConfigInputExpected = Promise<number | SideEffect<'NO_VALUE' | 'INPUT'>>;
+export type PipeAsyncSideEffectStrictConfigInputIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectStrictConfigInput, PipeAsyncSideEffectStrictConfigInputExpected>
+>;
+
+export const pipeStreamSync = pipe(
+  (end: number) => streamRange(0, end),
+  streamMapNumber,
+  streamFilterNumber,
+  streamReduceNumber
+);
+
+type PipeStreamSyncExpected = (input: number) => number;
+export type PipeStreamSyncIsStrict = Expect<Equal<typeof pipeStreamSync, PipeStreamSyncExpected>>;
+
+export const pipeSideEffectStream = pipeSideEffect(
+  (end: number) => streamRange(0, end),
+  streamMapNumber,
+  streamFilterNumber,
+  streamReduceNumber,
+  (value) => (value > 0 ? value : SideEffect.of(() => 'EMPTY' as const))
+);
+
+type PipeSideEffectStreamExpected = (input: number | SideEffect<any>) => number | SideEffect<any>;
+export type PipeSideEffectStreamIsStrict = Expect<Equal<typeof pipeSideEffectStream, PipeSideEffectStreamExpected>>;
+
+export const pipeSideEffectStrictStream = pipeSideEffectStrict(
+  (end: number) => streamRange(0, end),
+  streamMapNumber,
+  streamFilterNumber,
+  streamReduceNumber,
+  (value) => (value > 0 ? value : SideEffect.of(() => 'EMPTY' as const))
+);
+
+export const pipeSideEffectStrictStreamValue = pipeSideEffectStrictStream(3);
+
+type PipeSideEffectStrictStreamValueExpected = number | SideEffect<'EMPTY'>;
+export type PipeSideEffectStrictStreamValueIsStrict = Expect<
+  Equal<typeof pipeSideEffectStrictStreamValue, PipeSideEffectStrictStreamValueExpected>
+>;
+
+export const pipeAsyncStream = pipeAsync(
+  (end: number) => streamRange(0, end),
+  streamMapAsyncNumber,
+  streamToArray
+);
+
+type PipeAsyncStreamExpected = (input: number) => Promise<number[]>;
+export type PipeAsyncStreamIsStrict = Expect<Equal<typeof pipeAsyncStream, PipeAsyncStreamExpected>>;
+
+export const pipeAsyncSideEffectStream = pipeAsyncSideEffect(
+  (end: number) => streamRange(0, end),
+  streamMapAsyncNumber,
+  streamToArray,
+  (value) => (value.length > 0 ? value : SideEffect.of(() => 'EMPTY' as const))
+);
+
+type PipeAsyncSideEffectStreamExpected = (input: number | SideEffect<any>) => Promise<number[] | SideEffect<any>>;
+export type PipeAsyncSideEffectStreamIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectStream, PipeAsyncSideEffectStreamExpected>
+>;
+
+export const pipeAsyncSideEffectStrictStream = pipeAsyncSideEffectStrict(
+  (end: number) => streamRange(0, end),
+  streamMapAsyncNumber,
+  streamToArray,
+  (value) => (value.length > 0 ? value : SideEffect.of(() => 'EMPTY' as const))
+);
+
+export const pipeAsyncSideEffectStrictStreamValue = pipeAsyncSideEffectStrictStream(3);
+
+type PipeAsyncSideEffectStrictStreamValueExpected = Promise<number[] | SideEffect<'EMPTY'>>;
+export type PipeAsyncSideEffectStrictStreamValueIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectStrictStreamValue, PipeAsyncSideEffectStrictStreamValueExpected>
+>;

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

@@ -0,0 +1,16 @@
+import { vi, describe, it, expect } from 'vitest';
+import tap0 from './tap0';
+
+describe('tap0', () => {
+  it('runs the side effect without input', () => {
+    const spy = vi.fn();
+    tap0(spy)();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns undefined', () => {
+    const result = tap0(() => {})();
+    expect(result).toBeUndefined();
+  });
+});

package/src/implement/composition/tap0.ts

@@ -0,0 +1,10 @@
+/**
+ * tap0 - 입력 없이 side-effect 실행
+ */
+function tap0(fn: () => void): () => void {
+  return () => {
+    fn();
+  };
+}
+
+export default tap0;