TypeScript: Why can't I assign a valid field of an object with type { a: "a", b: "b" }

Question

I created the following types from a constant array <const>['a', 'b]:

const paths = <const>['a', 'b']

type Path = typeof paths[number]

type PathMap = {
  [path in Path]: path
}

Path equals to "a" | "b"

PathMap equals to {a: "a", b: "b"}

Then the following code compiles fine:

const BASE_PATHS = paths.reduce((map: PathMap, p: Path) => {
  map['a'] = 'a'
  return map
}, <PathMap>{})

This also works:

const BASE_PATHS = paths.reduce((map: PathMap, p: Path) => {
  return { ...map, [p]: p }
}, <PathMap>{})

But the following code does not compile:

const BASE_PATHS = paths.reduce((map: PathMap, p: Path) => {
  map[p] = p
  return map
}, <PathMap>{})

Which gave me this error at map[p] = p:

TS2322: Type 'string' is not assignable to type 'never'. Type 'string' is not assignable to type 'never'.

Why is this the case?

Thanks for helping!

I believe second option is the best approach to stick with – captain-yossarian from Ukraine Jun 30 '21 at 07:26 — captain-yossarian from Ukraine, Jun 30 '21 at 07:26

captain-yossarian from Ukraine · Accepted Answer · 2021-06-30T07:21:48.093

4

I believe this is because objects are contravariant in their key types.

For more information see this answer.

Likewise, multiple candidates for the same type variable in contra-variant positions causes an intersection type to be inferred.

const paths = ['a', 'b'] as const

type Path = typeof paths[number]

type PathMap = {
    [path in Path]: path
}

type a = 'a'
type b = 'b'

type c = a & b // never

{
    const BASE_PATHS = paths.reduce((map: PathMap, p: Path) => {
        let x = map[p]
        map[p] = p // same here
        return map
    }, {} as PathMap)

Intersection of a and b produces never.

If you remove as const from paths it will compile, because string & string = string

Btw, since you are using functional approach try to avoid object mutations.

Here, in my blog, you can find more information about mutations in TS

Credits to @aleksxor

Here you can find official explanation

edited Jun 30 '21 at 07:21

answered Jun 30 '21 at 07:18

captain-yossarian from Ukraine

31,174
3
30
62

1

In complement to your answer. Here is [microsoft/TypeScript/pull/30769](https://github.com/microsoft/TypeScript/pull/30769) the exact PR introduced this behaviour for indexed access types when union type converts into intersection when met on the target side of assignment. – aleksxor Jun 30 '21 at 07:19
@aleksxor thanks a lot for the link! I made an update of answer – captain-yossarian from Ukraine Jun 30 '21 at 07:21
1

Just checked your blog. Very good resources are available. Thanks for sharing – Amir Saleem Jun 30 '21 at 07:28
1

I am also in the process of advancing TS skills. I want to write a blog, a book on Typesript. – Amir Saleem Jun 30 '21 at 07:32
Don't forget to share the link to your blog – captain-yossarian from Ukraine Jun 30 '21 at 07:34
Sure, definitely – Amir Saleem Jun 30 '21 at 07:43

score 0 · Answer 2 · answered Jun 30 '21 at 07:18

This is because map[p] will give you either a or b and type of a or b is definitely a string. For type Path, as it is a union type, type string is never for Path because Path must satisfy a or b. You can do something like this

const BASE_PATHS = paths.reduce((map: PathMap, p: Path) => {
    // enforce the compiler to treat map[p] as one of Path
    (map[p] as Path) = p;
    return map;
}, {} as PathMap);

TypeScript: Why can't I assign a valid field of an object with type { a: "a", b: "b" }

2 Answers2

Linked