Callback argument type not inferred for union of interfaces

🔎 Search Terms

"implicitly has an" inference

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about "inference"

⏯ Playground Link

https://www.typescriptlang.org/play/?target=5&ts=5.5.3#code/KYDwDg9gTgLgBASwHY2FAZgQwMbDgQQGcBPJbAJWEIFcAbGAYU1toCMcBrAHgBUAaOAFE4AXiFQo0AHxwA3gFgAUHBVwAFGigB+AFxC4AHzhI6tAVCp0YuuDwCUegG4QEAEwDcSgL5KloSLCIKGhYuAQkZJQ09ACSqFCYMNC8AuQCwmKCEtJySqrqCKgAtnr8cNjMbJx6RKQUlvRMLOzY3GlCUg5wzm6eij6K-tDwyPGheLWRDTBxaInQAAqSRQiEwClw5DIKyqpqhcAltl1LECtrXFt9A0quwNi0mBZw6NRkMAgQSHBFmGAAMggVjANu0MuJJFApGo8qonlBSgBtAC6fFhKloQMKehMRVYaDRuxUBwSSQRKkm9WiM3i8ygp3O6zKW0M4TqUSss1JyWZ6SkhJOy1W63IKKkfSUvwBWJgakRAEY+AAmPgAZlRcFVAkwEWw6iQdlE23RcAsMGoUG+3wAVNa4ErrnZ3EA

💻 Code

export interface AsyncResultCallback<T, E = Error> {
    (err?: E | null, result?: T): void;
}

export interface AsyncResultIterator<T, R, E = Error> {
    (item: T, callback: AsyncResultCallback<R, E>): void;
}
export interface AsyncResultIteratorPromise<T, R> {
    (item: T): Promise<R>;
}

declare function mapLimit<T, R, E = Error>(
    arr: T[],
    limit: number,
    iterator:  AsyncResultIteratorPromise<T, R> | AsyncResultIterator<T, R, E>,
): Promise<R[]>;

mapLimit([1,2,3], 3, async (n) => {
    return n ** 2;
});

🙁 Actual behavior

The type of n in the mapLimit callback is inferred as any:

Parameter 'n' implicitly has an 'any' type. (7006)

🙂 Expected behavior

I would expect the type of n to be inferred as number.

Additional information about the issue

This example is based on the types for the async package:

https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b9820410f85f259cbad6065d8cb6f23f403109ac/types/async/index.d.ts#L321-L325

Note that if the type for iterator in mapLimit is changed to either just AsyncResultIteratorPromise<T, R> or just AsyncResultIterator<T, R, E> (that is, no longer a union type), things work as expected and n has type number.

I found a very old discussion of what looks to be the same issue in the DefinitelyTyped repo: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/24297. The issue described there is exactly the one I'm facing. One commenter claimed that things worked correctly, and another commenter claimed that changing the way that async was imported had some effect? Neither of those sounds plausible to me.

I found some issues that may describe the same or a similar problem:

• https://github.com/microsoft/TypeScript/issues/56881
• https://github.com/microsoft/TypeScript/issues/55632
• https://github.com/microsoft/TypeScript/issues/52047
• https://github.com/microsoft/TypeScript/issues/47599

However, my knowledge of TypeScript internals/terminology isn't strong enough to say for sure that this isn't a novel issue I'm facing. If this is in fact a duplicate, please close it as such and I'll add this example to the relevant issue. Thank you!

Commencez par le Playground lié et l’exemple minimal de mapLimit, puis comparez l’inférence lorsque iterator est chaque interface séparément et lorsqu’il s’agit de leur union. Consultez les issues TypeScript associées et la définition de type async liée pour disposer du contexte correspondant. C’est terminé lorsque, dans le cas de l’union, le paramètre n du callback est inféré comme number sans erreur d’implicit-any.