BUG: Wrong type inferred for AsyncIterableIterator

[babakness]

Search Terms:

AsyncIterableIterator

Code

declare function generatorPipe<A, B, C>(ab: (a: A) => B, bc: (b: B) => C): (a: A) => C
declare function map<A, B>(fn: (p: A) => B): (inputs: Iterable<A>) => AsyncIterableIterator<B>


const foo = generatorPipe(
  map( (i: number ) => i + 1),
  map( (i: number ) => i + 1),
)

Expected behavior:

const foo: (a: Iterable<number>) => AsyncIterableIterator<number>

Actual behavior:

TypeScript seems to infer Iterable for AsyncIterableIterator

Argument of type '(inputs: Iterable) => AsyncIterableIterator' is not assignable to parameter of type '(a: Iterable) => Iterable'.
Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator' but required in type 'Iterable'.ts(2345)

Note, the following works as expected

declare function generatorPipe<A, B, C>(ab: (a: A) => B, bc: (b: B) => C): (a: A) => C
declare function map<A, B>(fn: (p: A) => B): (inputs: Iterable<A>) => IterableIterator<B>

const foo = generatorPipe(
  map( (i: number ) => i + 1),
  map( (i: number ) => i + 1),
)

const foo =  (a: Iterable<number>) => IterableIterator<number>

Playground Link:

Playground does not support AsyncIterableIterator

[dragomirtitian]

Not sure what the bug is here ? AsyncIterableIterator<number> is not assignable to Iterable<number>. The non async example works since IterableIterator<number> is assignable to Iterable<number>.

Relevant definitions:

// Not async 
interface Iterator<T> {
    next(value?: any): IteratorResult<T>;
    return?(value?: any): IteratorResult<T>;
    throw?(e?: any): IteratorResult<T>;
}

interface Iterable<T> {
    [Symbol.iterator](): Iterator<T>;
}

interface IterableIterator<T> extends Iterator<T> {
    [Symbol.iterator](): IterableIterator<T>;
}
// async version 
interface AsyncIterator<T> {
    next(value?: any): Promise<IteratorResult<T>>;
    return?(value?: any): Promise<IteratorResult<T>>;
    throw?(e?: any): Promise<IteratorResult<T>>;
}



interface AsyncIterable<T> {
    [Symbol.asyncIterator](): AsyncIterator<T>;
}

interface AsyncIterableIterator<T> extends AsyncIterator<T> {
    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
}

Your async version works if you change in map, Iterable to AsyncIterable:

declare function generatorPipe<A, B, C>(ab: (a: A) => B, bc: (b: B) => C): (a: A) => C
declare function map<A, B>(fn: (p: A) => B): (inputs: AsyncIterable<A>) => AsyncIterableIterator<B>

const foo = generatorPipe(
    map( (i: number ) => i + 1),
    map( (i: number ) => i + 1),
)
// foo: (a: AsyncIterable<number>) => AsyncIterableIterator<number>

[babakness]

Ah! Indeed my misunderstanding. Thanks for the clarification.