auto r=async(launch::async, []{return CalcSomething();});
DoAnother();
ProcessResult(r.get());

thread([]{PostMessage(CalcSomething());}).detach();
...
OnDataMessage(Data d){ProcessResult(d.get<type>());}

Andrei Alexandrescu: "The going word at Facebook is that 'reasonably written C++ code just runs fast,' which underscores the enormous effort spent at optimizing PHP and Java code. Paradoxically, C++ code is more difficult to write than in other languages, but efficient code is a lot easier."

EP>private async void handler(object sender, TaskArgs args)
EP>{
EP>    string result = await new Task(() => Download(args.Url), args.Cancellation);
EP>    textBox.Text += result;
EP>}
EP>

EP>void handler(Object &sender, TaskArgs &args)
EP>{
EP>    background(bind(download, args.url), args.cancellation),
EP>    textBox.Text += _1;
EP>}
EP>

EP>

private async void handler(object sender, TaskArgs args)
{
    var client = new HttpClient();
    var response = await client.GetAsync(args.Url, args.Cancellation);
    response.EnsureSuccessStatusCode();
    textBox.Text +=  await response.Content.ReadAsStringAsync();
}

void handler(object& sender, TaskArgs& args)
{
    for(int i=0; i<5; i++){
        BEGIN_ASYNC
        HttpClient client;
        auto response=await_async(client.Get(args.Url+sufix[i], args.Cancellation));
        response.EnsureSuccessStatusCode();
        textBox[i].Text+=await_async(response.Content.ReadAsString());
        END_ASYNC
    }
}

EP>private async void handler(object sender, TaskArgs args)
EP>{
EP>    string result = await new Task(() => Download(args.Url), args.Cancellation);
EP>    textBox.Text += result;
EP>}
EP>

EP>void handler(Object &sender, TaskArgs &args)
EP>{
EP>    background(bind(download, args.url), args.cancellation),
EP>    textBox.Text += _1;
EP>}
EP>

EP>

void foo(... fd - parameters structure ... )
{


    boost::asio::ip::tcp::resolver::query q("222.111.222.111", "1080");
    boost::asio::ip::tcp::resolver::iterator it;
    boost::system::error_code ec = resolve_resume(*fd.io, q, it);


    boost::asio::ip::tcp::socket sock(*fd.io);
    ec = connect_resume(sock, it);

    size_t bytes_transfered;
    boost::asio::streambuf socks_request;

    /// ... build socks_request ...

    ec = write_resume(sock, socks_request, bytes_transfered);

    boost::asio::streambuf socks_response;
    ec = read_resume(sock, socks_response, boost::asio::transfer_at_least(1), bytes_transfered);


    boost::asio::streambuf request;

    /// ... build request ...

    ec = write_resume(sock, request, bytes_transfered);

    boost::asio::streambuf response;
    while (!ec)
    {
        ec = read_resume(sock, response, boost::asio::transfer_at_least(1), bytes_transfered);
    }

    co_exit();
}

struct connect_handler_resume
{
private:
    coroutine_t owner_fiber;
    boost::system::error_code *ec;
public:
    connect_handler_resume(coroutine_t owner_fiber,
                            boost::system::error_code *ec)
                            : owner_fiber(owner_fiber), ec(ec)
    {

    }

    void operator()(const boost::system::error_code& ec);
};


// этот код вызовется по завершении операции
void connect_handler_resume::operator()(const boost::system::error_code& ec)
{
    *this->ec = ec;
    co_call(owner_fiber); // здесь возврат в корутину
}

boost::system::error_code connect_resume(boost::asio::ip::tcp::socket &sock,
                                        boost::asio::ip::tcp::resolver::iterator it)
{
    boost::system::error_code ec;

    connect_handler_resume handler(co_current(), &ec);
    sock.async_connect(*it, handler);

    /**----------*/
    co_resume(); //здесь уходим из корутины и сюда же нас вернёт вызов co_call(owner_fiber);
    /**----------*/

    return ec;
}

private static async Task<int> F1()
{
    return 42;//!!!
}

private static Task<int> F2()
{
    return Task.FromResult(13);
}

private static async Task<string> FF()
{
    Func<Task<int>> f = F1;//!!!
    var x = await f();//!!!
    var y = await F2();//!!!
    return (x + y).ToString();
}

private static void Main()
{
    var r = FF().Result;//вызываем без await

    Console.WriteLine(r);
    Console.WriteLine("Done...");
    Console.ReadKey();
}

private static async Task<int> F1()
{
    Console.WriteLine("F1_1: {0}", Thread.CurrentThread.ManagedThreadId);
    await Task.Yield();
    Console.WriteLine("F1_2: {0}", Thread.CurrentThread.ManagedThreadId);
    return 42;
}

private static Task<int> F2()
{
    Console.WriteLine("F2: {0}", Thread.CurrentThread.ManagedThreadId);
    return Task.FromResult(13);
}

private static async Task<string> FF()
{
    Func<Task<int>> f = F1;//!!!
    var x = await f();
    Console.WriteLine("FF_1: {0}", Thread.CurrentThread.ManagedThreadId);
    var y = await F2();//!!!
    Console.WriteLine("FF_2: {0}", Thread.CurrentThread.ManagedThreadId);

    return (x + y).ToString();
}

private static void Main()
{
    Console.WriteLine("Main: {0}", Thread.CurrentThread.ManagedThreadId);
    var r = FF().Result;//вызываем без await

    Console.WriteLine(r);
    Console.WriteLine("Done...");
    Console.ReadKey();
}

