fp-pack 0.3.0 → 0.4.0

package/src/implement/async/pipeAsyncSideEffectStrict.ts

@@ -97,6 +97,86 @@ 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<A, R>(
   ab: AsyncOrSync<A, R>
 ): PipeAsyncSideEffectStrict<[AsyncOrSync<A, R>]>;
@@ -152,6 +232,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/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;

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

@@ -1,4 +1,5 @@
 import SideEffect from './sideEffect';
+import from from './from';
 import pipe from './pipe';
 import pipeSideEffect from './pipeSideEffect';
 import pipeSideEffectStrict from './pipeSideEffectStrict';
@@ -36,6 +37,40 @@ export const purePipeSix = pipe(
 type PurePipeSixExpected = (input: number) => string;
 export type PipePureSixIsStrict = Expect<Equal<typeof purePipeSix, PurePipeSixExpected>>;
 
+export const purePipeTen = pipe(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => `v:${value}`,
+  (value) => value.toUpperCase(),
+  (value) => value.length,
+  (value) => value + 1,
+  (value) => `${value}`,
+  (value) => value.padStart(3, '0'),
+  (value) => value.length,
+  (value) => `n:${value}`
+);
+
+type PurePipeTenExpected = (input: number) => string;
+export type PipePureTenIsStrict = Expect<Equal<typeof purePipeTen, PurePipeTenExpected>>;
+
+export const pipeFromTen = pipe(
+  from(1),
+  (value) => value + 1,
+  (value) => value * 2,
+  (value) => `${value}`,
+  (value) => value.padStart(3, '0'),
+  (value) => value.length,
+  (value) => value + 1,
+  (value) => `${value}`,
+  (value) => value.padStart(4, '0'),
+  (value) => `n:${value}`
+);
+
+export const pipeFromTenValue = pipeFromTen('input');
+
+type PipeFromTenValueExpected = string;
+export type PipeFromTenValueIsStrict = Expect<Equal<typeof pipeFromTenValue, PipeFromTenValueExpected>>;
+
 export const pipeWithSideEffectInput = pipeSideEffect(
   (value: number) => value + 1,
   (value) => value * 2,
@@ -59,6 +94,42 @@ export const pipeSideEffectSix = pipeSideEffect(
 type PipeSideEffectSixExpected = (input: number | SideEffect<any>) => string | SideEffect<any>;
 export type PipeSideEffectSixIsStrict = Expect<Equal<typeof pipeSideEffectSix, PipeSideEffectSixExpected>>;
 
+export const pipeSideEffectTen = pipeSideEffect(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => `v:${value}`,
+  (value) => value.toUpperCase(),
+  (value) => value.length,
+  (value) => value + 1,
+  (value) => `${value}`,
+  (value) => value.padStart(3, '0'),
+  (value) => value.length,
+  (value) => `n:${value}`
+);
+
+type PipeSideEffectTenExpected = (input: number | SideEffect<any>) => string | SideEffect<any>;
+export type PipeSideEffectTenIsStrict = Expect<Equal<typeof pipeSideEffectTen, PipeSideEffectTenExpected>>;
+
+export const pipeSideEffectFromTen = pipeSideEffect(
+  from(1),
+  (value) => value + 1,
+  (value) => value * 2,
+  (value) => `${value}`,
+  (value) => value.padStart(3, '0'),
+  (value) => value.length,
+  (value) => value + 1,
+  (value) => `${value}`,
+  (value) => value.padStart(4, '0'),
+  (value) => `n:${value}`
+);
+
+export const pipeSideEffectFromTenValue = pipeSideEffectFromTen('input');
+
+type PipeSideEffectFromTenValueExpected = string | SideEffect<any>;
+export type PipeSideEffectFromTenValueIsStrict = Expect<
+  Equal<typeof pipeSideEffectFromTenValue, PipeSideEffectFromTenValueExpected>
+>;
+
 export const purePipeAsync = pipeAsync(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -80,6 +151,42 @@ export const purePipeAsyncSix = pipeAsync(
 type PurePipeAsyncSixExpected = (input: number) => Promise<string>;
 export type PipeAsyncPureSixIsStrict = Expect<Equal<typeof purePipeAsyncSix, PurePipeAsyncSixExpected>>;
 
+export const purePipeAsyncTen = pipeAsync(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => `${value}`,
+  async (value) => value.length,
+  (value) => value + 3,
+  async (value) => value * 2,
+  (value) => `${value}`,
+  async (value) => value.length,
+  (value) => value + 1,
+  async (value) => `n:${value}`
+);
+
+type PurePipeAsyncTenExpected = (input: number) => Promise<string>;
+export type PipeAsyncPureTenIsStrict = Expect<Equal<typeof purePipeAsyncTen, PurePipeAsyncTenExpected>>;
+
+export const pipeAsyncFromTen = pipeAsync(
+  from(1),
+  async (value) => value + 1,
+  (value) => value * 2,
+  async (value) => `${value}`,
+  (value) => value.padStart(3, '0'),
+  async (value) => value.length,
+  (value) => value + 1,
+  async (value) => `${value}`,
+  (value) => value.padStart(4, '0'),
+  async (value) => `n:${value}`
+);
+
+export const pipeAsyncFromTenValue = pipeAsyncFromTen('input');
+
+type PipeAsyncFromTenValueExpected = Promise<string>;
+export type PipeAsyncFromTenValueIsStrict = Expect<
+  Equal<typeof pipeAsyncFromTenValue, PipeAsyncFromTenValueExpected>
+>;
+
 export const pipeAsyncWithSideEffectInput = pipeAsyncSideEffect(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -107,6 +214,44 @@ export type PipeAsyncSideEffectSixIsStrict = Expect<
   Equal<typeof pipeAsyncSideEffectSix, PipeAsyncSideEffectSixExpected>
 >;
 
+export const pipeAsyncSideEffectTen = pipeAsyncSideEffect(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => `${value}`,
+  async (value) => value.length,
+  (value) => value + 3,
+  async (value) => value * 2,
+  (value) => `${value}`,
+  async (value) => value.length,
+  (value) => value + 1,
+  async (value) => `n:${value}`
+);
+
+type PipeAsyncSideEffectTenExpected = (input: number | SideEffect<any>) => Promise<string | SideEffect<any>>;
+export type PipeAsyncSideEffectTenIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectTen, PipeAsyncSideEffectTenExpected>
+>;
+
+export const pipeAsyncSideEffectFromTen = pipeAsyncSideEffect(
+  from(1),
+  async (value) => value + 1,
+  (value) => value * 2,
+  async (value) => `${value}`,
+  (value) => value.padStart(3, '0'),
+  async (value) => value.length,
+  (value) => value + 1,
+  async (value) => `${value}`,
+  (value) => value.padStart(4, '0'),
+  async (value) => `n:${value}`
+);
+
+export const pipeAsyncSideEffectFromTenValue = pipeAsyncSideEffectFromTen('input');
+
+type PipeAsyncSideEffectFromTenValueExpected = Promise<string | SideEffect<any>>;
+export type PipeAsyncSideEffectFromTenValueIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectFromTenValue, PipeAsyncSideEffectFromTenValueExpected>
+>;
+
 export const strictPipeSideEffect = pipeSideEffectStrict(
   (value: number) => value + 1,
   (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -150,6 +295,54 @@ type StrictSixValue = ValueUnion<typeof strictPipeSideEffectSixResult>;
 type StrictSixValueExpected = number;
 export type PipeSideEffectStrictSixValue = Expect<Equal<StrictSixValue, StrictSixValueExpected>>;
 
+export const strictPipeSideEffectTen = pipeSideEffectStrict(
+  (value: number) => value + 1,
+  (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => value + 1,
+  (value) => (value > 3 ? value : SideEffect.of(() => 'MID' as const)),
+  (value) => value * 2,
+  (value) => value + 1,
+  (value) => (value > 10 ? value : SideEffect.of(() => 0 as const)),
+  (value) => value + 1,
+  (value) => value * 2,
+  (value) => value + 1
+);
+
+export const strictPipeSideEffectTenResult = strictPipeSideEffectTen(1);
+
+type StrictTenEffects = EffectUnion<typeof strictPipeSideEffectTenResult>;
+type StrictTenEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeSideEffectStrictTenEffects = Expect<Equal<StrictTenEffects, StrictTenEffectsExpected>>;
+
+type StrictTenValue = ValueUnion<typeof strictPipeSideEffectTenResult>;
+type StrictTenValueExpected = number;
+export type PipeSideEffectStrictTenValue = Expect<Equal<StrictTenValue, StrictTenValueExpected>>;
+
+export const strictPipeSideEffectFromTen = pipeSideEffectStrict(
+  from(1),
+  (value) => value + 1,
+  (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => value * 2,
+  (value) => (value > 4 ? value : SideEffect.of(() => 'MID' as const)),
+  (value) => value + 1,
+  (value) => value * 2,
+  (value) => (value > 20 ? value : SideEffect.of(() => 0 as const)),
+  (value) => value + 1,
+  (value) => value * 2
+);
+
+export const strictPipeSideEffectFromTenResult = strictPipeSideEffectFromTen('input');
+
+type StrictFromTenEffects = EffectUnion<typeof strictPipeSideEffectFromTenResult>;
+type StrictFromTenEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeSideEffectStrictFromTenEffects = Expect<
+  Equal<StrictFromTenEffects, StrictFromTenEffectsExpected>
+>;
+
+type StrictFromTenValue = ValueUnion<typeof strictPipeSideEffectFromTenResult>;
+type StrictFromTenValueExpected = number;
+export type PipeSideEffectStrictFromTenValue = Expect<Equal<StrictFromTenValue, StrictFromTenValueExpected>>;
+
 export const strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
   (value: number) => value + 1,
   async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -194,3 +387,59 @@ type StrictAsyncSixValueExpected = number;
 export type PipeAsyncSideEffectStrictSixValue = Expect<
   Equal<StrictAsyncSixValue, StrictAsyncSixValueExpected>
 >;
+
+export const strictPipeAsyncSideEffectTen = pipeAsyncSideEffectStrict(
+  (value: number) => value + 1,
+  async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => value + 1,
+  async (value) => (value > 3 ? value : SideEffect.of(() => 'MID' as const)),
+  (value) => value * 2,
+  async (value) => value + 1,
+  (value) => (value > 10 ? value : SideEffect.of(() => 0 as const)),
+  async (value) => value + 1,
+  (value) => value * 2,
+  async (value) => value + 1
+);
+
+export const strictPipeAsyncSideEffectTenResult = strictPipeAsyncSideEffectTen(1);
+
+type StrictAsyncTenResolved = Awaited<typeof strictPipeAsyncSideEffectTenResult>;
+type StrictAsyncTenEffects = EffectUnion<StrictAsyncTenResolved>;
+type StrictAsyncTenEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeAsyncSideEffectStrictTenEffects = Expect<
+  Equal<StrictAsyncTenEffects, StrictAsyncTenEffectsExpected>
+>;
+
+type StrictAsyncTenValue = ValueUnion<StrictAsyncTenResolved>;
+type StrictAsyncTenValueExpected = number;
+export type PipeAsyncSideEffectStrictTenValue = Expect<
+  Equal<StrictAsyncTenValue, StrictAsyncTenValueExpected>
+>;
+
+export const strictPipeAsyncSideEffectFromTen = pipeAsyncSideEffectStrict(
+  from(1),
+  async (value) => value + 1,
+  (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
+  async (value) => value * 2,
+  (value) => (value > 4 ? value : SideEffect.of(() => 'MID' as const)),
+  async (value) => value + 1,
+  (value) => value * 2,
+  async (value) => (value > 20 ? value : SideEffect.of(() => 0 as const)),
+  (value) => value + 1,
+  async (value) => value * 2
+);
+
+export const strictPipeAsyncSideEffectFromTenResult = strictPipeAsyncSideEffectFromTen('input');
+
+type StrictAsyncFromTenResolved = Awaited<typeof strictPipeAsyncSideEffectFromTenResult>;
+type StrictAsyncFromTenEffects = EffectUnion<StrictAsyncFromTenResolved>;
+type StrictAsyncFromTenEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeAsyncSideEffectStrictFromTenEffects = Expect<
+  Equal<StrictAsyncFromTenEffects, StrictAsyncFromTenEffectsExpected>
+>;
+
+type StrictAsyncFromTenValue = ValueUnion<StrictAsyncFromTenResolved>;
+type StrictAsyncFromTenValueExpected = number;
+export type PipeAsyncSideEffectStrictFromTenValue = Expect<
+  Equal<StrictAsyncFromTenValue, StrictAsyncFromTenValueExpected>
+>;

package/src/implement/composition/pipeSideEffect.ts

@@ -43,6 +43,48 @@ function pipeSideEffect<B, C, D, E, F, R>(
   ef: UnaryFn<E, F>,
   fg: UnaryFn<F, R>
 ): () => MaybeSideEffect<R>;
+function pipeSideEffect<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>
+): () => MaybeSideEffect<R>;
+function pipeSideEffect<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>
+): () => MaybeSideEffect<R>;
+function pipeSideEffect<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>
+): () => MaybeSideEffect<R>;
+function pipeSideEffect<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>
+): () => 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>,
@@ -74,6 +116,48 @@ function pipeSideEffect<A, B, C, D, E, F, R>(
   ef: UnaryFn<E, F>,
   fg: UnaryFn<F, R>
 ): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<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 | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<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 | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<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 | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<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 | SideEffect<any>) => MaybeSideEffect<R>;
 
 function pipeSideEffect<Fns extends [UnaryFn<any, any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): PipeSideEffect<Fns>;
 function pipeSideEffect(...funcs: Array<UnaryFn<any, any>>): (input: any) => any;