Le 25/05/2017 à 02:13, Hartmut Kaiser via Boost a écrit :
There is still this case where you want to avoid exceptions in one part of the program, but still use exceptions in other parts of the program. For one example. in one "task" you launch another task with a callback function `f`. You might want to throw from `f` and this is valid. But the framework for launching tasks cannot afford to spill exceptions, so they have to catch and somehow transport the exception (e.g., by exception_ptr) then in the other task, you might want to re-convert to an exception. (something similar to what std::future does.) I understand what you're saying, std::future needs a (conceptual) variant
to store its state. So if I hear you correctly, outcome::expected could be used for that.
I believe that yes, the underlying type of a future is an
expected
Also, maybe you will find of use the following example that tries to illustrate the basic use case of the library: <snipped code example>
Thanks, I think I've seen this in the docs. All of this could have been done with a variant
without changing the semantics, yes?
With the code it will be easier to answer :) Sorry, I was unable to find it.
If we had some PossibleValued, MonadError interfaces, variant
So I guess the next question I would like to ask is: what is the benefit of using outcome::result<T> over std::optional<T>, and outcome::expected
over std::variant ?
Can I try to answer what are the benefits of using std::optional<T>
instead of variant