Inconsistent generic type inference between record type and object literal type

[hkleungai]

🔎 Search Terms

record, generics, object literal

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about Generics

⏯ Playground Link

https://tsplay.dev/mq0kQN

💻 Code

declare function forEach<T extends string | number | symbol>(
    data: { [a in T]: unknown },
    cb: (x: T) => unknown
): void;

declare let record: Record<string, unknown>;
forEach(record, key => {})
//              ^?

declare let obj: { [a: string]: unknown };
forEach(obj,    key => {})
//              ^?

🙁 Actual behavior

• key for record: Record<string, unknown> is inferred as string type
• key for { [a: string]: unknown } is inferred as string | number type

🙂 Expected behavior

both key should be inferred as the same type, i.e. string type.

Additional information about the issue

No response

[fatcerberus]

This is intentional, if surprising. Normally keyof a string index signature is string | number, because the type is indexable by either. Record, however, is defined as a mapped type which produces a keyof of just string. Duplicate of Related to #55706.

[fatcerberus]

Duplicate of #49540 and/or #48269.

[hkleungai]

Edit: Thanks @fatcerberus for the quick response. I think record / mapped types are the way then :)

Thanks @fatcerberus for the quick response. I have read through the issues you mentioned, and I want to further ask something.

I find that by changing the obj type from index signature to mapped type, it gives the desired type.

Playground link: https://tsplay.dev/mb1nBN

Code:

declare function forEach<T extends string | number | symbol>(
    data: { [a in T]: unknown },
    cb: (x: T) => unknown
): void;

declare let               obj_index_sig: { [s: string]: unknown };
//                        ^?
forEach(obj_index_sig,    key => {})
//                        ^?

declare let               obj_mapped_type: { [s in string]: unknown } 
//                        ^?
forEach(obj_mapped_type,  key => {})
//                        ^?

But then, what is the actual difference between { [s: string]: unknown } and { [s in string]: unknown }?

On one hand, it seems the mapped type does not just devolve into an index signature, based on how the tsc successfully interpreted the string type from key for obj_mapped_type.

But on the other hand, the ts playground inlay indicates they have the same "shape" (with the only difference in the LHS key, s vs x).

let obj_index_sig: { [s: string]: unknown; }
let obj_mapped_type: { [x: string]: unknown; }

How should I understand the difference between { [s: string]: unknown } and { [s in string]: unknown }?

If i understand it correctly, mapped type is essentially a record. But then why the ts inlay shows that mapped type and index-signature type are in same shape?

let obj_index_sig: { [s: string]: unknown; }
let obj_mapped_type: { [x: string]: unknown; }

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.