fp-pack 0.3.0 → 0.5.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';
@@ -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,49 @@ 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 pipeSideEffectFromTenValueNoInput = pipeSideEffectFromTen();
+
+type PipeSideEffectFromTenValueNoInputExpected = string | SideEffect<any>;
+export type PipeSideEffectFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof pipeSideEffectFromTenValueNoInput, PipeSideEffectFromTenValueNoInputExpected>
+>;
+
 export const purePipeAsync = pipeAsync(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -80,6 +158,49 @@ 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 pipeAsyncFromTenValueNoInput = pipeAsyncFromTen();
+
+type PipeAsyncFromTenValueNoInputExpected = Promise<string>;
+export type PipeAsyncFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof pipeAsyncFromTenValueNoInput, PipeAsyncFromTenValueNoInputExpected>
+>;
+
 export const pipeAsyncWithSideEffectInput = pipeAsyncSideEffect(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -107,6 +228,51 @@ 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 pipeAsyncSideEffectFromTenValueNoInput = pipeAsyncSideEffectFromTen();
+
+type PipeAsyncSideEffectFromTenValueNoInputExpected = Promise<string | SideEffect<any>>;
+export type PipeAsyncSideEffectFromTenValueNoInputIsStrict = Expect<
+  Equal<typeof pipeAsyncSideEffectFromTenValueNoInput, PipeAsyncSideEffectFromTenValueNoInputExpected>
+>;
+
 export const strictPipeSideEffect = pipeSideEffectStrict(
   (value: number) => value + 1,
   (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -150,6 +316,68 @@ 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 strictPipeSideEffectFromTenResultNoInput = strictPipeSideEffectFromTen();
+
+type StrictFromTenNoInputEffects = EffectUnion<typeof strictPipeSideEffectFromTenResultNoInput>;
+type StrictFromTenNoInputEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeSideEffectStrictFromTenNoInputEffects = Expect<
+  Equal<StrictFromTenNoInputEffects, StrictFromTenNoInputEffectsExpected>
+>;
+
+type StrictFromTenNoInputValue = ValueUnion<typeof strictPipeSideEffectFromTenResultNoInput>;
+type StrictFromTenNoInputValueExpected = number;
+export type PipeSideEffectStrictFromTenNoInputValue = Expect<
+  Equal<StrictFromTenNoInputValue, StrictFromTenNoInputValueExpected>
+>;
+
 export const strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
   (value: number) => value + 1,
   async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -194,3 +422,74 @@ 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>
+>;
+
+export const strictPipeAsyncSideEffectFromTenResultNoInput = strictPipeAsyncSideEffectFromTen();
+
+type StrictAsyncFromTenNoInputResolved = Awaited<typeof strictPipeAsyncSideEffectFromTenResultNoInput>;
+type StrictAsyncFromTenNoInputEffects = EffectUnion<StrictAsyncFromTenNoInputResolved>;
+type StrictAsyncFromTenNoInputEffectsExpected = 'LOW' | 'MID' | 0;
+export type PipeAsyncSideEffectStrictFromTenNoInputEffects = Expect<
+  Equal<StrictAsyncFromTenNoInputEffects, StrictAsyncFromTenNoInputEffectsExpected>
+>;
+
+type StrictAsyncFromTenNoInputValue = ValueUnion<StrictAsyncFromTenNoInputResolved>;
+type StrictAsyncFromTenNoInputValueExpected = number;
+export type PipeAsyncSideEffectStrictFromTenNoInputValue = Expect<
+  Equal<StrictAsyncFromTenNoInputValue, StrictAsyncFromTenNoInputValueExpected>
+>;

package/src/implement/composition/pipeSideEffect.ts

@@ -1,3 +1,4 @@
+import type { FromFn } from './from';
 import SideEffect, { isSideEffect } from './sideEffect';
 
 type MaybeSideEffect<T> = T | SideEffect<any>;
@@ -18,6 +19,9 @@ type Resolve<T> = T extends infer R ? R : never;
 type PipeSideEffect<Fns extends UnaryFn<any, any>[]> = (
   input: PipeInput<Fns> | SideEffect<any>
 ) => Resolve<PipeOutput<Fns>>;
+type PipeSideEffectFrom<Fns extends [FromFn<any>, ...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>;
@@ -43,6 +47,49 @@ 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<Fns extends [FromFn<any>, ...UnaryFn<any, any>[]]>(...funcs: Fns): PipeSideEffectFrom<Fns>;
 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 +121,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;

package/src/implement/composition/pipeSideEffectStrict.ts

@@ -1,3 +1,4 @@
+import type { FromFn } from './from';
 import SideEffect, { isSideEffect } from './sideEffect';
 
 type AnyFn = (...args: any[]) => any;
@@ -43,6 +44,12 @@ type PipeSideEffectStrictUnary<Fns extends [AnyFn, ...AnyFn[]]> = {
     input: PipeInputStrict<Fns> | SideEffect<EIn>
   ): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns> | EIn>>;
 };
+type PipeSideEffectStrictUnaryOptional<Fns extends [AnyFn, ...AnyFn[]]> = {
+  (input?: PipeInputStrict<Fns>): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>;
+  <EIn>(
+    input?: PipeInputStrict<Fns> | SideEffect<EIn>
+  ): Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns> | EIn>>;
+};
 
 type PipeSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]> = Fns extends [ZeroFn<any>, ...AnyFn[]]
   ? () => Resolve<MaybeSideEffect<PipeValueOutputStrict<Fns>, EffectsOf<Fns>>>
@@ -97,6 +104,89 @@ function pipeSideEffectStrict<B, C, D, E, F, R>(
   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<Fns extends [FromFn<any>, ...AnyFn[]]>(
+  ...funcs: Fns
+): PipeSideEffectStrictUnaryOptional<Fns>;
 function pipeSideEffectStrict<A, R>(ab: UnaryFn<A, R>): PipeSideEffectStrict<[UnaryFn<A, R>]>;
 function pipeSideEffectStrict<A, B, R>(
   ab: UnaryFn<A, B>,
@@ -146,6 +236,86 @@ function pipeSideEffectStrict<A, B, C, D, E, F, R>(
   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>) {