TypeScript 中的高阶类型函数?

请考虑以下伪代码，尝试使用函数类型的参数定义高阶类型函数M<?>：

type HigherOrderTypeFn<T, M<?>> = T extends (...)
? M<T>
: never;

M<?>TypeScript 语法不正确，但将类型签名声明为HigherOrderTypeFn<T, M>会在第二行产生错误Type 'M' is not generic. ts(2315)。

假设这种类型目前在 TS 中不可表示是否正确？

你是对的，它目前在TypeScript中不可表示。有一个长期开放的GitHub功能请求，microsoft/TypeScript#1213，它可能应该被命名为"支持更高种类的类型"，但目前的标题是"允许类在其他参数类中参数化"。

在讨论中有一些关于如何在当前语言中模拟这种高级类型的想法(有关具体示例，请参阅此评论(，但在我看来，它们可能不属于生产代码。如果你有一些特定的结构要实现，也许可以建议一些合适的东西。

但无论如何，如果你想增加这种情况发生的机会(不幸的是，可能可以忽略不计(，你可能想去那个问题并给它一个👍和/或描述你的用例，如果你认为它特别引人注目与已经存在的东西相比。

对于您和其他寻找解决方法的人，您可以尝试基于占位符的简单想法(请参阅jcalz提到的讨论中的此评论(：

type Placeholder = {'aUniqueKey': unknown};
type Replace<T, X, Y> = {
[k in keyof T]: T[k] extends X ? Y : T[k];
};

因此，您的函数如下所示：

type HigherOrderTypeFn<T, M> = T extends (...) ? Replace<M, Placeholder, T> : never;

并像这样称呼

：

type M<U> = U[];
type X = HigherOrderTypeFn<number, M<Placeholder>> // is number[] (if ... is number)

对于遇到这个问题的人来说，在TypeScript不和谐服务器上有一个很好的例子：

export interface Hkt<I = unknown, O = unknown> {
[Hkt.isHkt]: never,
[Hkt.input]: I,
[Hkt.output]: O,
}
export declare namespace Hkt {
const isHkt: unique symbol
const input: unique symbol
const output: unique symbol
type Input<T extends Hkt<any, any>> =
T[typeof Hkt.input]
type Output<T extends Hkt<any, any>, I extends Input<T>> =
(T & { [input]: I })[typeof output]
interface Compose<O, A extends Hkt<any, O>, B extends Hkt<any, Input<A>>> extends Hkt<Input<B>, O>{
[output]: Output<A, Output<B, Input<this>>>,
}
interface Constant<T, I = unknown> extends Hkt<I, T> {}
}

可以按如下方式使用。下面的代码片段定义了一个SetFactory，您可以在创建工厂时指定所需的集合类型类型，例如typeof FooSet或typeof BarSet.typeof FooSet是FooSet的构造函数，并且与高级类型类似，构造函数类型接受任何T并返回FooSet<T>。该SetFactory包含多个方法，例如createNumberSet，它返回给定类型的新集合，类型参数设置为number。

interface FooSetHkt extends Hkt<unknown, FooSet<any>> {
[Hkt.output]: FooSet<Hkt.Input<this>>
}
class FooSet<T> extends Set<T> {
foo() {} 
static hkt: FooSetHkt;
}
interface BarSetHkt extends Hkt<unknown, BarSet<any>> {
[Hkt.output]: BarSet<Hkt.Input<this>>;
}
class BarSet<T> extends Set<T> { 
bar() {} 
static hkt: BarSetHkt;
}
class SetFactory<Cons extends {
new <T>(): Hkt.Output<Cons["hkt"], T>;
hkt: Hkt<unknown, Set<any>>;
}> {
constructor(private Ctr: Cons) {}
createNumberSet() { return new this.Ctr<number>(); }
createStringSet() { return new this.Ctr<string>(); }
}
// SetFactory<typeof FooSet>
const fooFactory = new SetFactory(FooSet);
// SetFactory<typeof BarSet>
const barFactory = new SetFactory(BarSet);
// FooSet<number>
fooFactory.createNumberSet();
// FooSet<string>
fooFactory.createStringSet();
// BarSet<number>
barFactory.createNumberSet();
// BarSet<string>
barFactory.createStringSet();

简要说明其工作原理(以FooSet和number为例(：

要了解的主要类型是Hkt.Output<Const["hkt"], T>.替换我们的示例类型后，这变得Hkt.Output<(typeof FooSet)["hkt"], number>.现在的魔力是把它变成一个FooSet<number>
首先，我们(typeof FooSet)["hkt"]FooSetHkt.很多魔力就在这里，通过在FooSet的静态hkt属性中存储有关如何创建FooSet的信息。您需要为每个受支持的类执行此操作。
现在我们有Hkt.Output<FooSetHkt, number>.解析Hkt.Output类型别名，我们得到(FooSetHkt & { [Hkt.input]: number })[typeof Hkt.output].唯一符号Hkt.input/Hkt.output有助于创建唯一属性，但我们也可以使用唯一的字符串常量。
现在我们需要访问FooSetHkt的Hkt.output属性。这对于每个类都是不同的，并且包含有关如何使用 type 参数构造具体类型的详细信息。FooSetHkt将输出属性定义为类型FooSet<Hkt.Input<this>>。
最后，Hkt.Input<this>只是获得了FooSetHkt的Hkt.input属性。它将解析为unknown，但是通过使用交集FooSetHkt & { [Hkt.input]: number }，我们可以将Hkt.input属性更改为number。因此，如果我们达到了目标，Hkt.Input<this>决心number，FooSet<Hkt.Input<this>>决心FooSet<number>。

对于问题中的示例，Hkt.Output本质上是所要求的，只是类型参数颠倒了：

interface List<T> {}
interface ListHkt extends Hkt<unknown, List<any>> {
[Hkt.output]: List<Hkt.Input<this>>
}
type HigherOrderTypeFn<T, M extends Hkt> = Hkt.Output<M, T>;
// Gives you List<number>
type X = HigherOrderTypeFn<number, ListHkt>;

在 fp-ts 中有一个 HKT(利用模块增强(的实现。

作者在此处记录的高级类型解决方法是：

export interface HKT<URI, A> {
readonly _URI: URI;
readonly _A: A;
}

并且可以像这样使用：

export interface Foldable<F> {
readonly URI: F;
reduce: <A, B>(fa: HKT<F, A>, b: B, f: (b: B, a: A) => B) => B;
}

看看这个问题：来自 fp-ts 和 URI 的打字稿中的高级类型

类型也许这可以提供一些启示？

干杯

相关内容

最新更新

热门标签：