Deferred/Promise pattern in C++

Question

I've recently discovered, and fallen in love with, the Deferred/Promise pattern used in jQuery. It just encapsulates so many async use cases, including the wonderful chaining, filtering ability, that I can't believe I missed it for so long.

I've just finished refactoring my AS3 code to use the excellent CodeCatalyst/promise-as3 library (https://github.com/CodeCatalyst/promise-as3), and so started thinking about going back to my C++ code and seeing how I could implement the pattern there.

Before I started coding this myself, I checked to see if it had been done before, and discovered the std::future/std::promise (and boost equivalents), but they are very heavy (they seem use real threads etc, and have a heavy template syntax).

So, my question is: Is there are lightweight, pure C++ implementation of the Deferred/Promise pattern, jQuery-style?

refs:

• pattern: http://en.wikipedia.org/wiki/Futures_and_promises
• jQuery: http://api.jquery.com/category/deferred-object/
• AS3: https://github.com/CodeCatalyst/promise-as3
• Dart: http://api.dartlang.org/dart_core/Futures.html
• C++: http://www.stdthread.co.uk/doc/headers/future/future.html

Answer 1

Sorry to play necromancer, but I too was very interested using A+ style promises in C++ and spent years working out the best way to implement it. I did eventually succeed, and you can see my implementation here.

Usage is pretty straight forward, but does make heavy use of templating and template metaprogramming. Here's an example:

Promise<int> promise;

promise.future().then([](int i){
    std::cout << "i = " << i << std::endl;
    return "foobar";
}).then([](const std::string& str){
    std::cout << "str = " << str << std::endl;
});

promise.resolve(10);

This would print out:

i = 10
str = foobar

Answer 2

I am not sure how lightweight a solution you are after, but std::async simplifies the setting up of future/promise pairs a great deal and allows the caller to decide whether a the work is carried out asynchronously by another thread, or with delayed execution in the same thread. In any case, the caller doesn't have to do any explicit thread management.