Typescript ReturnType av generisk funktion

Den nya ReturnType i TypeScript 2.8 är en riktigt användbar funktion som låter dig extrahera returtypen för en viss funktion.

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

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

Jag har dock problem med att använda det i sammanhanget med generiska funktioner.

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

Finns det ett sätt att extrahera returtypen som en generisk funktion skulle ha givit vissa typparametrar?

Svar #1

Detta var tidigare omöjligt att göra på ett helt generiskt sätt, men kommer att vara möjligt i Typescript 4.7. Mönstret kallas för en "Instansieringsuttryck". Den relevanta PR:n finns här. Utdrag från beskrivningen:

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> ```

...

Ett särskilt användbart mönster är att skapa generiska typalias för användningar av typeof som refererar till typparametrar i typen-instanseringsuttryck:

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 }

Svar #2

Detta är min nuvarande fungerande lösning för att extrahera icke-exporterade interna typer från importerade bibliotek (som 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>

Svar #3

Om du vill få någon speciell generisk typ kan du använda en falsk funktion för att omsluta den.

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

Mer komplex demo

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}

Relaterade artiklar