Por que os geradores comuns permitem escrever código…

Os geradores comuns em JavaScript permitem escrever código assíncrono graças à sua capacidade de pausar e retomar a execução, bem como de transmitir valores em ambas as direções (através de yield e next()).

Aqui está como isso funciona no contexto da assíncronia:

Pausa na execução (yield): Quando a instrução yield é atingida, o gerador é pausado e retorna um valor. Em código assíncrono, esse valor pode ser uma promessa ou outra "ação" que precisa ser executada de forma assíncrona.
Aguardar o resultado assíncrono: O código externo (por exemplo, um "runner" ou um wrapper para o gerador) recebe o valor passado através de yield. Se for uma promessa, ele espera por sua resolução ou rejeição.
Retomar a execução (next()): Após a conclusão da operação assíncrona (resolução da promessa), o resultado assíncrono (o valor da promessa) é passado de volta ao gerador através do método next(). O gerador retoma a execução de onde foi pausado.
Transmissão do resultado: O valor passado para next() torna-se o resultado da expressão yield dentro do gerador. Assim, o gerador pode "obter" o resultado da operação assíncrona e continuar a trabalhar com ele, como se o código fosse síncrono.

Este padrão cria uma ilusão de execução síncrona para operações assíncronas, tornando o código mais legível e gerenciável em comparação com o uso tradicional de callbacks ou cadeias complexas de .then().

Um exemplo disso são os wrappers como co (embora agora sejam mais comuns async/await, que na essência são açúcar sintático sobre geradores e promessas):

// Exemplo de uso de gerador para assíncronia
function* myAsyncGenerator() {
  try {
    const result1 = yield Promise.resolve(1); // Pausa, retorna promessa
    console.log('Primeiro resultado recebido:', result1); // Retoma com o valor

    const result2 = yield new Promise(resolve => setTimeout(() => resolve(2), 500)); // Outra operação assíncrona
    console.log('Segundo resultado recebido:', result2);

    return 'Pronto'; // Finaliza o gerador
  } catch (error) {
    console.error('Ocorreu um erro:', error);
  }
}

// "Runner" simples para o gerador (simplificado)
function run(generatorFunc) {
  const generator = generatorFunc();

  function handleNext(newValue) {
    const result = generator.next(newValue);

    if (!result.done) {
      if (result.value instanceof Promise) {
        result.value.then(handleNext).catch(handleError);
      } else {
        handleNext(result.value);
      }
    } else {
      console.log('Gerador finalizado com resultado:', result.value);
    }
  }

  function handleError(error) {
      generator.throw(error);
  }

  handleNext(); // Iniciar o gerador
}

// Executar nosso gerador assíncrono
run(myAsyncGenerator);

Neste exemplo, yield Promise.resolve(1) pausa o gerador. O "runner" (ou co) espera a promessa ser resolvida e então retoma o gerador, passando o valor 1 via next(1). Este valor 1 torna-se o resultado de yield Promise.resolve(1) dentro do gerador, permitindo processá-lo na próxima linha (console.log). Este mecanismo permite simular um fluxo de execução síncrono para operações assíncronas.

Por que os geradores comuns permitem escrever código assíncrono?