Estoy tratando de escribir una función con una firma de tipo bastante compleja. Acepta dos diccionarios args y funcs , donde funcs asigna claves a funciones que transforman el tipo A en B, y args asigna un superconjunto de esas claves a: A si la clave aparece en funcs y B en caso contrario. Es decir, si se define una función para una clave determinada, use la función para mapear el valor de la misma clave del otro diccionario, si no existe una función correspondiente, simplemente use el valor en sí.
Tengo lo siguiente hasta ahora, pero eso no parece funcionar:
function foo<Properties>( args: { [P in keyof typeof funcs]: Parameters<typeof funcs[P]>[0] } & { [P in Exclude<keyof Properties, keyof typeof funcs>]?: Properties[P]; }, funcs: { [P in keyof Properties]?: (attributes: any) => Properties[P] } ) {} interface Bar { x: number; y: string; } foo<Bar>( { x: "a", y: 1, }, { y: (a: string) => "a", } ); En este caso, esperaría ver dos errores: uno que indica que x debe asignarse a un number en el primer diccionario y el segundo que indica que y debe ser una string en el primer diccionario. Parece que estoy sobreestimando el poder de TS: ¿es posible este comportamiento previsto?
¡Problema interesante!
Creo que esto logra el resultado previsto:
type Func<I, O> = (arg: I) => O type Funcs<T> = { [K in keyof Partial<T>]: Func<K, T[K]> } declare function converter<Properties>( args: Properties, funcs: Funcs<Properties> ): void; interface Bar { x: number; y: string; } converter<Bar>( { x: 1, y: "foo", }, { y: (a: string) => "2", } );