It's not possible to assign to string to T[keyof T] where T extends { [key: string]: string }

[blixt]

TypeScript Version: 3.7.0-dev.20191018

Search Terms: keyof string index record not assignable

Code

function test<T extends { [key: string]: string }>(map: T) {
    const key: keyof T = "hello"
    map[key] = "hi there"
}

(see playground for a more real example)

Expected behavior: Infer that the types accepted by the function will allow string key assignment (to string value). Since an interface with members incompatible with the string->string signature is invalid, anything that extends Record<string, string> should also have string keys with string values.

Actual behavior: An error such as:

• Type 'string' is not assignable to type 'T[keyof T]'.
• Type 'string' cannot be used to index type 'T'.
• Type 'string' is not assignable to type 'T[Extract<keyof T, string>]'.

The last one is if you attempt to do the assignment inside of a for (const key in map) loop. In this case especially, you'd think that even if there were somehow other properties with other types on the object (eg symbol or number indices), that it's narrowed down to just strings.

Playground Link: http://www.typescriptlang.org/play/?ts=3.7-Beta#code/GYVwdgxgLglg9mABFApgZygHgCqJQD1TABM1EBvRAbQGsUBPALkQwCcYwBzAXWbY86IAvgD4AFAFsAhgAdm2AJQUAUIjWIICDIjr1EAXkQAiABYoANubhHV6gPR2NWqDobNdcYIlyHTFqzbqiA5OYNq6fFDsXAbGZpbWtmrSMrQM3LGmMMhmrCg2QsrKIQCCiBJweaEQeah4+FISMuYojEWgkLAI5VJ0AGpS5iDoAKoyMiisOPVEpIgASiiarMSY-FwANCxRAiLiAG6Dw2jyCvIqQZphLnloIOZQzAAKUqywgzgiseSFQcCViDEV3CDEQHEQhyG6CU5CSQUQt3uUDS9AyhkhxxR3AAdFA4GMJqwAMJSNAoMQKOG-eyOADKMGIKDAcFQzAAkogAO4wNAmMEuTmkxAyOBoNAwABGLWQcEQnBArykYFQKAR6CRYLImiaLTquFyKGxRrhtRArCQiIeiCF2GUhWUwJcIHGk1i0n6R1GLtYYkoYEarWMACE4BKjFsZKxPOhxQhmEYg6S6FAJYNzIgnuYpPRJkZhJSgA

Related Issues: #29295 was similar but possible to work around.

[AnyhowStep]

This is not an error.
T = { hello : "bye" }

Now, your assignment,
map["hello"] = "hi there"

Is unsound

[blixt]

Hm fair enough. I also tried type intersection (T & { [key: string]: string }) which produces the same error. What mechanism is there to accept a type that fulfills the string->string index and then return that same type?

My attempted approaches to the example in the sandbox:

// Type 'string' is not assignable to type 'T[Extract<keyof T, string>]
function makeValuesUpper<T extends Record<string, string>>(values: T): T { }
// Type 'string' cannot be used to index type 'T & Record<string, string>'
function makeValuesUpper<T>(values: T & Record<string, string>): T { }
// Removes all type information from the passed in value.
function makeValuesUpper(values: Record<string, string>): typeof values { }

[AnyhowStep]

Your input map should be immutable.

function makeValuesUpper<T extends Record<string, string>>(values: T): Record<Extract<keyof T, string>, string> { }

Assuming you're doing what I think you're doing. You're taking the values and making them upper case?

[blixt]

Yes it appears this works:

function upperValues<T extends Record<string, string>>(values: T): Record<Extract<keyof T, string>, string> {
    const result: Record<string, string> = {}
    for (const key in values) {
        result[key] = values[key].toUpperCase()
    }
    return result
}

const upper = upperValues({ name: "Bob", profession: "Basketball Player" })

The return type does change (Record<"name" | "profession", string>) and it seems eliding Record<...> here with { [K in ...]: string } causes type errors again. Although I think there should probably be an error in the above code, but somehow that Record<string, string> sneaks through and passes for the correct type to return...

Anyway maybe this is too much of an edge case though I had hoped there'd be a more obvious way to do something similar to […].map(…) on objects, given you could show at compile time the object only contains string values.

For additional context, the real world use case here is to augment configuration objects. Examples would be making a map of config keys to relative paths into absolute paths, expanding variables, or otherwise modifying the values in the object while returning the exact same structure.

(The current implementation we have makes the types in the function any and works around the issue this way, and I think to keep the exposed API nice, we'll keep it that way.)

[jack-williams]

There is no type-safe way to iterate over an object with a generic set of keys. String indexers are unsound in certain cases, which is why you don't see an error. I tend to write functions like this as:

function upperValues<K extends string>(values: Record<K, string>): Record<K, string> {
    const result: Partial<Record<K, string>> = {}
    for (const key in values) {
        result[key] = values[key].toUpperCase()
    }
    return result as Record<K, string>;
}

// or generically
function mapObj<K extends string, T, U>(values: Record<K, T>, fn: (t: T) => U): Record<K, U> {
    const result: Partial<Record<K, U>> = {}
    for (const key in values) {
        result[key] = fn(values[key]);
    }
    return result as Record<K, U>;
}

const upper = upperValues({ name: "Bob", profession: "Basketball Player" })
const upper2 = mapObj({ name: "Bob", profession: "Basketball Player" }, x => x.toUpperCase());

The last case can be reasonably justified as the previous loop should iterate over each K, so going from partial to defined should be safe.

[AnyhowStep]

Gotta be careful of own properties vs not-own properties and enumerable vs non-enumerable properties =x

The TS type system can't quite represent the difference between those (yet?).

So, gotta be careful how you use in values /of Object.keys(values)/of Object.getOwnPropertyNames(values)/etc. (with/without hasOwnProperty check, with/without propertyIsEnumerable checks)

In general, though, I think it's safe to assume the properties are own properties+enumerable. Just edge cases to keep in the back of your mind, I guess

[typescript-bot]

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