如何让 TypeScript 为这些参数推断正确的类型？

Question

我正在尝试使一个库在 Promise 库中通用，但我遇到了这样一种情况，在同一类型中，单个类型参数被推断为两种不同的类型：

interface PromiseClass<A, P extends PromiseLike<A>> {
    new(
        callback: (resolve: (value?: A | P) => void, reject: (reason?: any) => void) => void): P;
}

interface Options<A, P extends PromiseLike<A>> {
    promise?: PromiseClass<A, P>;
}

declare class PromisePool<
    A,                        // the type of value returned by the source
    P extends PromiseLike<A>, // the type of Promise returned by the source
    P2 extends PromiseLike<A>, // the type of Promise specified in `options`
    > {
    constructor(
        source: P,
        concurrency: number,
        options?: Options<A, P2>
    );

    start(): P2;
}

class FakePromise<T> implements PromiseLike<T> {
    constructor(
        _callback: (
            resolve: (value?: T | FakePromise<T>) => void,
            reject: (reason?: any) => void) => void) {
    }

    then<TResult1 = T, TResult2 = never>(
        _onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
        _onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null):
        PromiseLike<TResult1 | TResult2> {
        throw new Error("stub");
    }
};


// erroneously inferred as PromisePool<unknown, FakePromise<number>,
// PromiseLike<unknown>> instead of PromisePool<number, FakePromise<number>,
// PromiseLike<number>> i.e. A is inferred as both `unknown` and `number`
const pool = new PromisePool(
    new FakePromise<number>((_resolve, _reject) => true), 1);

// error:
// Type 'PromiseLike<unknown>' is not assignable to type 'PromiseLike<number>'.
//   Type 'unknown' is not assignable to type 'number'.
const promise: PromiseLike<number> = pool.start();

(Playground link.)

如果我指定 pool 的完整类型，它会起作用：

const pool: PromisePool<number, FakePromise<number>, PromiseLike<number>> = new PromisePool(
    new FakePromise<number>((_resolve, _reject) => true), 1);

我如何告诉 TypeScript pool.start 将返回 PromiseLike<number> 而无需写出来？

Answer 1

只需从这个类中去掉第二个和第三个泛型参数 (P, P2)：

declare class PromisePool<
    A,
    > {
    constructor(
        source: PromiseLike<A>,
        concurrency: number,
        options?: Options<A,  PromiseLike<A>>
    );

    start(): PromiseLike<A>;
}

完整示例：

interface PromiseClass<A, P extends PromiseLike<A>> {
    new(
        callback: (resolve: (value?: A | P) => void, reject: (reason?: any) => void) => void): P;
}

interface Options<A, P extends PromiseLike<A>> {
    promise?: PromiseClass<A, P>;
}

declare class PromisePool<
    A,
    > {
    constructor(
        source: PromiseLike<A>,
        concurrency: number,
        options?: Options<A,  PromiseLike<A>>
    );

    start(): PromiseLike<A>;
}

class FakePromise<T> implements PromiseLike<T> {
    constructor(
        _callback: (
            resolve: (value?: T | FakePromise<T>) => void,
            reject: (reason?: any) => void) => void) {
    }

    then<TResult1 = T, TResult2 = never>(
        _onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
        _onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null):
        PromiseLike<TResult1 | TResult2> {
        throw new Error("stub");
    }
};


// erroneously inferred as PromisePool<unknown, FakePromise<number>,
// PromiseLike<unknown>> instead of PromisePool<number, FakePromise<number>,
// PromiseLike<number>> i.e. A is inferred as both `unknown` and `number`
const pool = new PromisePool(
    new FakePromise<number>((_resolve, _reject) => true), 1);


const promise = pool.start(); // ok

Playground

更新 这个解决方案怎么样：

interface PromiseClass<A, P extends PromiseLike<A>> {
    new(
        callback: (resolve: (value?: A | P) => void, reject: (reason?: any) => void) => void): P;
}

interface Options<A, P extends PromiseLike<A>> {
    promise?: PromiseClass<A, P>;
}

declare class PromisePool<
    A,
    T,
    > {
    constructor(
        source: PromiseLike<A>,
        concurrency: T,
        options?: Options<A,  PromiseLike<A>>
    );

    start(): PromiseLike<T>;
}

class FakePromise<T> implements PromiseLike<T> {
    constructor(
        _callback: (
            resolve: (value?: T | FakePromise<T>) => void,
            reject: (reason?: any) => void) => void) {
    }

    then<TResult1 = T, TResult2 = never>(
        _onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
        _onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null):
        PromiseLike<TResult1 | TResult2> {
        throw new Error("stub");
    }
};


// erroneously inferred as PromisePool<unknown, FakePromise<number>,
// PromiseLike<unknown>> instead of PromisePool<number, FakePromise<number>,
// PromiseLike<number>> i.e. A is inferred as both `unknown` and `number`
const fake = new FakePromise<number>((_resolve, _reject) => true);
const pool = new PromisePool(fake, 1);