fp-pack 0.2.0 → 0.4.0

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';
@@ -24,6 +25,52 @@ export const purePipe = pipe(
 type PurePipeExpected = (input: number) => string;
 export type PipePureIsStrict = Expect<Equal<typeof purePipe, PurePipeExpected>>;
 
+export const purePipeSix = pipe(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => `${value}`,
+  (value) => value.length,
+  (value) => value + 1,
+  (value) => `n:${value}`
+);
+
+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,
@@ -35,6 +82,54 @@ export const pipeWithSideEffectValue = pipeWithSideEffectInput(sideEffectInput);
 type PipeExpected = (input: number | SideEffect<any>) => string | SideEffect<any>;
 export type PipeAcceptsSideEffectInput = Expect<Equal<typeof pipeWithSideEffectInput, PipeExpected>>;
 
+export const pipeSideEffectSix = pipeSideEffect(
+  (value: number) => value + 1,
+  (value) => value * 2,
+  (value) => value + 3,
+  (value) => value - 1,
+  (value) => value * 2,
+  (value) => `n:${value}`
+);
+
+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,
@@ -44,6 +139,54 @@ export const purePipeAsync = pipeAsync(
 type PurePipeAsyncExpected = (input: number) => Promise<string>;
 export type PipeAsyncPureIsStrict = Expect<Equal<typeof purePipeAsync, PurePipeAsyncExpected>>;
 
+export const purePipeAsyncSix = pipeAsync(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => `${value}`,
+  async (value) => value.length,
+  (value) => value + 3,
+  async (value) => `n:${value}`
+);
+
+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,
@@ -57,6 +200,58 @@ export type PipeAsyncAcceptsSideEffectInput = Expect<
   Equal<typeof pipeAsyncWithSideEffectInput, PipeAsyncExpected>
 >;
 
+export const pipeAsyncSideEffectSix = pipeAsyncSideEffect(
+  (value: number) => value + 1,
+  async (value) => value * 2,
+  (value) => value + 3,
+  async (value) => value - 1,
+  (value) => value * 2,
+  async (value) => `n:${value}`
+);
+
+type PipeAsyncSideEffectSixExpected = (input: number | SideEffect<any>) => Promise<string | SideEffect<any>>;
+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)),
@@ -81,6 +276,73 @@ export type PipeSideEffectStrictInputEffects = Expect<
   Equal<StrictSideEffectInputEffects, StrictSideEffectInputEffectsExpected>
 >;
 
