template<typename F>
std::unique_future<typename std::result_of<F()>::type> spawn_task(F f)
{
    typedef typename std::result_of<F()>::type result_type;
    std::packaged_task<result_type()> task(std::move(f));
    std::unique_future<result_type> res(task.get_future());
    std::thread(std::move(task));
    return res;
}

This builds a std::packaged_task for the function, obtains a std::unique_future for the result, moves that task onto a thread (which is automatically detached), and returns the future.

This can easily be extended to handle additional arguments.

template<typename F>
std::unique_future<typename std::result_of<F()>::type> spawn_task(F f)
{
    typedef typename std::result_of<F()>::type result_type;

    struct local_task
    {
        std::promise<result_type> promise;
        F func;

        local_task(local_task const& other)=delete;

        local_task(F func_):
            func(func_)
        {}

        local_task(local_task&& other):
            promise(std::move(other.promise)),
            f(std::move(other.f))
        {}

        void operator()
        {
            try
            {
                promise.set_value(f());
            }
            catch(...)
            {
                promise.set_exception(std::current_exception());
            }
        }
    };
    
    local_task task(std::move(f));

    std::unique_future<result_type> res(task.promise.get_future());
    std::thread(std::move(task));
    return res;
}

local_task performs the same function as std::packaged_task, but in a much more limited manner. It is easy to imagine users getting it wrong by forgetting to catch the exception, or creating the promise as a local variable and using a lambda as the thread function (and thus getting a dangling reference to the promise).

std::packaged_task is intended to be usable as a basic building block of a thread pool. Whereas with spawn_task as presented above the task is immediately associated with a thread, in a thread pool the task could be put on a queue to be executed by a worker thread at a later point. The worker threads would then only need to know they were executing tasks from the queue, without having to worry about what the functions were, or the details of storing the results.

Advanced thread pool implementations would potentially require access to the internals of std::packaged_task and/or std::unique_future, and would therefore have to be provided as part of the same implementation, or require extensions to the interfaces. Such extensions are left for a later proposal, as thread pools are not being standardized for C++0x.

Though std::packaged_task is ideally suited to multi-threaded usage, it can also be used in a single-threaded scenario too. In this case, it is important not to wait() for the future result, since there isn't a background thread to prepare the result, but it does allow an unspecified task to be invoked only when necessary.

std::packaged_task<int(int,int)> task(create_task());
std::unique_future<int> future;

while(!done())
{
    int a,b;
    if(future_value_needed())
    {
        if(!future.is_ready())
            task(a,b);

        do_something(future.get());
    }
}

If the task needs to be invoked multiple times, but should only be invoked when necessary, then reset() can be called after the task has been invoked in order to reset the state for a subsequent invocation. It is important to note that in this case, a fresh std::unique_future must be obtained (by calling get_future()) after the call to reset(): any futures already obtained will continue to refer to the result of the prior invocation.

template<class> class packaged_task; // undefined

template<class R,class... ArgTypes>
class packaged_task<R(ArgTypes...)>
{
public:
    typedef R result_type;

    // construction and destruction
    packaged_task();

    template <class F>
    explicit packaged_task(F const& f);

    explicit packaged_task(R(*f)());
    
    template <class F>
    explicit packaged_task(F&& f);

    template <class F, class Allocator>
    explicit packaged_task(allocator_arg_t,Allocator const& a, F f);
    template <class F, class Allocator>
    explicit packaged_task(allocator_arg_t,Allocator const& a, F&& f);

    ~packaged_task();

    // no copy
    packaged_task(packaged_task&) = delete;
    packaged_task& operator=(packaged_task&) = delete;

    // move support
    packaged_task(packaged_task&& other);
    packaged_task& operator=(packaged_task&& other);

    void swap(packaged_task&& other);

    explicit operator bool() const;

    // result retrieval
    unique_future<R> get_future();        

    // execution
    void operator()(ArgTypes... );

    void reset();
};

template<typename F>
packaged_task(F const &f);

packaged_task(R(*f)());

template<typename F>
packaged_task(F&&f);

packaged_task(packaged_task && other);

packaged_task& operator=(packaged_task && other);

~packaged_task();

explicit operator bool() const

unique_future<R> get_future();

void operator()(ArgTypes... args);

void reset();