Você pode usar a expressão sync para executar duas ou mais expressões assíncronas ao mesmo tempo. Por exemplo:
# Todas as três funções assíncronas iniciam ao mesmo tempo
Results = sync:
AsyncFunction1() # tarefa 1
AsyncFunction2() # tarefa 2
AsyncFunction3() # tarefa 3
# Chamada após todas as três tarefas serem concluídas (não importa a ordem)
MyLog.Print("Concluído com a lista de resultados: {Results}")
O código a seguir mostra a sintaxe para a expressão sync com um diagrama que mostra o fluxo de execução das expressões.
~~~(verse) expression0 sync: slow-expression mid-expression fast-expression expression1
{:width="600"}
## Uso da expressão `sync`
| --- | --- |
| **Onde você pode usar uma expressão `sync`** | [Contextos assíncronos](verse-glossary#async-context) |
| **Tempo de invocação da expressão `sync`** | Assíncrono |
| **Requisitos do bloco de código `sync`** | O corpo da expressão `sync` deve ter pelo menos duas expressões assíncronas; caso contrário, não é necessário executar as expressões simultaneamente. |
| **O que faz a expressão `sync`** | Executa simultaneamente todas as expressões em seu [bloco de código](verse-glossary#code-block) e espera que todas terminem antes de executar a próxima expressão após `sync`. |
| **Quando a expressão `sync` é concluída** | Quando todas as expressões no bloco de código `sync` são concluídas. |
| **Quando a próxima expressão após `sync` começa** | Quando todas as expressões no bloco de código `sync` são concluídas. |
| **Resultado da expressão `sync`** | Seu [resultado](verse-glossary#result) é uma [tupla](verse-glossary#tuple) de resultados de cada expressão na ordem em que as expressões de nível superior foram especificadas. Os [tipos](verse-glossary#type) resultantes das expressões podem ser de qualquer tipo, e cada elemento da tupla terá o tipo da sua expressão correspondente. |
Pelo menos duas [expressões de nível superior](verse-glossary#top-level-expression) devem ser assíncronas.
~~~(verse)
sync:
AsyncFunction1()
MyLog.Print("Segunda expressão de alto nível”)
AsyncFunction2()
MyLog.Print("Terceira expressão de alto nível")
sync:
AsyncFunction1()
# Erro: Pelo menos duas expressões nível superior esperadas
~~~
Expressões de nível superior podem ser expressões compostas, como [blocos de código](verse-glossary#code-block) [aninhados](verse-glossary#nested):
~~~(verse)
# a sincronização também pode ter expressões compostas
# com cada expressão de nível superior em sua própria tarefa
sync:
block: # tarefa 1
# Avaliado em ordem de série
AsyncFunction1a()
AsyncFunction1b()
block: # tarefa 2
AsyncFunction2a()
AsyncFunction2b()
AsyncFunction2c()
AsyncFunction3() # tarefa 3
# AsyncFunction1a(), AsyncFunction2a() e AsyncFunction3() são iniciadas essencialmente ao mesmo tempo
~~~
Como as tuplas podem ser usadas como [argumentos](verse-glossary#argument) de [auto-splatting](verse-glossary#splat), expressões `sync` podem ser usadas diretamente como argumentos, pois têm um resultado de tupla. Isso permite que argumentos assíncronos sejam avaliados simultaneamente, e a função para a qual eles estão sendo transmitidos é chamada quando todas as expressões no bloco de código de sincronização são concluídas.
~~~(verse)
# Todos os três argumentos de corrotina começam suas avaliações ao mesmo tempo
DoStuff(sync{AsyncFunctionArg1(); AsyncFunctionArg2(); AsyncFunctionArg3()})
# Nem todo argumento precisa ser assíncrono, no mínimo dois justificam o uso de `sync`
DoOtherStuff(sync{AsyncFunctionArg1(); 42; AsyncFunctionArg2(); AsyncFunctionArg3()})