+export const strictPipeSideEffectSix = pipeSideEffectStrict(
+  (value: number) => value + 1,
+  (value) => (value > 2 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => value + 1,
+  (value) => (value > 10 ? value : SideEffect.of(() => 'SMALL' as const)),
+  (value) => value * 2,
+  (value) => (value > 40 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeSideEffectSixResult = strictPipeSideEffectSix(1);
+
+type StrictSixEffects = EffectUnion<typeof strictPipeSideEffectSixResult>;
+type StrictSixEffectsExpected = 'LOW' | 'SMALL' | 0;
+export type PipeSideEffectStrictSixEffects = Expect<Equal<StrictSixEffects, StrictSixEffectsExpected>>;
+
+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)),
@@ -101,3 +363,83 @@ type StrictPipeAsyncValueExpected = number;
 export type PipeAsyncSideEffectStrictValue = Expect<
   Equal<StrictPipeAsyncValue, StrictPipeAsyncValueExpected>
 >;
+
+export const strictPipeAsyncSideEffectSix = pipeAsyncSideEffectStrict(
+  (value: number) => value + 1,
+  async (value) => (value > 2 ? value : SideEffect.of(() => 'LOW' as const)),
+  (value) => value + 1,
+  async (value) => (value > 10 ? value : SideEffect.of(() => 'SMALL' as const)),
+  (value) => value * 2,
+  async (value) => (value > 40 ? value : SideEffect.of(() => 0 as const))
+);
+
+export const strictPipeAsyncSideEffectSixResult = strictPipeAsyncSideEffectSix(1);
+
+type StrictAsyncSixResolved = Awaited<typeof strictPipeAsyncSideEffectSixResult>;
+type StrictAsyncSixEffects = EffectUnion<StrictAsyncSixResolved>;
+type StrictAsyncSixEffectsExpected = 'LOW' | 'SMALL' | 0;
+export type PipeAsyncSideEffectStrictSixEffects = Expect<
+  Equal<StrictAsyncSixEffects, StrictAsyncSixEffectsExpected>
+>;
+
+type StrictAsyncSixValue = ValueUnion<StrictAsyncSixResolved>;
+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

@@ -35,6 +35,56 @@ function pipeSideEffect<B, C, D, E, R>(
   de: UnaryFn<D, E>,
   ef: UnaryFn<E, R>
 ): () => MaybeSideEffect<R>;
+function pipeSideEffect<B, C, D, E, F, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  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>,
@@ -58,6 +108,56 @@ function pipeSideEffect<A, B, C, D, E, R>(
   de: UnaryFn<D, E>,
   ef: UnaryFn<E, R>
 ): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
+function pipeSideEffect<A, B, C, D, E, F, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<B, C>,
+  cd: UnaryFn<C, D>,
+  de: UnaryFn<D, E>,
+  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;

package/src/implement/composition/pipeSideEffectStrict.ts

@@ -82,6 +82,101 @@ function pipeSideEffectStrict<B, C, D, E, R>(
   UnaryFn<NonSideEffect<D>, E>,
   UnaryFn<NonSideEffect<E>, R>
 ]>;
+function pipeSideEffectStrict<B, C, D, E, F, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, R>
+]>;
+function pipeSideEffectStrict<B, C, D, E, F, G, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, R>
+]>;
+function pipeSideEffectStrict<B, C, D, E, F, G, H, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, H>,
+  hi: UnaryFn<NonSideEffect<H>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, H>,
+  UnaryFn<NonSideEffect<H>, R>
+]>;
+function pipeSideEffectStrict<B, C, D, E, F, G, H, I, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, H>,
+  hi: UnaryFn<NonSideEffect<H>, I>,
+  ij: UnaryFn<NonSideEffect<I>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, H>,
+  UnaryFn<NonSideEffect<H>, I>,
+  UnaryFn<NonSideEffect<I>, R>
+]>;
+function pipeSideEffectStrict<B, C, D, E, F, G, H, I, J, R>(
+  ab: ZeroFn<B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, H>,
+  hi: UnaryFn<NonSideEffect<H>, I>,
+  ij: UnaryFn<NonSideEffect<I>, J>,
+  jk: UnaryFn<NonSideEffect<J>, R>
+): PipeSideEffectStrict<[
+  ZeroFn<B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, H>,
+  UnaryFn<NonSideEffect<H>, I>,
+  UnaryFn<NonSideEffect<I>, J>,
+  UnaryFn<NonSideEffect<J>, R>
+]>;
 function pipeSideEffectStrict<A, R>(ab: UnaryFn<A, R>): PipeSideEffectStrict<[UnaryFn<A, R>]>;
 function pipeSideEffectStrict<A, B, R>(
   ab: UnaryFn<A, B>,
@@ -116,6 +211,101 @@ function pipeSideEffectStrict<A, B, C, D, E, R>(
   UnaryFn<NonSideEffect<D>, E>,
   UnaryFn<NonSideEffect<E>, R>
 ]>;
+function pipeSideEffectStrict<A, B, C, D, E, F, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, R>
+]>;
+function pipeSideEffectStrict<A, B, C, D, E, F, G, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, R>
+]>;
+function pipeSideEffectStrict<A, B, C, D, E, F, G, H, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, H>,
+  hi: UnaryFn<NonSideEffect<H>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, H>,
+  UnaryFn<NonSideEffect<H>, R>
+]>;
+function pipeSideEffectStrict<A, B, C, D, E, F, G, H, I, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, H>,
+  hi: UnaryFn<NonSideEffect<H>, I>,
+  ij: UnaryFn<NonSideEffect<I>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, H>,
+  UnaryFn<NonSideEffect<H>, I>,
+  UnaryFn<NonSideEffect<I>, R>
+]>;
+function pipeSideEffectStrict<A, B, C, D, E, F, G, H, I, J, R>(
+  ab: UnaryFn<A, B>,
+  bc: UnaryFn<NonSideEffect<B>, C>,
+  cd: UnaryFn<NonSideEffect<C>, D>,
+  de: UnaryFn<NonSideEffect<D>, E>,
+  ef: UnaryFn<NonSideEffect<E>, F>,
+  fg: UnaryFn<NonSideEffect<F>, G>,
+  gh: UnaryFn<NonSideEffect<G>, H>,
+  hi: UnaryFn<NonSideEffect<H>, I>,
+  ij: UnaryFn<NonSideEffect<I>, J>,
+  jk: UnaryFn<NonSideEffect<J>, R>
+): PipeSideEffectStrict<[
+  UnaryFn<A, B>,
+  UnaryFn<NonSideEffect<B>, C>,
+  UnaryFn<NonSideEffect<C>, D>,
+  UnaryFn<NonSideEffect<D>, E>,
+  UnaryFn<NonSideEffect<E>, F>,
+  UnaryFn<NonSideEffect<F>, G>,
+  UnaryFn<NonSideEffect<G>, H>,
+  UnaryFn<NonSideEffect<H>, I>,
+  UnaryFn<NonSideEffect<I>, J>,
+  UnaryFn<NonSideEffect<J>, R>
+]>;
 
 function pipeSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]>(...funcs: Fns): PipeSideEffectStrict<Fns>;
 function pipeSideEffectStrict(...funcs: Array<(input: any) => any>) {