Typescript：变量 function arguments 取决于前面的 arguments

Question

这个问题以前一定有人问过，我几乎可以肯定。 然而：

1. 我找不到任何这样的问题
2. Typescript 最近取得了重大飞跃，因此现有答案可能已经过时。

我在我的代码中经常使用的东西是 function arguments 的扩展运算符，它允许我接受 arguments 的可变长度数组。 我现在要做的是为 function 创建 TS 类型定义，其中arg1类型取决于arg2类型，而arg2取决于arg3 ，依此类推。

非常像 lodash https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/lodash/common/util.d.ts#L209

 flow<R2, R3, R4, R5, R6, R7>(f2: (a: ReturnType<T>) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): Function<(...args: Parameters<T>) => R7>;

lodash 方法显然非常有限，并且在 8 arguments 处也达到最大值（在本例中）。 这很好，我可以忍受它，但是，在 2021 年有更好、更递归的方式吗？ 一种对（理论上） infinite数量的 arguments 做同样事情的方法？

如果存在并且它是最新的，请随时关闭问题并向我指出现有答案。

Answer 1

通过条件类型的推断，这是可能的（尽管有点难看）：

// convenience alias
type Func = (...args: any[]) => any;

// check arguments in reverse
// since typescript doesn't like deconstructing arrays into init/last
type CheckArgsRev<T extends Func[]> =
    // get first two elements
    T extends [infer H1, infer H2, ...infer R]
        // typescript loses typings on the inferred types
        // so this gains them back
        ? H1 extends Func ? H2 extends Func ? R extends Func[]
            // actual check
            // ensures parameters of next argument extends return type of previous
            // you can substitute this with whatever check you want to add
            // just know that H1 is the current argument type and H2 is the previous
            // also if you change this to work with non-functions then change Func to an appropriate type
            // like unknown to work with all types
            ? Parameters<H1> extends [ReturnType<H2>]
                // it was a match, recurse onto the tail
                ? [H1, ...CheckArgsRev<[H2, ...R]>]
                : never // invalid type, become never for error
            : never : never : never // should never happen
        // base case, 0 or 1 elements should always pass
        : T;

// reverse a tuple type
type Reverse<T extends unknown[]> =
    T extends [infer H, ...infer R]
        ? [...Reverse<R>, H]
        : [];

// check args not in reverse by reversing twice
type CheckArgs<T extends Func[]> = Reverse<CheckArgsRev<Reverse<T>>>;

// make sure the argument passes the check
function flow<T extends Func[]>(...args: T & CheckArgs<T>) {
    console.log(args);
}

// this is invalid (since number cannot flow into a string)
flow((x: string) => parseInt(x, 10), (x: string) => x + "1");
// this is valid (number flows into number)
flow((x: string) => parseInt(x, 10), (x: number) => x + 1);

游乐场链接

Answer 2

Applet 的回答很棒。 但是当您传递错误的参数时，它会放弃有关 function 数组的类型信息。 仅Argument of type '(x: string) => number' is not assignable to parameter of type 'never'. 当错误实际上来自(x: string) => string时并不是很有帮助。

不幸的是，似乎并没有一种强大的方法可以做到这一点，但我仍然想分享我的 2 美分-

type AnyFunc = (a: any) => any;

// Given a tuple of functions - deduce how much of it is flowable
type FlowFrom<T extends readonly AnyFunc[]> = T extends [(a: infer R) => any, ...AnyFunc[]]
    ? // Infer the argument type of the first function and pass it to `FlowFrom$`
      FlowFrom$<R, T>
    : // T was empty array
      [];

// Actual function that deduces how much of a tuple is flowable, taking previous return type and remaining functions
type FlowFrom$<R, T extends readonly [(a: R) => any, ...AnyFunc[]]> = T extends [
    (a: R) => infer R$,
    ...infer Tail
]
    ? Tail extends [(a: R$) => any, ...AnyFunc[]]
        ? // Valid, continue
          [(a: R) => R$, ...FlowFrom$<R$, Tail>]
        : // Tail has either been exhausted or invalid function has been found
        Tail extends [(a: any) => any, ...AnyFunc[]]
        ? // Invalid function found, append a correct function type so it points out the specific error
          // But make the appended function optional, the flow is still valid before this point
          [(a: R) => R$, (a: R$) => any] | [(a: R) => R$]
        : // Tail exhausted
          [(a: R) => R$]
    : // T is empty, exhausted tuple (impossible - apparently)
      [];

FlowFrom从给定的函数元组推导出一个“可流动的”元组类型。 本质上，它提取元组中将相互流入的所有函数，当遇到不再可流动的 function 或元组耗尽时停止。

// All the functions in the tuple type are flowable - the return type is the same
let valid: FlowFrom<[(x: string) => number, (x: number) => number]>;
//  ^ [(a: string) => number, (a: number) => number]

// First function won't flow into the second one - stop at first one
let invalid: FlowFrom<[(x: string) => number, (x: string) => number]>;
//  ^ [(a: string) => number, (a: number) => any] | [(a: string) => number]

这意味着，当您尝试将[(x: string) => parseInt(x, 10), (x: string) => x + '1']分配给invalid时，您会得到一个很好的错误-

let invalid: FlowFrom<[(x: string) => number, (x: string) => number]> = [
    (x: string) => parseInt(x, 10),
    (x: string) => x + '1',
];
//  ^ Type 'number' is not assignable to type 'string'

但是，你仍然可以在那个断点之前分配这些东西——

let reducedButCorrect: FlowFrom<[(x: string) => number, (x: string) => number]> = [
    (x: string) => parseInt(x, 10),
];

（如果您不想要这种行为，例如 - 当存在断点时仍然能够分配断点之前的所有内容，请从FlowFrom$中删除联合类型， [(a: R) => R$, (a: R$) => any] | [(a: R) => R$] -> [(a: R) => R$, (a: R$) => any] )

您现在可以像使用它一样 -

declare function flow<T extends readonly AnyFunc[]>(...args: T & FlowFrom<T>): unknown;

// Valid
flow(
    (x: string) => parseInt(x, 10),
    (x: number) => Boolean(x),
    (x: boolean) => Number(x)
);

// Invalid
flow(
    (x: string) => parseInt(x, 10),
    (x: number) => Boolean(x),
    (x: string) => Number(x)
);
//  ^ Type 'boolean' is not assignable to type 'string'

在操场上尝试所有这些

只是想分享我的两分钱。