Typescript sets function args as never

[jaunty fossil]

Here's the TS playground: https://www.typescriptlang.org/play?#code/KYOwrgtgBAYmIGMAuBLA9iAKgTwA7CgG8AoKMqAdQFEBBAaSgF4oAiAd2AEMBrFgGlLkAypgBKAeQByAcSasREmS2IBfYsSR4CANU4AbMMADOckuSgBtOIlQYc+AHTV6AXQBcRQebKb8H68joWFpOtHQC3uQAbvqGRh40AE6JnNgAPEZIiSggAOYAfF5QKhHkVvCBdiEKUtLunpE+Wv4VtsGONTKlkTEGxh7genpFJepqxABmrUFQCIlcSMAUXNwAFL1xHrp9RuU2QfbAoa4WLBvGLC4AlA3k80hgiSCWLqrqk9MYs-Oci0JZGFy61i-Sg2zie0q7SOnTqp3ORkuNzMd2ADyeLze6gQGEysBAJmYKLIkLah2OdHqcwWSxW3UsATJ1TEtSpPz+ALyWN8BBgel+ixAaUwUGAAA9BQATEyiYA4xKSjJZHK5PhQTggbD5fJyTAWbjAbBoCZQTCvD77L65NGMoKrCYgfz8pCCtLg4z5ZFFAD03qgSVykFASCgxqgPKgAHJMtk8hYXFAAD5QQZ6SNQFAmEBoEOcIxGFC5ECcABGegISDQUFwnBSEDRwESoZNEcjIGAUUbkYcPr9hyjqfTmZTOfV+cLxbLFarrfbncS3dWACYAMwAFgArFcijiCSHqb80E3mDACRYHQ4eS57SAHAjtyogA

In short, I don't understand why it's setting the function args as never instead of their correct types (i.e. string[] | null in this case)

[oak dirge]

@jaunty fossil Here's a shortened URL of your playground link! You can remove the full link from your message.

.va.n#0

Playground Link

Preview:```ts
enum FunctionType {
WEAK = "weak",
STRONG = "STRONG",
}

type Values = {
[FunctionType.WEAK]: {
type: FunctionType.WEAK
values: Array<string>
}
[FunctionType.STRONG]: {
type: FunctionType.STRONG
values:
...```

You can choose specific lines to embed by selecting them before copying the link.

[maiden peak]

!:corr*

[oak dirge]

retsam19#0

`!retsam19:correspondence-problem`:

There's a particular pattern that is safe but hard for the Typescript compiler to handle, which I call the "correspondence problem":

const functionsWithArguments = [
  { func: (arg: string) => {}, arg: "foo" },
  { func: (arg: number) => {}, arg: 0 },
];

for (const { func, arg } of functionsWithArguments) {
  func(arg);
//     ^^^
// Argument of type 'string | number' is not assignable to parameter of type 'never'.
//   Type 'string' is not assignable to type 'never'.
}

The problem is that func is typed as (x: string) => void | (x: number) => void and arg is string | number, but the compiler can't prove that they "correspond": that, for example, arg is only a string when func accepts strings.

As far as the type are concerned, arg could be number, and func could be (arg: string) => void, and that would be a type-error. It's easy for us to see that that won't happen, but that requires understanding the program at a higher-level than the level the compiler operates.

Depending on the specifics there's sometimes clever fixes, but usually I recommend using a type assertion and ignoring the issue:

func(arg as never);

[jaunty fossil]

I love that there's a shortcut to this problem - it must be quite common!

thank you so much - this was making me crazy

i'm not sure I like the solution of casting the type as never but if this is how it is, then it's fair enough... thanks again!