future<T>.always([]{});

[aaronalbers]

I think it would be nice to have a way to easily request that a continuation in a chain be done every time regardless of error state. I am accomplishing this now with f.recover([](auto f){}); but I think f.always([]{}); is more expressive.

[FelixPetriconi]

I would consider at this point, that your tasks do not throw.
We are currently thinking about changing the recover() interface. Perhaps this eases the usage a bit.

[aaronalbers]

My tasks certainly do throw but there are instances where regardless of if a task succeeds or not I want some code to execute. This could be useful in many cases but the main one I use it for is state tracking via a construct like RAII. Like when a task finishes do this even if you failed.

I am curious however what the new interface will ultimately turn out to be. I have been following your progress on error and exception.

[dabrahams]

Two questions:

1. Should .always really be spelled .finally?
2. Is the closure ever something that is unknown at the point the task is created, or should it just be folded into the task body?

[sean-parent]

I'm not certain I want to promote the idea of depending on side-effects with future continuations. But I believe (except for the member function syntax) this is easily expressible as:

// arguments are future, executor, task.
template <class T, class E, class F>
auto always(future<T>&& x, E&& e, F&& f) {
    return future<T> move(x).recover(std::forward<E>(e), [_f = std::forward<F>(f)](auto&& f) {
        std::move(_f)();
        return std::forward<F>(f); // is this forward redundant?
    });
}