Main: 1
F1_1: 1
F1_2: 3
FF_1: 4
F2: 4
FF_2: 4
55
Done...

I>>>>По моему это есть всяких сортов пляски. Хотя я не уверен, давно пора пляски с памятью и стеком сделать частью языка С++, как это было сделано со смартпоинтерами. Тогда уж точно нельзя будет придраться

do
{
    getline(client_stream, msg);
    cout << msg << endl; 
} while(msg != "exit");

J>хз что из этого ты называешь "аццкими плясками"

Boost.Coroutine is implemented around a stack switching model; that is, every time a coroutine is entered, the following actions are carried:

The caller instruction pointer and callee clobbered registers are saved on the caller stack (this is done automatically as part of the call to the context switching routine respectively by the compiler and by the CPU).
the set of callee save registers are saved by the context switching routine on the caller stack.
The caller stack pointer is saved inside the caller context structure. This structure is stored on the coroutine context if a yield_to or yield is being performed, else it is also on the caller stack.
The callee stack pointer is retrieved from the callee context structure and set as current stack pointer.
Callee save registers are popped from the callee stack.
The context switching routine returns, restoring automatically from the new stack the called coroutine instruction pointer and clobbered registers.

J>>Чем тебя не устроил мой пример с продолжениями?

void cont( const error_code& error, std::size_t bytes_transferred );

boost::asio::async_read(async_stream, boost::asio::buffer(data, size), cont);

EP>>>Пользователи предпочтут рисование по мере вычисления за пол-секунды

EP>>>Ты вроде как толком не ответил, что не так с продолжениями в C++

class A
{
    int x;
}
Func<int> GetFunc()
{
    var closure = new A { x = 0 };
    return () => closure.x++;
}

EP>>>Нет, каждый элемент нужно обрабатывать много раз. Причём такие элементы будут хранится не только в массиве — это общий пример на простой абстракции в виде группировки элементов

EP>>>А я и не говорил что оптимизация это самоцель — действительно, если тебе нужно обрабатывать 90 байтиков в секунду, то можешь хоть visual basic взять

EP>Где я это доказывал?

EP>Там где нужна производительность — у C++ пока практически нет конкурентов, там где не нужна — можно использовать либо C++, либо что-то другое — зависит от конкретной задачи

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR lpCmdLine, int nCmdShow)
{
   ::AttachConsole(); // появляется консолька
   MSG msg;
   while(GetMessage(&msg, NULL, 0, 0) > 0)
   {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   return msg.wParam;
 }

some_window_handler(...) 
{
  getline() // упростил, консолька есть, значит можно читать из неё
 // здесь мы выяснили, будет ожидание, хандлер вызывается прямо из DispatchMessage, стало быть ...
}

EP>>>Не будет зависания — до прихода данных из стрима управление передаться в другое место. Если там UI — то в UI loop

function getSin(param, end)
{
  end(Math.sin(param));
}

getSin(45, function(result){ ля ля ля})

вот этот вызов выглядит как асинхронный, при этом в данном примере нет ничего асинхронного, обычный event driven подоход, а вы с EP почему то называете такой хлам асинхронщиной

#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/coroutine/all.hpp>

#include <functional>
#include <istream>
#include <memory>
#include <cwchar>

using namespace boost;
using namespace std;

#include <windows.h>

typedef function<void(wchar_t)> CharHandler;
CharHandler on_char;
HWND main_hwnd;

template<typename F>
void async_read(F f)
{
    on_char = f;
}

typedef coroutines::coroutine<void()> Coro;
typedef std::shared_ptr<Coro> shared_coro;

struct DataSource
{
    typedef wchar_t char_type;
    typedef iostreams::source_tag category;

    Coro::caller_type &ca;
    const shared_coro *coro;

    std::streamsize read(wchar_t* s, streamsize n) 
    {
        if(n==0) return 0;
        auto &&sc = *coro;
        async_read([s, sc, this](wchar_t ch)
        {
            s[0] = ch;
            coro = &sc;
            (*sc)();
        });
        ca();
        return 1;
    }
};
typedef iostreams::stream<DataSource> InputStream;

void foo(wistream &client_stream)
{
    wstring msg;
    do
    {
        getline(client_stream, msg);
        SendMessage(main_hwnd, WM_SETTEXT, 0, reinterpret_cast<LPARAM>(msg.c_str()));
    } while(msg != L"exit");
}

void task()
{
    auto &&coro = make_shared<Coro>();
    *coro = Coro([&coro](Coro::caller_type &ca)
    {
        DataSource source = {ca, &coro};
        InputStream client_stream(source);
        foo(client_stream);
    });
}

LRESULT CALLBACK window_procedure(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_param)
{
    switch (msg)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
       case WM_SIZE:
            if(w_param == SIZE_MAXIMIZED)
            {
                static auto once = []{ return task(), 1; }();
            } break;
        case WM_CHAR:
            if(on_char)
            {
                wchar_t ch = w_param;
                auto handler = on_char;
                on_char = CharHandler();
                handler(ch == L'\x0D'? L'\n' : ch);
            } break;
    }
    return DefWindowProc(hwnd, msg, w_param, l_param);
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
    WNDCLASS wincl = {};
    wincl.hInstance = hInstance;
    wincl.lpszClassName = TEXT("SFC");
    wincl.lpfnWndProc = window_procedure;
    RegisterClass(&wincl);

    main_hwnd = CreateWindow(wincl.lpszClassName, TEXT(""), WS_OVERLAPPEDWINDOW, 0, 0, 400, 100, 0, 0, hInstance, 0);
    ShowWindow(main_hwnd, nCmdShow);

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