Como funciona a construção async/await na linguagem…

No Kotlin, para programação assíncrona, usam-se corutinas, e não async/await no sentido habitual, como em C# ou JavaScript. No entanto, a biblioteca kotlinx.coroutines fornece as funções async e await, que implementam um padrão semelhante baseado em corutinas.

Como funciona:

async: É uma função construtora (função de extensão de CoroutineScope) que inicia uma nova corutina em paralelo e retorna um valor diferido do tipo Deferred<T>. Deferred<T> é uma espécie de resultado "futuro" dos cálculos, que ainda não está pronto. A execução do código após chamar async continua imediatamente, sem esperar a conclusão da operação assíncrona.
```
// Exemplo de uso de async
val deferredResult = CoroutineScope(Dispatchers.IO).async {
    // Operação assíncrona (por exemplo, uma requisição de rede ou leitura de arquivo)
    delay(1000) // Simulação de trabalho prolongado
    "Resultado da operação assíncrona"
}
```
await: É uma função suspensa, chamada no objeto Deferred<T>. Ela suspende a execução da corutina atual até que a operação assíncrona iniciada com async termine e o resultado esteja pronto. await retorna o valor pronto de tipo T.
```
// Exemplo de uso de await
// Dentro de uma função suspensa ou corutina
val result = deferredResult.await() // Suspende a execução até obter o resultado
println(result)
```

Pontos-chave:

Corutinas: No núcleo do async/await em Kotlin estão as corutinas. async cria uma nova corutina, e await suspende a corutina atual sem bloquear a thread.
Deferred<T>: É análogo ao Promise em JavaScript ou Task<T> em C#. Ele representa um resultado que estará disponível no futuro. Deferred herda de Job, o que permite gerenciar o ciclo de vida da operação assíncrona (cancelar, verificar status).
Não bloqueante: await não bloqueia a thread na qual a corutina é executada. Em vez disso, ela suspende a corutina, liberando a thread para outras tarefas. Quando o resultado da operação assíncrona estiver pronto, a corutina é retomada.
Scope: Como async, assim como launch (outra construtora de corutinas), são funções de extensão de CoroutineScope. Isso significa que eles devem ser iniciados dentro de uma determinada área de escopo (Scope). O Scope gerencia o ciclo de vida das corutinas nele contidas.
Tratamento de exceções: Exceções que ocorrem dentro de uma corutina iniciada via async são armazenadas no objeto Deferred e serão lançadas ao chamar await.

Comparação com launch:

Aspecto	`launch`	`async`
Tipo de retorno	`Job`	`Deferred<T>` (herda de `Job`)
Objetivo	"Lançar e esquecer" (efeitos colaterais)	Obter resultado
Espera terminar	Não (a menos que use `join()`)	Sim (ao usar `await()`)
Exemplo de uso	Atualização de UI	Realizar requisição de rede e processar resposta

async e await em Kotlin permitem escrever código assíncrono de forma sequencial, tornando-o mais legível e compreensível, ao mesmo tempo que aproveitam as vantagens de operações não bloqueantes.

Como funciona a construção async/await na linguagem de programação Kotlin?