How can I define an array type in typescript that can connect function and its parameter？

Question

Here I have three functions and I put them into a literal:

type AnyCallback = (...args: any) => unknown;
const callbackAlpha = (data: string) => {
  console.log(data);
  return data.length;
};

const callbackBeta = (data: string, prefix: string) => {
  console.log(data, prefix);
  return prefix + data;
};

const callbackGamma = (data: string, prefix: string, suffix: string) => {
  console.log(data, prefix, suffix);
  return prefix + data + suffix;
};

let allCallBack: Record<string, AnyCallback> = {
  callbackAlpha,
  callbackBeta,
  callbackGamma,
};

and then, I want to define an array type to record the function name and parameters when I call it, the member supposed to be like this:

{
   name: //name of a function in the literal
   args: //parameters that needed when I call the function
}

Firstly, I tried like this:

type TaskType = keyof typeof allCallBack;
type TaskQueue = {
  name: TaskType;
  args: Parameters<(typeof allCallBack)[TaskType]>;
}[];

Obviously, it is wrong, because you can give "name" any string value,and "args" can be any parameters of the three functions.

Does this approach meet your needs? If so I'll write up an answer explaining; if not, what am I missing? — jcalz
– jcalz, Commented Jul 28, 2023 at 16:47

Boopathi Rajaa · Accepted Answer · 2023-07-28 17:17:27Z

In TypeScript, when you assign/alias a subtype (a more specific type / narrow type) to a supertype (a less specific type / broader type), the subtype is not preserved in the supertype.

For example,

let a: "foo" = "foo";

let b: string = a;

// typeof b === string and not "foo"

The same thing has happened to your functions when you assign subtypes "callbackAlpha", (data: string) => number to its corresponding supertypes - string, and (...args: any[]) => any as defined in Record<string, AnyCallback>

If you want TS to preserve the exact type information, then removing the type declaration (Record) for allCallback would help -

let allCallback = {
  callbackAlpha,
  callbackBeta,
  callbackGamma,
}

Here, the type inference works just fine and the exact types are preserved. And then, to construct the TaskQueue type preserving the relation/association between the name and args, it can be done using generics -

type TaskType = keyof typeof allCallBack;
type TaskQueueItem<Name extends TaskType> = {
    name: Name,
    args: Parameters<(typeof allCallBack)[Name]>
}
type TaskQueue = TaskQueueItem<TaskType>[];

For example,

const myAlphaName = "callbackAlpha" as const;
const myBetaName = "callbackBeta" as const;
const myAlphaTask: TaskQueueItem<typeof myAlphaName> = {
    name: myAlphaName,
    args: ["a"]
};
const myBetaTask: TaskQueueItem<typeof myBetaName> = {
    name: myBetaName,
    args: ["a", "b"]
};
const myAllTasks: TaskQueue = [myAlphaTask, myBetaTask];

TS Playground link

how to achieve the following: myAllTasks.push({ name:myAlphaName, args:["a","b"] }) //type check not allowed

Collectives™ on Stack Overflow

How can I define an array type in typescript that can connect function and its parameter？

1 Answer 1

2 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Related