send e corrotinas: a ponte para o async

O yield também recebe valores

Até aqui o yield foi uma via de mão única: o gerador produz um valor e quem consome recebe. Mas o yield também pode ser uma expressão que recebe um valor de volta. Quando você escreve recebido = yield, o gerador pausa naquele ponto e, quando alguém o retoma com o método send, o valor enviado se torna o resultado dessa expressão, ficando guardado em recebido. É uma comunicação de mão dupla: dados saem com o yield e entram com o send.

def acumulador():
    total = 0
    while True:
        valor = yield total   # produz o total e espera um novo valor
        total += valor        # o valor enviado com send() chega aqui

acc = acumulador()
next(acc)              # avanca ate o primeiro yield (necessario)
print(acc.send(10))    # 10
print(acc.send(5))     # 15
print(acc.send(3))     # 18

valor = yield recebe o que send envia; o gerador vira um acumulador vivo.

Acompanhe o fluxo. Primeiro é preciso avançar o gerador até o primeiro yield, seja com next, seja com send(None); esse passo é conhecido como escorvar a corrotina. A partir daí, cada send envia um número que vira o valor da expressão yield, é somado ao total, e o novo total é produzido de volta. O gerador mantém seu estado, o total, entre as chamadas, funcionando como um pequeno objeto que aprende com o que recebe.

Isso é uma corrotina

Um gerador que recebe valores com send tem um nome: corrotina baseada em gerador. A diferença para uma função comum é profunda. Uma função roda do começo ao fim de uma vez. Uma corrotina pausa em cada yield, devolvendo o controle a quem a chamou, e retoma exatamente de onde parou quando é chamada de novo. Essa capacidade de suspender e continuar, mantendo o estado, é o que permite coordenar muitas tarefas que esperam por coisas diferentes sem travar umas às outras.

Vale ser honesto sobre o escopo desta aula: corrotinas com send à mão são um recurso conceitual mais do que uma ferramenta que você usará todo dia. Elas existem, funcionam, e aparecem em código mais antigo e em situações específicas. O valor de conhecê-las agora é entender o mecanismo de pausar e retomar trocando dados, porque é exatamente esse mecanismo que a programação assíncrona moderna leva adiante, com uma sintaxe muito mais clara.

A ponte para a programação assíncrona

Aqui as peças se juntam. A programação assíncrona resolve um problema concreto: um programa que passa a maior parte do tempo esperando, por respostas de rede, por disco, por outros serviços, poderia usar essa espera para adiantar outras tarefas. Para isso, cada tarefa precisa conseguir pausar quando começa a esperar e devolver o controle, deixando outra tarefa avançar. É precisamente a capacidade de suspender e retomar que você acabou de ver nas corrotinas com yield e send.

No módulo de programação assíncrona, você não vai mais escrever send à mão nem escorvar corrotinas: a sintaxe async def e await cuida disso com muito mais elegância, e um coordenador chamado laço de eventos gerencia quem roda quando. Mas, por baixo, o princípio é o que você viu aqui. Ter enxergado o gerador que pausa, guarda estado e troca dados nos dois sentidos faz o async deixar de parecer mágica e passar a ser a evolução natural de algo que você já entende.