¿Cómo permito que quien llama elija entrada y transformación sin escribir argumentos de tipo?

La receta

function mapValues<T, U>(
  items: readonly T[],
  transform: (item: T) => U,
): U[] {
  return items.map(transform)
}

const lengths = mapValues(['a', 'four'], text => text.length)
const flags = mapValues([1, 2], value => value > 1)

La compilación compila esto y comprueba cada resultado de abajo.

Cómo funciona

1. 01

   items: readonly T[]

   El primer argumento aporta `T`; `readonly` acepta arrays mutables y de solo lectura.

2. 02

   transform: (item: T) => U

   El contexto da la entrada al callback y su expresión de retorno aporta `U`.

Lo que obtienes

• typeof lengths

  →number[]

• typeof flags

  →boolean[]

• ReturnType<() => ReturnType<typeof mapValues<string, number>>> extends number[] ? true : false

  →true

Dónde falla

Un parámetro usado solo en el retorno no puede inferirse de los argumentos. Quien llama tendría que escribirlo o aceptar un valor predeterminado desligado del resultado real.