fp-pack 0.2.0 → 0.3.0

package/src/implement/async/pipeAsync.ts

@@ -32,6 +32,14 @@ function pipeAsync<A, B, C, D, E, R>(
   de: AsyncOrSync<Awaited<D>, E>,
   ef: AsyncOrSync<Awaited<E>, R>
 ): (a: A) => Promise<Awaited<R>>;
+function pipeAsync<A, B, C, D, E, F, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, R>
+): (a: A) => Promise<Awaited<R>>;
 
 function pipeAsync<Fns extends [AsyncOrSync<any, any>, ...AsyncOrSync<any, any>[]]>(...funcs: Fns): PipeAsync<Fns>;
 function pipeAsync(...funcs: Array<AsyncOrSync<any, any>>): (value: any) => Promise<any>;

package/src/implement/async/pipeAsyncSideEffect.ts

@@ -47,6 +47,14 @@ function pipeAsyncSideEffect<A, B, C, D, E, R>(
   de: AsyncOrSync<Awaited<D>, E>,
   ef: AsyncOrSync<Awaited<E>, R>
 ): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
+function pipeAsyncSideEffect<A, B, C, D, E, F, R>(
+  ab: AsyncOrSync<A, B>,
+  bc: AsyncOrSync<Awaited<B>, C>,
+  cd: AsyncOrSync<Awaited<C>, D>,
+  de: AsyncOrSync<Awaited<D>, E>,
+  ef: AsyncOrSync<Awaited<E>, F>,
+  fg: AsyncOrSync<Awaited<F>, R>
+): (a: A | SideEffect<any>) => Promise<MaybeSideEffect<Awaited<R>>>;
 
 function pipeAsyncSideEffect<Fns extends [AsyncOrSync<any, any>, ...AsyncOrSync<any, any>[]]>(
   ...funcs: Fns

package/src/implement/async/pipeAsyncSideEffectStrict.ts

@@ -82,6 +82,21 @@ function pipeAsyncSideEffectStrict<B, C, D, E, R>(
   AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
   AsyncOrSync<NonSideEffect<Awaited<E>>, R>
 ]>;
+function pipeAsyncSideEffectStrict<B, C, D, E, F, 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>>, 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>>, R>
+]>;
 function pipeAsyncSideEffectStrict<A, R>(
   ab: AsyncOrSync<A, R>
 ): PipeAsyncSideEffectStrict<[AsyncOrSync<A, R>]>;
@@ -122,6 +137,21 @@ function pipeAsyncSideEffectStrict<A, B, C, D, E, R>(
   AsyncOrSync<NonSideEffect<Awaited<D>>, E>,
   AsyncOrSync<NonSideEffect<Awaited<E>>, R>
 ]>;
+function pipeAsyncSideEffectStrict<A, B, C, D, E, F, 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>>, 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>>, R>
+]>;
 
 function pipeAsyncSideEffectStrict<Fns extends [AnyFn, ...AnyFn[]]>(...funcs: Fns): PipeAsyncSideEffectStrict<Fns>;
 function pipeAsyncSideEffectStrict(...funcs: Array<AsyncOrSync<any, any>>) {

package/src/implement/composition/pipe.ts

@@ -23,6 +23,14 @@ function pipe<B, C, D, E, R>(
   de: UnaryFn<D, E>,
   ef: UnaryFn<E, R>
 ): () => R;
+function pipe<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>
+): () => 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;
@@ -39,6 +47,14 @@ function pipe<A, B, C, D, E, R>(
   de: UnaryFn<D, E>,
   ef: UnaryFn<E, R>
 ): (a: A) => R;
+function pipe<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) => 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

@@ -24,6 +24,18 @@ 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 pipeWithSideEffectInput = pipeSideEffect(
   (value: number) => value + 1,
   (value) => value * 2,
@@ -35,6 +47,18 @@ 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 purePipeAsync = pipeAsync(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -44,6 +68,18 @@ 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 pipeAsyncWithSideEffectInput = pipeAsyncSideEffect(
   (value: number) => value + 1,
   async (value) => value * 2,
@@ -57,6 +93,20 @@ 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 strictPipeSideEffect = pipeSideEffectStrict(
   (value: number) => value + 1,
   (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -81,6 +131,25 @@ 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 strictPipeAsyncSideEffect = pipeAsyncSideEffectStrict(
   (value: number) => value + 1,
   async (value) => (value > 1 ? value : SideEffect.of(() => 'LOW' as const)),
@@ -101,3 +170,27 @@ 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>
+>;

package/src/implement/composition/pipeSideEffect.ts

@@ -35,6 +35,14 @@ 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<A, R>(ab: UnaryFn<A, R>): (a: A | SideEffect<any>) => MaybeSideEffect<R>;
 function pipeSideEffect<A, B, R>(
   ab: UnaryFn<A, B>,
@@ -58,6 +66,14 @@ 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<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,21 @@ 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<A, R>(ab: UnaryFn<A, R>): PipeSideEffectStrict<[UnaryFn<A, R>]>;
 function pipeSideEffectStrict<A, B, R>(
   ab: UnaryFn<A, B>,
@@ -116,6 +131,21 @@ 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<Fns extends [AnyFn, ...AnyFn[]]>(...funcs: Fns): PipeSideEffectStrict<Fns>;
 function pipeSideEffectStrict(...funcs: Array<(input: any) => any>) {