Type Extension not working on generic accumulator

Question

Say I have the following helper function:

type Entity = Readonly<{ id: string }>
type EntityEntry<T extends Entity> = readonly [string, T| null]

export const toEntityMap = <T extends Entity>(ids: ReadonlyArray<string>) => {
  return (entities: ReadonlyArray<T>): ReadonlyMap<string, T | null> => {
    return new Map(
      ids.reduce(
        (acc: ReadonlyArray<EntityEntry<T>>, cur) => {
          const entity = entities.find(e => e.id === cur)
          const entry: EntityEntry<T> = [cur, entity ?? null]
          return [...acc, entry]
        }, []
      )
    )
  }
}

Which I try to call like so:

type Thing = Readonly<{
    id: string,
    foo: string
}>

export type ThingIds = Readonly<{
  ids: ReadonlyArray<string>
}>

type GetThings = (thingIds: ThingIds) => TaskEither<Error, ReadonlyArray<Thing>>

export type Input = Readonly<{ ids: ReadonlyArray<string> }>
export type Result = ReadonlyMap<string, Thing | null>

type Deps = Readonly<{ getThings: GetThings }>
type Ctx = ReaderTaskEither<Deps, Error, Result>

export const execute = (input: Input): Ctx => (
  (deps: Deps): TaskEither<Error, Result> => (
    pipe(
      deps.getThings(input),
      map((things) => {
        const map: ReadonlyMap<string, Thing | null> = toEntityMap(input.ids)(things)
        return map
      })
    )
  )
)

Runnable Link: https://stackblitz.com/edit/typescript-tv6w7o

I would expect this to compile successfully, as Thing extends Entity. However, instead I am getting a compile error:

Type 'ReadonlyMap<string, Readonly<{ id: string; }>>' is not assignable to type 'ReadonlyMap<string, Readonly<{ id: string; foo: string; }>>'.
  Property 'foo' is missing in type 'Readonly<{ id: string; }>' but required in type 'Readonly<{ id: string; foo: string; }>'.(2322)

Indicating that for some reason my utility function is returning a map onto Entities.

My question here is, why? And how can I fix this?

Answer 1

Soluce

const map: ReadonlyMap<string, Thing | null> = toEntityMap<Thing>(input.ids)(things)

---

Explanation

If you do not specify the template calling toEntityMap, TypeScript infers it as Entity, and Entity does not contains foo. It may surpise you, but you have a function inside of a function. TypeScript cannot infer the data you give to the second function when evaluating the first one.

export const toEntityMap = <T extends Entity>(ids: ReadonlyArray<string>) => {