Suggestion needed - Wrapping AsyncGenerator

Sorry for opening an issue with what is basically a question/ feedback for API ergonomics…

Has any of you stumbled upon a situation where you’d want to wrap an AsynGenerator in a Result somehow where the ultimate goal is to typify the possible errors and effectively not have it throwing exceptions?

Let’s say that the AsyncGenerator is wrapping a REST API Call and yielding results over time:

type SomeData = {};

type SomeApiResult = {
    content: SomeData[];
    nextToken?: string;
};


const getData = async (nextToken?: string): Promise<SomeApiResult> => /*...*/;

async function* getAllData(): AsyncGenerator<SomeData> {
    let loadMore = true;
    let prevNextToken: string | undefined = undefined;
    while (loadMore) {
        const result = await getData(prevNextToken);
        for (const data of result.content) {
            yield data;
        }
        loadMore = result.nextToken !== prevNextToken;
        prevNextToken = result.nextToken;
    }
}

One way I see it, is to have the generator return Results and as soon as an exception is thrown/promise rejection occurs, yield the error. This breaks the iteration as soon as the error occurs however, the side effect is that now the consumer has to unwrap each received value from the result and this breaks the norms of common generators.

async function* getAllData(): AsyncGenerator<Result<SomeData, SomeError>>;

[konradekk]

That case would be better solved by streams (see e.g. RxJS solutions). What you roughly do here is: maintain a stream reading iterables that you flatten (with mapping) into the stream. You could convert to async iteration from the streaming with some small effort (see e.g. this implementation on StackOverflow).

Iʼd second @paduc here (providing him with bounty!) and avoid Result completely here.

[supermacro]

I’m adding a bounty to this if it ever gets resolved; $100 USD