组合通用 function 参数类型

Question

我希望 typescript 接受具有相似结构但具有不同值的 arguments 列表，并正确推断生成的联合类型。

示例代码

interface User<
    N extends string = string,
    S extends unknown = unknown,
    A extends (a: S) => unknown = (a: S) => unknown
> {
    name: N;
    state: S;
    action: A;
}

function createUser<
    N extends string = string,
    S extends unknown = unknown,
    A extends (a: S) => unknown = (a: S) => unknown
>(name: N, state: S, action: A): User<N, S, A> {
    return { action, name, state };
}

function combineUsers<
    V extends User<string, unknown, (a: unknown) => unknown>[]
>(...users: V) {
    type Names = V[number]["name"];
    return {
        actions: users.reduce(
            (a, u) => ({ ...a, [u.name]: u.action }),
            {} as { [K in Names]: Extract<V[number], { name: K }>["action"] },
        ),
        names: new Set<Names>(users.map((u) => u.name)),
    };
}

const userA = createUser("user1", 1, (_a: number) => undefined);
const user2 = createUser("userB", "two", (_s: string) => true);
const users = combineUsers(userA, user2);
// Argument of type 'User<"user1", number, (_a: number) => undefined>' is not assignable to parameter of type 'User<string, unknown, (a: unknown) => unknown>'.
//   Type '(_a: number) => undefined' is not assignable to type '(a: unknown) => unknown'.
//     Types of parameters '_a' and 'a' are incompatible.
//       Type 'unknown' is not assignable to type 'number'.ts(2345)

那是由于不兼容的功能而导致的编译错误。

我希望看到 function 返回的类型是某种推断的联合；

type Return = {
    names: Set<"user1" | "userB">,
    actions: {
        user1: (_a: number) => undefined;
        userB: (_s: string) => boolean;
    }
}

• 这可能吗？ 可以洒any但我宁愿不
• 是否有任何替代方法或更好的方法来实现这一目标

编辑：

@jcalz 的解决方案对于之前版本中所述的问题非常有效，但我的示例缺少一些使其适用于我的实际代码的内容，即当 function 的参数必须与别处定义的类型匹配时。

Answer 1

我给combinedUsers的输入看起来像这样：

function combineUsers<V extends User<string, never[], unknown>[]>(...users: V) {
  type Names = V[number]['name'];
  return {
    actions: users.reduce(
      (a, u) => ({ ...a, [u.name]: u.action }),
      {} as { [K in Names]: Extract<V[number], { name: K }>['action'] }
    ),
    names: new Set<Names>(users.map((u) => u.name)),
  };
}

请注意，只有一个泛型类型参数V对应于传入的User<N, A, R>对象数组。类型参数string （属性类型的协变上限约束）， never[] （逆变下限约束）对于参数类型）和unknown （返回值类型的协变上限约束）比any 、 any 、 any稍微更安全一些，但仍然可以允许一些奇怪的输入。 希望这实际上并不重要。

在实现中，我们定义Names类型来获取V的每个元素的N个参数的联合（ V[number]['name']是您使用number索引索引users然后索引结果User时获得的类型带有"name"索引）。

actions属性的类型是一个映射类型，其中对于Names中的每个名称，我们找到V中以该名称作为name的元素，并获取其action类型。

---

让我们看看它是否有效。 假设您有这些类型的userA和user2 ：

//const userA: User<"user1", [x: number, y: string], undefined>
//const user2: User<"userB", [x: string], boolean>

然后你combineUsers(userA, user2)结果是：

const users = combineUsers(userA, user2);
/* const users: {
    actions: {
        user1: (x: number, y: string) => undefined;
        userB: (x: string) => boolean;
    };
    names: Set<"user1" | "userB">;
} */

看起来不错。

游乐场代码链接