La discusión sobre la implementación de la interfaz invocable es útil, pero no responde completamente a mi pregunta.
interface lol { (a: number): (b: number) => string // (a: string): (b: string) => string // overloaded will not work } let l: lol = function(a: number) { return (b: number) => { return (a + b).toString() } }Este fragmento funciona, pero cuando la función sobrecargada no se comenta, falla. He probado varios métodos y no he descubierto cómo implementar la versión sobrecargada.
Una implementación del mundo real un poco enrevesada pero que estoy tratando de entender son las interfaces de estilo fp-ts . Ignorar los tipos complejos es una interfaz invocable sobrecargada, es lo que entiendo. ¿Cómo podría tal cosa tener una implementación concreta?
export interface Traverse1<T extends URIS> { <F extends URIS4>(F: Applicative4<F>): <A, S, R, E, B>( ta: Kind<T, A>, f: (a: A) => Kind4<F, S, R, E, B> ) => Kind4<F, S, R, E, Kind<T, B>> <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>( ta: Kind<T, A>, f: (a: A) => Kind3<F, R, E, B> ) => Kind3<F, R, E, Kind<T, B>> <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>( ta: Kind<T, A>, f: (a: A) => Kind3<F, R, E, B> ) => Kind3<F, R, E, Kind<T, B>> <F extends URIS2>(F: Applicative2<F>): <A, E, B>( ta: Kind<T, A>, f: (a: A) => Kind2<F, E, B> ) => Kind2<F, E, Kind<T, B>> <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>( ta: Kind<T, A>, f: (a: A) => Kind2<F, E, B> ) => Kind2<F, E, Kind<T, B>> <F extends URIS>(F: Applicative1<F>): <A, B>(ta: Kind<T, A>, f: (a: A) => Kind<F, B>) => Kind<F, Kind<T, B>> <F>(F: Applicative<F>): <A, B>(ta: Kind<T, A>, f: (a: A) => HKT<F, B>) => HKT<F, Kind<T, B>> }La declaración de implementación debe satisfacer todas las sobrecargas establecidas por la interfaz, por lo que, en su caso, podría terminar luciendo así:
let l: lol = function <T extends number | string>(a: T): (b: T) => string { throw Error("not implemented"); }En mi experiencia, deberá realizar muchas comprobaciones de tipo y conversión para obtener la implementación correcta.
Después de la útil explicación de @spender, me di cuenta de lo que realmente está haciendo la interfaz de estilo fp-ts. Al tener <F extends ...> marcado, es posible resolver las funciones sobrecargadas en una sola implementación concreta como en el ejemplo a continuación.
interface lol { <T extends number>(a: T): (b: T) => string <T extends string>(a: T): (b: T) => string } let l: lol = function(a: number) { return (b: number) => { return (a + b).toString() } } Esto crea una instancia de la T como un número, por lo que la sobrecarga de <T extends string> nunca se resuelve (¿es esa la palabra correcta para ello?).