Specific type revert to string with dynamic key

[Zamralik]

🔎 Search Terms

dynamic key type

🕗 Version & Regression Information

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

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.7.2#code/GYVwdgxgLglg9mABAUwB4EMC2AHANsgRgB4BpFVKZMAEwGdFaoAnGMAcwD4AKAa2QE8AXIhIAaRADd0uEMmHgeYOAHcwASmEBvRAG0+-RKxEBdeWEUqkAXwBQmmwEgmyKCCZJtegacnTZiKwBuG1sbUEhYBHIsPGQAJlJyShp6RhZ2bn1hMV8ZOUQFJVUNRAAlZAg4JmpScULLDjtHZ1d3RE99Hyk8gOCrIA

💻 Code

function example1<K extends string>(key: K, value: unknown): { [key in K]: unknown }
{
	return { [key]: value };
}

function example2<K extends string>(key: K, value: unknown): Record<K, unknown>
{
	return { [key]: value };
}

🙁 Actual behavior

Type '{ [x: string]: unknown; }' is not assignable to type '{ [key in K]: unknown; }'.(2322)
Type '{ [x: string]: unknown; }' is not assignable to type 'Record<K, unknown>'.(2322)

The type of the key is K but reverts to string

🙂 Expected behavior

The type of the key is preserved as K.

Additional information about the issue

No response

[MartinJohns]

This is working as intended. Duplicate of #53912.

This call is perfectly valid, but your functions would return incomplete objects:

example1<"a" | "b">("a", "value");

[Zamralik]

Thanks. I understand the cause of the issue now.

But we can't do things like

function example(key: infer K satisfies string, value: unknown): { [key in K]: unknown }
{
    return { [key]: value };
}

Or

function example<K extends unique string>(key: K, value: unknown): { [key in K]: unknown }
{
    return { [key]: value };
}

These syntax do not exists.

[MartinJohns]

You can't do that because it's simply not supported (yet?). There's an open issue for this: #27808

[Zamralik]

Though it appear similar, it's not exactly the same.
#27808 is about needing to pick a type among a list, here it's more needing to as const the value when used.
If only we could infer outside ternary and use satisfies in type.

[MartinJohns]

It is exactly the same. You want to limit the type argument to a single value, disallowing unions.

If only we could infer outside ternary and use satisfies in type.

It would still need to be a generic type, and generic types can be provided by the caller explicitly.

[typescript-bot]

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

[Zamralik]

It is exactly the same. You want to limit the type argument to a single value, disallowing unions.

If only we could infer outside ternary and use satisfies in type.

It would still need to be a generic type, and generic types can be provided by the caller explicitly.

In this example it wouldn't be possible for the caller to provide the type explicitly.
The issue is that you would be able to get a variable with a non-const type.

function example(key: infer K satisfies string, value: unknown): { [key in K]: unknown }
{
    return { [key]: value };
}

[MartinJohns]

In this example it wouldn't be possible for the caller to provide the type explicitly.

Only because it's arbitrary syntax with nothing behind it. When implemented the argument would still need to be generic.

And you could still always do this:

declare const myKey: "a" | "b"
example(myKey, value);

And according to the type system the object would need to have two properties.

Again, what you want is #27808.