Cleaner function overloading without replicating parts that do not change

Question

type Foo = {
    (trx: Transaction | undefined, event: SomeEnum.OPT_1, params: { whatever: number }): Promise<void>;
    (trx: Transaction | undefined, event: SomeEnum.OPT_2, params: { whatever: string }): Promise<void>;
};

export const foo: Foo = async (trx: Transaction | undefined, event: SomeEnum, params: object | undefined) => {};

I'm experimenting with function overloading, the above code works but in my real world case I will have something like 40 overloads where only some of the parameters will be different, so I was wondering, is there a way to improve the code so I don't have to replicate all the invariant elements over and over? In the example, the first parameter trx will always be the same, also the return type of the function will always be the same. I tried somethig like this but typescript clearly doesn't like it:

type FooPartial<T1 extends SomeEnum, T2> = (trx: Transaction | undefined, event: T1, params: T2) => Promise<void>;

type Foo {
    FooPartial<SomeEnum.OPT_1, { whatever: number }>
    FooPartial<SomeEnum.OPT_2, { whatever: string }>
}

score 2 · Accepted Answer · answered Jul 13 '21 at 16:12

You need to make dynamic overloading.

In order to do it , you need:

compute each overloading in the loop


type Transaction = {
    tag: 'Transaction'
}

type Maps = {
    [SomeEnum.OPT_1]: string;
    [SomeEnum.OPT_2]: number
}


type Overloading = {
    [Ev in keyof Maps]:  (trx: Transaction | undefined, event: Ev, params: Maps[Ev]) => Promise<void>
}

Now we should get only values of Overloading type

type Values<T> = T[keyof T]

type Overloading = Values<{
    [Ev in keyof Maps]:  (trx: Transaction | undefined, event: Ev, params: Maps[Ev]) => Promise<void>
}>

Now, when we have union of all allowed functions, we need to convert this union to overloaded function. In order to do it you just need use an intersection &.

// credits goes to https://stackoverflow.com/a/50375286
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  k: infer I
) => void
  ? I
  : never;

type Overloading =UnionToIntersection<Values<{
    [Ev in keyof Maps]:  (trx: Transaction | undefined, event: Ev, params: Maps[Ev]) => Promise<void>
}>>

Full code



enum SomeEnum {
    OPT_1 = '1',
    OPT_2 = '2'
}

type Transaction = {
    tag: 'Transaction'
}

type Maps = {
    [SomeEnum.OPT_1]: string;
    [SomeEnum.OPT_2]: number
}

type Values<T> = T[keyof T]


// credits goes to https://stackoverflow.com/a/50375286
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
  k: infer I
) => void
  ? I
  : never;

type Overloading =UnionToIntersection<Values<{
    [Ev in keyof Maps]:  (trx: Transaction | undefined, event: Ev, params: Maps[Ev]) => Promise<void>
}>>

export const foo: Overloading = async (trx: Transaction | undefined, event: SomeEnum, params: Values<Maps>) => { };

foo({tag:'Transaction'}, SomeEnum.OPT_1, 'string') // ok

Playground

Here, in my blog, you can find similar solution

Thanks, that's exactly what I wanted. I'm new to typescript and I'm amazed by how it can quickly pass from "easy" to "WTF". — flagg19, Jul 13 '21 at 16:43

Cleaner function overloading without replicating parts that do not change

1 Answers1