En Typescript, ¿cómo puedo implementar una interfaz de función simple con sobrecargas?

Estoy usando Typescript 2.3.3

Estoy tratando de crear una buena API para un código que estoy escribiendo, así que estoy experimentando con lo que es posible en los genéricos de Typescript.

Me gustaría poder llamar a una función con un tipo genérico y usar ese tipo para presentar opciones al usuario, algunas de las cuales pueden ser funciones con diferentes firmas.

Aquí está mi intento hasta ahora.

Declaré una interfaz con dos firmas de función básicas (las dos opciones que me gustaría presentar al desarrollador):

interface api<T1> {

  <T2>(second: T2):  {
    first: T1
    second: T2;
  };

  <T2, T3>(second: T2, third: T3):  {
    first: T1
    second: T2;
    third: T3;
  };

}

Y creo una función que contiene las implementaciones de cada firma de función, usando el parámetro de tipo genérico que se le pasa:

const test = <TFirst>(first: TFirst) : api<TFirst> => {

  const impl1 = <T2>(second: T2) => ({
    first, second
  });

  const impl2 = <T2, T3>(second: T2, third: T3) =>({
    first, second, third
  });

  return ...?
};

Sin embargo, no tengo idea de dónde asignar esas implementaciones ni de cómo crear un objeto de retorno que cumpla con la especificación de la API.

¿Esto es siquiera posible?

Respuesta #1

Es posible. Podrías hacer algo como esto:

interface api<T1> {

  <T2>(second: T2):  {
    first: T1;
    second: T2;
  };

  <T2, T3>(second: T2, third: T3):  {
    first: T1;
    second: T2;
    third: T3;
  };
};

function createApi<T1>(first: T1): api<T1> {

  function impl<T2>(second: T2): { first: T1; second: T2; };
  function impl<T2, T3>(second: T2, third: T3): { first: T1; second: T2; third: T3; };
  function impl<T2, T3>(second: T2, third?: T3): { first: T1; second: T2; third?: T3; } {
    if (third === undefined) {
      return { first, second };
    }
    return { first, second, third };
  }

  return impl;
}

const test = createApi<number>(1);
console.log(test(2));
console.log(test(2, 3));

La función createApi solo devuelve una función interna sobrecargada.

Para obtener más información sobre las sobrecargas de TypeScript, consulte la sección Overloads en la documentación.