Boost logo

Boost :

Subject: Re: [boost] Non-allocating constexpr functional continuations-based future-promise
From: Bjorn Reese (breese_at_[hidden])
Date: 2014-10-25 07:00:41


On 10/23/2014 11:00 PM, Niall Douglas wrote:

> Given Hartmut's feedback from my previous attempt at a non-allocating
> future-promise implementation, I now have a second, much more generic
> demonstration prototype which is based on heterogenous sequences of
> constexpr functional calls. I think this design may have huge potential.

This is a very nice evolution of your previous promise-future framework.

> template<class T> struct then_continuation
> {
> std::vector<std::function<void(T)>> _conts;
> template<class U> auto then(U &&c)
> {
> typedef decltype(c(std::declval<T>())) result_type;
> promise<result_type> p;
> future<result_type> ret(p.get_future());
> // Unfortunately libstdc++'s std::function currently always tries to
> copy lambda types
> //_conts.emplace_back([p=std::move(p), c=std::forward<U>(c)](T
> v){p.set_value(c(v));});
> _conts.push_back([p =
> std::make_shared<promise<result_type>>(std::move(p)),
> c=std::forward<U>(c)](T v){p->set_value(c(v));});
> return ret;
> }
> BOOST_CONSTEXPR T operator()(T v) const
> {
> for(auto &i : _conts)
> i(v);
> return v;
> }
> };
>
> All this continuation does is provide a .then(callable) which stores those
> callables into a std::vector and its operator() executes the previously
> stored callables.

Previously you defined callables as composed functions, but here you
execute them sequentially. That is, then(f1).then(f2) gets executed as
f1(v),f2(v) instead of f2(f1(v)). Or am I missing something?


Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk