Typescript ReturnType generičke funkcije

Novi ReturnType u TypeScriptu 2.8 je zaista korisna značajka koja vam omogućuje da izdvojite tip povratne vrijednosti određene funkcije.

function foo(e: number): number {
    return e;
}

type fooReturn = ReturnType<typeof foo>; // number

Međutim, imam problema s korištenjem toga u kontekstu generičkih funkcija.

function foo<T>(e: T): T {
    return e;
}

type fooReturn = ReturnType<typeof foo>; // type fooReturn = {}

type fooReturn = ReturnType<typeof foo<number>>; // syntax error

type fooReturn = ReturnType<(typeof foo)<number>>; // syntax error

Postoji li način da se izdvoji povratni tip koji bi generička funkcija imala za određene tipove parametara?

Odgovor #1

Ovo je prethodno bilo nemoguće učiniti na potpuno generički način, ali će biti moguće u Typescriptu 4.7. Taj se obrazac naziva "Izraz instanciranja". Relevantni PR je ovdje. Izvadak iz opisa:

function makeBox<T>(value: T) {
  return { value };
};

const makeStringBox = makeBox<string>;  // (value: string) => { value: string }
const stringBox = makeStringBox('abc');  // { value: string }

const ErrorMap = Map<string, Error>;  // new () => Map<string, Error>
const errorMap = new ErrorMap();  // Map<string, Error> ```

...

Posebno koristan obrazac je stvaranje generičkih aliasa tipa za primjene typeof koje referenciraju parametre tipa u izrazima instanciranja tipa:

type BoxFunc<T> = typeof makeBox<T>;  // (value: T) => { value: T }
type Box<T> = ReturnType<typeof makeBox<T>>;  // { value: T }
type StringBox = Box<string>;  // { value: string }

Odgovor #2

Ovo je moje trenutno funkcionalno rješenje za izdvajanje neizvezenih unutarnjih tipova uvezenih biblioteka (poput knex):

// foo is an imported function that I have no control over
function foo<T>(e: T): InternalType<T> {
    return e;
}

class Wrapper<T> {
  // wrapped has no explicit return type so we can infer it
  wrapped(e: T) {
    return foo<T>(e)
  }
}

type FooInternalType<T> = ReturnType<Wrapper<T>['wrapped']>
type Y = FooInternalType<number>
// Y === InternalType<number>

Odgovor #3

Ako želite dobiti neki poseban generički tip, možete koristiti lažnu funkciju za njegovo obavijanje.

const wrapperFoo = () => foo<number>()
type Return = ReturnType<typeof wrapperFoo>

Složenija demo verzija

function getList<T>(): {
  list: T[],
  add: (v: T) => void,
  remove: (v: T) => void,
  // ...blahblah
}
const wrapperGetList = () => getList<number>()
type List = ReturnType<typeof wrapperGetList>
// List = {list: number[], add: (v: number) => void, remove: (v: number) => void, ...blahblah}

Povezani članci