Can I infer record key type from value type?

[trail nebula]

https://www.typescriptlang.org/play?ssl=24&ssc=2&pln=12&pc=1#code/C4TwDgpgBAQlC8UBKEDGB7ATgEwDwAVN1JNQBpCEAGigGdhMBLAOwHMoAfKZgVwFsARhEwA+ALAAoSQHppUABbBgYWgC5Z9AIaoA1ugBuwgGYAbdAHcAdBj7SAjjwj1G6ZrWkA2AAwBGACw+AJze0qCQtKhMYMAAtDqUMfqaJo4xmBAmmsAuzDFg6bTC+iysMegCAFZosRDMDIxOMWEQks1QAKJ1TE64ACoiCFAAgpiYmiC4AN6SUFAA2mRQLFDxIOhGUL0AuqrzZDS9C1tbANySAL5zq+ubWyJnUhJtQ30DiNMSswtLzCuUN9tdocyFsoBAAB7AWrYWjcfhCTBQAD8dHqbCgux4zB0zAszAukkkRixqGyrigUPofTgEKhzBhsBEAApGECYABKKAfWYYNzAMFdBqwxAAeUq1UstXqThZnM0sM60to1PEnwFSss6WwPFQECZTO0qBoV0oNCSKQgW058AG3NmSw2TOaN3NjgQ8EQAHJ6Ew2J7OXb7VBDSaQKDEMwIOZkBBWO1wWAma6IOyZkGoOlgDxML9DWnZud88HUKhQ+HuFGoAARLJ65OptWzTPZ3MltPnGiTc7B2GBvY-P5rDa9GA7TYwI5gyHQ2E+krImNxhMY6u19sN85AA

How can I make this code works

They are the same code

[digital orbit]

I'm hesitant to say it's impossible, maybe someone else finds a solution, but I don't think you'll be able to make this one work.

For one, you're asking a lot of the type system

Secondly, you're running into the correspondence problem

[harsh sapphire]

Yeah I don't think you can do it without casting at all, the problem is that TS allows excess properties so Object.entries is inherently unsafe.

And what you are doing is just reflection in other languages.

But if you are fine with casting, usually you want to use Object.fromEntries rather than reducing.

[magic bobcat]

nonspicyburrito#0

Playground Link

Preview:```ts
type B = Record<PropertyKey, string | number>

function test<TB extends B>(i: TB) {
const result = Object.fromEntries(
Object.entries(i).map(([key, value]) => [
key,
typeof value === "string"
? new RegExp(value)
: new Date(value)
...```

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

[trail nebula]

I'm trying to avoid casting. But of course, I'll do that when required

[trail nebula]

I'm using keyof from generic type. Isn't it safe?

[harsh sapphire]

!:unsafe-keys

[magic bobcat]

retsam19#0

`!retsam19:unsafe-keys`:

Since TS allows objects to have extra properties not specified in the type, it doesn't assume that all the keys on the type are the only keys on the object. This means that Object.keys returns string[] not a specific type, and for(const key in obj), key is string, (not keyof typeof obj).

If you wish to assume otherwise, this utility is often helpful:

// A signature for `Object.keys` that assumes the only keys are the ones indicated by the type
const unsafeKeys = Object.keys as <T>(obj: T) => Array<keyof T>;

[harsh sapphire]

An example:

function doStuff<T extends object>(obj: T) {
    const keys = Object.keys(obj)
}

const fooBarBaz = { foo: 'hello', bar: 'world', baz: 42 }
const fooBar: { foo: string; bar: string } = fooBarBaz

doStuff(fooBar)

In the case of passing in fooBar, if you type keys as keyof T then that means it would be 'foo' | 'bar', when in reality it's actually 'foo' | 'bar' | 'baz'.

[rough fractal]

(Just FYI, there's also a snippet for this)

!*:unsafe-keys-example

[magic bobcat]

retsam19#0

`!retsam19:unsafe-keys-example`:

An example where assuming Object.keys(x) returns keyof (typeof x) is unsafe:

type XY = {
   x: string,
   y: string,
}
function louder(obj: XY) {
    Object.keys(obj).forEach(key => {
        // If key is "x" | "y", then this compiles:
        console.log(obj[key].toUpperCase());
    })
}
const obj = { x: "x", y: "y", zero: 0};
louder(obj); // compiles, because extra properties are allowed... but crashes at runtime

[trail nebula]

Make sense. But what am I doing is infer result from input type from user. So, the developers should always prefer pass the correct type info for correct result