如何创建只接受具有特定嵌套类型的类型实例的泛型函数？

Question

更新

我自己做了一个解决方案，将嵌套类型从静态字段移动到实例字段，这似乎可行但并不完美：https://tsplay.dev/w26Xjw

---

更新

主要用途是：

1. 我想创建一个接受两个参数的泛型函数；
2. 这些参数的类型可以是connected/related
3. 当我将第一个参数传递给 T 的类型时，它应该自动推断出第二个参数的类型 U

所以问题是：

1. 如何正确地使这两种类型连接/关联？我尝试使用嵌套类型，就像我在下面的上一篇文章中一样，这可能不是一种合适的方式，但我不知道。欢迎任何建议。
2. 一旦这些类型连接/相关，如果可能的话，后一个类型是否可以从第一个类型自动推断？

这样当用户传递第一个参数时，泛型函数应该限制第二个参数的类型。

我想在 C++ 中写一些类似的东西：

class A {
    class InnerType {}
}

template<typename T>
void test(const T& first, const typename T::InnerType& second);

---

我想创建一个接受两个参数的通用函数：

1. 第一个参数应该是T 的类型，并且会有一个嵌套类型T.Param
2. 第二个参数的类型应该是T.Param

class A {
    static Param = class {
        ....
    }
}

class B {
    static Param = class {
        ....
    }
}

// How can I make the T/P match the requirements explain above?
function test<T, P>(first:T, second:P) {
}

然后这样的调用应该通过：

test(new A(), new A.Param()); // OK
test(new A(), new B.Param()); // Fail
test(new B(), new A.Param()); // Fail
test(new B(), new B.Param()); // OK

Answer 1

有几种不同的方法可以做到这一点，部分取决于您想要推动流程的参数。你可以用第一个参数来驱动它：

function test1<T extends {Param: unknown}, P extends T["Param"]>(first: T, second: P) {
    // ...
}

或第二个：

function test2<P, T extends {Param: P}>(first: T, second: P) {
    // ...
}

有了这些，你会得到这些结果：

test1(A, A.Param); // works
test1(B, A.Param); // error on second argument

test2(A, A.Param); // works
test2(B, A.Param); // error on first argument

Playground with both

---

请注意，因为 TypeScript 的类型系统是 structural（基于类型的形状）而不是名义上的（基于类型的名称），所以在操场链接中我添加了一些东西到 A.Param 和B.Param 所以他们不会有相同的形状。否则，由于它们的形状相同（空类），因此可以使用其中一个来代替另一个。

Answer 2

This 的回答可能对你很感兴趣。

下一个解决方案呢？

class ParamA {
    foo: number = 0
}

class ParamB {
    bar: string = ''
}

class A {
    InnerType = () => ParamA
}

class B {
    InnerType = () => ParamB
}


function test1<
    T extends { InnerType: any },
    P extends InstanceType<ReturnType<T["InnerType"]>>,
    >(first: T, second: P) {
    // ...
}

test1(new A(), new ParamA());
test1(new B(), new ParamA()); // error
test1(new A(), new ParamB()); //error
test1(new B(), new ParamB());

Answer 3

作为对这个伟大的 answer 的补充。

要让你的函数只接受这些类型的实例，你可以将它们定义为：

function test1<
    T extends {Param: { new (): unknown }}, 
    P extends T["Param"]
>(first: T, second: InstanceType<P>) {}

function test2<
    P, 
    T extends {Param: { new (): P }}
>(first: T, second: P) {}

test1(A, new A.Param()); // works
test1(B, new A.Param()); // error on second argument

test2(A, new A.Param()); // works
test2(B, new A.Param()); // error on first argument

playground link

Answer 4

你不能。

虽然我确实有一个解决方法。

注意：我将我的答案复制到your duplicate question，因为我花了很多时间来整理它。我在下面给出的示例是基于该问题的，因此与上面的 完全相同 不一样，但它很接近并且完全涵盖了问题。

Typescript 不包含静态成员作为类表示的类型的一部分。 The following is in TS Playground 这样您就可以看到错误消息。我添加ParamClass 是因为我们需要一些 方法来引用泛型函数中Param 的类型。

class ParamClass {
    foo: number = 0
}

class A1 {
    Param: typeof ParamClass = class {
        foo: number = 0
    }
}

class A2 {
    static Param: typeof ParamClass = class {
        foo: number = 0
    }
}

const a1: A1 = {}  //fails type check: Property 'Param' is missing in type '{}' but required in type 'A1'.(2741)

const a2: A2 = {}  //passes type check, static class member is not part of type A2


function test1<T extends {Param: typeof ParamClass}>(c: T): T {
  return c
}

test1(new A1())  //passes

test1(new A2())  //fails: Property 'Param' is missing in type 'A2' but required in type '{ Param: typeof ParamClass; }'.(2345)


// But what if we define T to have a static member? 
// You can't. It's not legal Typescript:
//
//      'static' modifier cannot appear on a type member.(1070)
//
function test2<T extends {static Param: typeof ParamClass}>(c: T): T {
  return c
}

我的解决方法

in playground

class ParamClass {
    foo: number = 0
}

class A3 {
    static Param: typeof ParamClass = class {
        foo: number = 0
    }
    get Param() { 
        return A3.Param
    } 
}

class B {
}


function test1<T extends {Param: typeof ParamClass}>(c: T): T {
  const param = c.Param
  // now you can do whatever you want with class Param, e.g. 
  const paramInstance = new param() 
  return c
}

test1(new A3())  // passes type check

test1(new B())  // fails type check