while(GetMessage(&msg, 0, 0, 0))
{
    TranslateMessage(&msg);
    DispatchMessage(&msg);
}

main_tasks.push([]
{
    asynchronous([]
    {
        return async_user_handler(),
               finished = true;
    });
});

Task task;
while(!finished)
{
    main_tasks.pop(task);
    task();
}

_>Ага, как и в C++.

Begin()
Processing()
End()

Post2UI(void*);//реализуется приложением
CallFromUI(void*);

Post2UI(void* coro) {PostMessage(coro);}
...
OnAsync(event_data* coro) {CallFromUI(coro);}//обработчик в классе приложения

queue<void*> coro_queue;//предположим что это lock-free
Post2UI(void* coro) {coro_queue.push(coro);}
...
while(!coro_queue.empty) {CallFromUI(coro_queue.front()); coro_queue.pop();}//строчка где-то в глубине основного цикла вычислений

StartAsyncOp(..., [=]{CallFromUI(__coro);});//последний параметр - callback, который будет вызван из нужного потока

EP>while(GetMessage(&msg, 0, 0, 0))
EP>{
EP>    TranslateMessage(&msg);
EP>    DispatchMessage(&msg);
EP>}
EP>

EP>Task task;
EP>while(!finished)
EP>{
EP>    main_tasks.pop(task);
EP>    task();
EP>}
EP>

    void pop(T &result)
    {
        unique_lock<mutex> u(m);
        c.wait(u, [&]{return !q.empty();} );
        result = move_if_noexcept(q.front());
        q.pop();
    }

EP>>while(GetMessage(&msg, 0, 0, 0))
EP>>{
EP>>    TranslateMessage(&msg);
EP>>    DispatchMessage(&msg);
EP>>}
EP>>

async_something([]
{
    // Will be called on completion.
});

async([] // запустить в thread pool
{
    int result = do_job_in_pool();
    return result;
}).then([](int res)
{
    main_tasks.push([]
    {
        cout << "Job completed, result is: " << res << end;
    });
});

int res = await async([] // запустить в thread pool
{
    int result = do_job_in_pool();
    return result;
});
cout << "Job completed, result is: " << res << end;

A>    void pop(T &result)
A>    {
A>        unique_lock<mutex> u(m);
A>        c.wait(u, [&]{return !q.empty();} );
A>        result = move_if_noexcept(q.front());
A>        q.pop();
A>    }
A>

File.ReadAllLines(file)
    .Select(l => l.Split(',').Select(int.Parse).OrderBy(i => i).Join(","))

G>File.ReadAllLines(file)
G>    .Select(l => l.Split(',').Select(int.Parse).OrderBy(i => i).Join(","))
G>

foreach(var a in File.ReadAllLines("Numbers.txt")
    .Select(l => l.Split(',').Select(int.Parse).Average(v => v))
    .OrderBy(i => i))
    Console.WriteLine(a);

function operation(stream)
{
   var value = read(stream);  
   write(next(value), stream)
}

I>function operation(stream)
I>{
I>   var value = read(stream);  
I>   write(next(value), stream)
I>}
I>

I>Поясни, чем тебе помог этот параметр ? Когда код станет асинхронным, цепочки будут работать как попало

async_code(
    operation(async_stream);
)