Callback argument type not inferred for union of interfaces

Comienza con el Playground enlazado y el ejemplo mínimo de mapLimit; después compara la inferencia cuando iterator es cada interfaz por separado frente a su unión. Revisa las incidencias relacionadas de TypeScript y la definición de tipos async enlazada para obtener el contexto correspondiente. Se considera terminado cuando, en el caso de la unión, n se infiere como number en el parámetro del callback sin un error de implicit-any.

🔎 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!