TypeScript:如何编写异步函数组合的 asyncPipe 函数？

Question

我最近又在探索 TypeScript。它的主要限制之一似乎是无法键入函数组合。让我首先向您展示 JavaScript 代码。我正在尝试输入以下内容:

const getUserById = id => new Promise((resolve, reject) => id === 1
  ? resolve({ id, displayName: 'Jan' })
  : reject('User not found.')
);
const getName = ({ displayName }) => displayName;
const countLetters = str => str.length;
const asyncIsEven = n => Promise.resolve(n % 2 === 0);

const asyncPipe = (...fns) => x => fns.reduce(async (y, f) => f(await y), x);

const userHasEvenName = asyncPipe(
    getUserById,
    getName,
    countLetters,
    asyncIsEven
);

userHasEvenName(1).then(console.log);
// ↳ false
userHasEvenName(2).catch(console.log);
// ↳ 'User not found.'

这里 asyncPipe以反数学顺序(从左到右)组成常规函数和 promise 。我很想写一个 asyncPipe在 TypeScript 中，它知道输入和输出类型。所以 userHasEvenName应该知道，它接受一个数字并返回一个 Promise<boolean> .或者，如果您注释掉 getUserById和 asyncIsEven它应该知道它接受了 User并返回一个数字。

以下是 TypeScript 中的辅助函数:

interface User {
    id: number;
    displayName: string;
}

const getUserById = (id: number) => new Promise<User>((resolve, reject) => id === 1
    ? resolve({ id, displayName: 'Jan' })
    : reject('User not found.')
);
const getName = ({ displayName }: { displayName: string }) => displayName;
const countLetters = (str: string) => str.length;
const asyncIsEven = (n: number) => Promise.resolve(n % 2 === 0);

我很乐意向您展示我对 asyncPipe 的所有方法但大多数都离得很远。我发现为了写一个 compose TypeScript 中的函数，你必须 heavily overload这是因为 TypeScript 无法处理反向推理和 compose以数学顺序运行。由于 asyncPipe从左到右作曲，感觉可以写。我能够明确地写一个 pipe2可以组成两个常规函数:

function pipe2<A, B, C>(f: (arg: A) => B, g: (arg: B) => C): (arg: A) => C {
    return x => g(f(x));
}

你会怎么写 asyncPipe异步组成任意数量的函数或 promise 并正确推断返回类型？

Answer 1

变体 1:简单 asyncPipe (playground):

type MaybePromise<T> = Promise<T> | T

function asyncPipe<A, B>(ab: (a: A) => MaybePromise<B>): (a: MaybePromise<A>) => Promise<B>
function asyncPipe<A, B, C>(ab: (a: A) => MaybePromise<B>, bc: (b: B) => MaybePromise<C>): (a: MaybePromise<A>) => Promise<C>
// extend to a reasonable amount of arguments

function asyncPipe(...fns: Function[]) {
    return (x: any) => fns.reduce(async (y, fn) => fn(await y), x)
}

例子:

const userHasEvenName = asyncPipe(getUserById, getName, countLetters, asyncIsEven);
// returns (a: MaybePromise<number>) => Promise<boolean>

警告:即使所有函数参数都是同步的，它也将始终返回一个 promise 。

变体 2:混合 asyncPipe ( playground)
让我们尝试将结果设为 Promise , 如果任何函数是异步的，则返回同步结果。类型在这里很快就会变得臃肿，所以我只使用了一个带有一个重载(两个函数参数)的版本。

function asyncPipe<A, B, C>(ab: (a: A) => B, bc: (b: Sync<B>) => C): < D extends A | Promise<A>>(a: D) => RelayPromise<B, C, D, C>
// extend to a reasonable amount of arguments

function asyncPipe(...fns: Function[]) {
    return (x: any) => fns.reduce((y, fn) => {
        return y instanceof Promise ? y.then(yr => fn(yr)) : fn(y)
    }, x)
}

我定义了两个助手: Sync将始终为您提供已解决的 Promise 类型， RelayPromise如果任何其他参数是 promise ，则将最后一个类型参数转换为 promise (有关更多信息，请参见操场)。
例子:

const t2 = asyncPipe(getName, countLetters)(Promise.resolve({ displayName: "kldjaf" }))
// t2: Promise<number>

const t3 = asyncPipe(getName, countLetters)({ displayName: "kldjaf" })
// t3: number

警告:如果你想在一种类型中同时使用同步 + 异步，它会变得非常复杂，你应该对其进行广泛的测试(我的示例中可能还有一些🐛，我到目前为止只使用了简单的版本)。
还有可能是兼容性的原因，为什么 fp-ts使用 pipe 的特殊版本，这可以更好地使用 TypeScript 从左到右的类型参数推断(这也可能是您的考虑因素)。

笔记
最后，您应该决定是否值得拥有一个特殊的 asyncPipe仅适用于 Promises 的版本 - 更多类型和实现意味着更多潜在错误。
作为替代方案，使用简单的 pipe函数式编程风格的仿函数或单子(monad)。例如。您可以切换到 Task，而不是使用 promise 。或 TaskEither类型(以 fp-ts 为例)。