Re: [boost] Non-allocating constexpr functional continuations-based future-promise

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?