David Abrahams wrote: > "Peter Dimov" <[EMAIL PROTECTED]> writes: > >> With the above AsyncCall: >> >> async_call<int> f( bind(g, 1, 2) ); // can offer syntactic sugar here >> thread t(f); // or thread(f); for extra cuteness >> int r = f.result(); >> >> The alternative seems to be >> >> async_call<int> f( bind(g, 1, 2) ); >> int r = f.result(); >> >> but now f is tied to boost::thread. A helper >> >> int r = async(g, 1, 2); > > Another alternative might allow all of the following: > > async_call<int> f(create_thread(), bind(g,1,2)); > int r = f(); > > async_call<int> f(thread_pool(), bind(g,1,2)); > int r = f();
Using an undefined-yet Executor concept for the first argument. This is not much different from async_call<int> f( bind(g, 1, 2) ); // execute f using whatever Executor is appropriate int r = f.result(); except that the async_call doesn't need to know about Executors. > int r = async_call<int>(create_thread(), bind(g, 1, 2)); > > int r = async(boost::thread(), g, 1, 2); > > int r = async_call<int>(rpc(some_machine), bind(g,1,2)); > > int r = async_call<int>(my_message_queue, bind(g,1,2)); All of these are possible with helper functions (and the <int> could be made optional.) I've my doubts about > int r = async_call<int>(rpc(some_machine), bind(g,1,2)); though. How do you envision this working? A local opaque function object can't be RPC'ed. int r = rpc_call("g", 1, 2); looks much easier to implement. _______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost