Инверсия зависимостей в дженериках Typescript
Можно ли предоставить дженерик другому дженерику, который затем использует этот дженерик для определения типа возвращаемого значения — например, инверсия зависимостей?
Псевдокод, иллюстрирующий то, что я хотел бы сделать:
type GetTypeA<T extends (arg: any)=>unknown> = ReturnType<T>
type GetTypeB<T extends (arg: any)=>unknown> = Parameters<T>[0]
type Usage<Getter extends GetTypeA | GetTypeB,T extends (arg: any)=>unknown> = {
getter: Getter<T>
}
type TypeA<T> = Usage<GetTypeA,T>
type TypeB<T> = Usage<GetTypeB,T>
type A = TypeA<(a: string)=>number> // { getter: number }
type B = TypeB<(a: string)=>number> // { getter: string }
Конечно, в моем простом псевдокоде нельзя было бы использовать инверсию зависимостей для решения проблемы, однако для больших и сложных типов это становится полезным, так как можно повторно использовать код типа, не повторяясь.
Ответы 1
Нет, TypeScript в настоящее время не имеет прямой поддержки так называемых типов высшего типа, которые абстрагируются от универсальных типов так же, как универсальные типы абстрагируются от конкретных типов. Если у вас есть общий тип, такой как type G<T> = {prop: T}, вы не можете ссылаться на G в аннотации, не указав сразу T. Вы не можете передать просто «G» в какой-то сверхобщий тип, например H<G>, где, скажем, type H<F<~>> = F<string>. На microsoft/TypeScript#1213 есть давний открытый запрос на такую поддержку. На данный момент это не часть языка, и кто знает, когда и будет ли вообще.
В этом выпуске упоминаются некоторые обходные пути, в которых вы можете имитировать или эмулировать типы более высокого типа, но для них требуется шаблон, который включает предварительную «регистрацию» ваших универсальных типов. Например:
interface HKT<T = unknown> {
GetTypeA: T extends (arg: any) => infer R ? R : never;
GetTypeB: T extends (arg: infer A) => any ? A : never;
}
type Apply<F extends keyof HKT<any>, T> = HKT<T>[F];
И тогда аналог кода вашего примера выглядит так:
type Usage<G extends keyof HKT, T> = { getter: Apply<G, T> }
type TypeA<T> = Usage<"GetTypeA", T>;
type TypeB<T> = Usage<"GetTypeB", T>;
type A = TypeA<(a: string) => number>; // type A = { getter: number; }
type B = TypeB<(a: string) => number>; // type B = { getter: string; }
Это может или не может стоить того для вашего варианта использования.
TypeScript не имеет прямой поддержки типов более высокого порядка, поэтому невозможно сослаться, скажем, на
GetTypeAбез аргумента типа. Существуют способы имитации/эмулирования таких типов более высокого типа, но эти обходные пути включают в себя много шаблонов и, вероятно, не стоят того. Это полностью отвечает на ваш вопрос? Если это так, я мог бы написать ответ, объясняющий; если нет, то что мне не хватает?