void OnClick()
{
    thread([url=UrlCtrl.GetText()]{
        PostMessage(DownloadData(url)); //PostMessage - функция из используемой gui библиотеки
    }).detach();
}
void OnData(Data d)
{
    OutputCtrl.SetText(d);
}

void OnClick() async
(
    OutputCtrl.SetText(await([url=UrlCtrl.GetText()]{return DownloadData(url);})); //async и await - обёртки над сопрограммой/созданием потока
)

actor = new Actor();
actor.sendMessage(new CalculateSomething(1, 2, 3));
someHardCalculation();

//внешний API

message1(Data):
  return gen_server.call({message_pattern_1, Data})

message2(Data):
  return gen_server.call({message_pattern_2, Data})

message3(Data):
  return gen_server.call({message_pattern_3, Data})

//реализация gen_server'а
init():
  return gen_server.init(InitialState)

handle_call({message_pattern_1, Data}, CurrentState):
   обрабатываем message 1
   return {{response1, Data}, NewCurrentState}
handle_call(message_pattern_2, CurrentState):
   обрабатываем message 2
   return {response2, NewCurrentState}
handle_call({message_pattern_3, Data}, CurrentState):
   обрабатываем message 3
   return {response2, NewCurrentState}

Handle = some_module.init()

Response1 = some_module.message1(Handle, Data1)
Response2 = some_module.message2(Handle, Data2)
Response3 = some_module.message3(Handle, Data3)

if (state == 1)//В Callback я знаю, что state == 1, поэтому вызываю calc1
    call(request1, response -> {calc1(response)});
else if (state == 2)//В Callback я знаю, что state == 2, поэтому вызываю calc2
    call(request2, response -> {calc2(response)});

if (state == 1) {
    fsmState = WAIT_FOR_RESPONSE1;
    call(request1);
}
else if (state == 2) {
    fsmState = WAIT_FOR_RESPONSE2;
    call(request2);
}

//Обработка
void messageReceived(Response response) {
    if (fsmState == WAIT_FOR_RESPONSE1)
        calc1(response);
    else if (fsmState == WAIT_FOR_RESPONSE2)
        calc2(response);
    else if (fsmState == NO_REQUEST)//здесь сообщение Response пришло без Request
        processEvent(response);
}

if (state == 1) {
    response = await call(request1);
    calc1(response);
}
else if (state == 2) {
    response = await call(request2);
    calc2(response);
}

//Обрабатываем самопроизвольный приход Response (хотя название Response для сообщения в данном случае не самое удачное)
void messageReceived(Response response) {
    processEvent(response);
}

some_function() ->
   async1(),
   asyn2(),
   asyn3(),

   wait_for_response([]).  %% если мы не хотим блокировать
                           %% выполнение, и эту функцию тоже
                           %% можно вынести в отдельный процесс/поток

wait_for_response(ResponseAccum) when length(ResponseAccum) == 3->
  ResponseAccum; %% возвращаем аккумулированные ответы
wait_for_response(ResponseAccum) ->
 %% при получении ответа просто добавляем ответ в список ответов
 %% и продолжаем ждать. tail call optmization
 %% позволяет делать рекурсивный вызов сколько угодно раз

 %% receive выбирает из сообщений, поступающих в процесс,
 %% те, что соответсвуют паттерну. Ожидание не стоит ничего.
 %% Вплоть до того, что процесс могут просто выключить из очереди
 %% на обработку до тех пор, пока к нему не придет сообщение
 receive
   {response1, Data} -> wait_for_response(ResponseAccum ++ Data)
   {response2, Data} -> wait_for_response(ResponseAccum ++ Data)
   {response3, Data} -> wait_for_response(ResponseAccum ++ Data)
 %% можно опционально добавить таймаут, и не один, если надо
 after
    1000 -> log("все ждем ответа");
    10000 -> 
       log("ответа не дождались, аборт"),
       error("Aborting")
 end.

X = f(),
Y = g(),
Z = h(X, Y).

resp = await cast(actor, msg);//происходит возврат управления из функции, актор готов принимать сообщения

//Отсюда выполнение продолжится, когда придет ответ на запрос
process(resp);

M>X = f(),
M>Y = g(),
M>Z = h(X, Y).
M>

resp = await cast(actor, msg);//происходит возврат управления из функции, актор готов принимать сообщения

//Отсюда выполнение продолжится, когда придет ответ на запрос
process(resp);