Dynamically specify argument types based on data

I have an object which defines some transform functions. Those functions have the same number of parameters but different parameter types. I'm trying to figure out a way to make TS to infer parameter types based on a function name.

Let's say we have an object with some functions:

const funcList = {
  f1: (val: string, opts: number) => { console.log(val, opts); },
  f2: (val: number, opts: boolean) => { console.log(val, opts); },
} as const;

And there is data set that we need to iterate through

const data = [{
  func: 'f1',
  val: 'strval',
  opt: 111,
}, {
  func: 'f2',
  val: 222,
  opt: true,
}] as const;

And now I want to iterate over that data array and call a corresponding function

for (const e of data) {
  funcList[e.func](e.val, e.opt);
}

TS doesn't allow this code with the following error

> TS2345: Argument of type 'string | number' is not assignable to parameter of type 'never'.   Type 'string' is not assignable to type 'never'.

It seems that TS doesn't discriminate type based on func field.
However if I change the code as the following, everything works

for (const e of data) {
  if (e.func === 'f1') {
    funcList[e.func](e.val, e.opt);
  } else {
    funcList[e.func](e.val, e.opt);
  }
}

So if I explicitly check element's func field, TS can then infer the rest with proper types.

What could I do to avoid using tons of ifs/switch?

The compiler is unable to handle the "correlated union types" described in ms/TS#30581, however, there is a suggested refactor described in ms/TS#47109, which considers moving to generics.

First, we will need some map type that will hold the everything related to types of functions:

type RecordMap = {
  f1: {
    args: { val: string; opt: number };
    return: number;
  };
  f2: {
    args: { val: number };
    return: void;
  };
};

Now, let's create a type for funcList, which we will do using mapped types. We will map through RecordMap keys and take relevant types from each of its element:

type FuncList = {
  [K in keyof RecordMap]: (
    args: RecordMap[K]['args'],
  ) => RecordMap[K]['return'];
};

Result:

type FuncList = {
    f1: (args: {
        val: string;
        opt: number;
    }) => number;
    f2: (args: {
        val: number;
    }) => void;
}

Let's use FuncList on the funcList:

const funcList: FuncList = {
  f1: (args) => {
    return args.opt;
  },
  f2: (args) => {
    console.log(args);
  },
};

We don't need to include types in the funcList explicitly, since they are inferred from FuncList.

Next, we need to create a mapped type for the function arguments, which will return a union of possible arguments, for passed name of the function or for all of them if name is not passed:

type FuncListArgs<T extends keyof RecordMap = keyof RecordMap> = {
  [K in T]: {
    func: K;
  } & RecordMap[K]['args'];
}[T];

Result:

// {
//     func: "f1";
// } & {
//     val: string;
//     opt: number;
// }
type F1Args = FuncListArgs<'f1'>

// ({
//     func: "f1";
// } & {
//     val: string;
//     opt: number;
// }) | ({
//     func: "f2";
// } & {
//     val: number;
// })
type AllArgs = FuncListArgs

Since we need a generic argument to make this whole thing to work, we will create a function that will accept an args for some function:

const handleFunc = <T extends keyof RecordMap>(args: FuncListArgs<T>) => {
  const func = funcList[args.func];
  return func(args); // no error
};

Usage:

for (const a of data) {
  handleFunc(a);
}

playground