Strongly types a pipeline of functions.

TypedPipe.ts

const pipe =
  <Ctx, Ingress, A, B, C, Egress>(
    ...args:
      | [(x: Ingress, ctx: Ctx) => Promise<Egress>]
      | [
          (x: Ingress, ctx: Ctx) => Promise<A>,
          (x: A, ctx: Ctx) => Promise<Egress>
        ]
      | [
          (x: Ingress, ctx: Ctx) => Promise<A>,
          (x: A, ctx: Ctx) => Promise<B>,
          (x: B, ctx: Ctx) => Promise<Egress>
        ]
      | [
          (x: Ingress, ctx: Ctx) => Promise<A>,
          (x: A, ctx: Ctx) => Promise<B>,
          (x: B, ctx: Ctx) => Promise<C>,
          (x: C, ctx: Ctx) => Promise<Egress>
        ]
  ) =>
  async (context: Ctx, ingress: Ingress) => {
    let data: any = ingress;
    for (const effect of args) {
      data = await effect(data, context);
    }
    return <Egress>data;
  };

async function myTest() {
  const affect = pipe(
    async (x: string, ctx: string) => x + ctx,
    async (x: string, ctx: string) => x + ctx,
    async (x: string, ctx: string) => Number(x + ctx)
  );
  const ctx = "hello";
  const data = "hi";
  const egress = await affect(ctx, data);
}

A crazier version:

type Handler<Ingress, Ctx, Egress> = (x: Ingress, ctx: Ctx) => Promise<Egress>;
type PipeA<Ctx, Ingress, A, B, C, D, E, F, G, H, I, Egress> = [
  Handler<Ingress, Ctx, A>,
  ...([Handler<A, Ctx, Egress>] | PipeB<Ctx, A, B, C, D, E, F, G, H, I, Egress>)
];
type PipeB<Ctx, A, B, C, D, E, F, G, H, I, Egress> = [
  Handler<A, Ctx, B>,
  ...([Handler<B, Ctx, Egress>] | PipeC<Ctx, B, C, D, E, F, G, H, I, Egress>)
];
type PipeC<Ctx, B, C, D, E, F, G, H, I, Egress> = [
  Handler<B, Ctx, C>,
  ...([Handler<C, Ctx, Egress>] | PipeD<Ctx, C, D, E, F, G, H, I, Egress>)
];
type PipeD<Ctx, C, D, E, F, G, H, I, Egress> = [
  Handler<C, Ctx, D>,
  ...([Handler<D, Ctx, Egress>] | PipeE<Ctx, D, E, F, G, H, I, Egress>)
];
type PipeE<Ctx, D, E, F, G, H, I, Egress> = [
  Handler<D, Ctx, E>,
  ...([Handler<E, Ctx, Egress>] | PipeF<Ctx, E, F, G, H, I, Egress>)
];
type PipeF<Ctx, E, F, G, H, I, Egress> = [
  Handler<E, Ctx, F>,
  ...([Handler<F, Ctx, Egress>] | PipeG<Ctx, F, G, H, I, Egress>)
];
type PipeG<Ctx, F, G, H, I, Egress> = [
  Handler<F, Ctx, G>,
  ...([Handler<G, Ctx, Egress>] | PipeH<Ctx, G, H, I, Egress>)
];
type PipeH<Ctx, G, H, I, Egress> = [
  Handler<G, Ctx, H>,
  ...([Handler<H, Ctx, Egress>] | PipeI<Ctx, H, I, Egress>)
];
type PipeI<Ctx, H, I, Egress> = [Handler<H, Ctx, I>, Handler<I, Ctx, Egress>];

const pipe =
  <Ctx, Ingress, A, B, C, D, E, F, G, H, I, Egress>(
    ...args: PipeA<Ctx, Ingress, A, B, C, D, E, F, G, H, I, Egress>
  ) =>
  async (context: Ctx, ingress: Ingress) => {
    let data: any = ingress;
    for (const effect of args) {
      data = await effect(data, context);
    }
    return <Egress>data;
  };

async function myTest() {
  const affect = pipe(
    async (x: string, ctx: string) => x + ctx,
    async (x: string, ctx: string) => x + ctx,
    async (x: string, ctx: string) => Number(x + ctx)
  );
  const ctx = "hello";
  const data = "hi";
  const egress = await affect(ctx, data);
}

https://medium.com/ackee/typescript-function-composition-and-recurrent-types-a9efbc8e7736