Re: [boost] [review] Outcome Review Report

6 Jun 2017

      ...
Since conclusion of the review period, discussion continues (on and
off-list) regarding possible evolution to the Outcome library, related to
feedback provided during this review, and related to discussions of design
evolution for pertinent libraries (e.g., possible changes to
std::expected<>, and evolution of a never-empty ‘variant2<>’).  It is
promising that such a strong library as Outcome continues to receive
critical attention and evolution by multiple interested parties.
...
class result
{
  T _value;
  EC _error;  // 24 bytes
Thank you so much Charley for review managing one of the lengthiest and
most complex reviews we have had here at Boost in some year.

I like to take a month's break from all programming after a review has
ended, as it happens I have lots of non-programming stuff backlogged
anyway, so it's good timing. But for those not following the continuing
discussions, the rough plan moving forward is this:

1. Expected implementation to be no longer implemented by Outcome, maybe
by Peter Dimov's Variant2 library at some future point instead.

2. Outcome to drop the variant based storage. Outcome gets simplified
into this synopsis (design still evolving, this is a snapshot of current
thinking):

```
template<
  class T,
  class EC = error_code_extended
public:
  // Constructors to be inspired by std::variant's

  // Narrow observers
  T &access_value() noexcept;
  EC &access_error() noexcept;

  // Wide observers
  T &value();
  EC &error();
};

template<
  class T,
  class P = shared_ptr<void>,
  class EC = error_code_extended,
  class E = exception_ptr
...
class outcome
  : private result
{
  using base = result;
  union
  {
    P _payload;    // 16 bytes
    E _exception;  //  8 bytes
  };
public:
  // Constructors to be inspired by std::variant's

  // Explicit construction from compatible result<_T, _EC>
  template explicit outcome(result<_T, _EC>);

  // Narrow observers
  using base::access_value;
  using base::access_error;
  P &access_payload() noexcept;
  E &access_exception() noexcept;

  // Wide observers
  using base::value;
  using base::error;
  P payload();
  E exception();
  // Returns exception state, but if errored, synthesises
  // an exception_ptr of the error code
  E failure();
};

static_assert(sizeof(outcome<void>) == 40);  // bytes overhead
```

I've left out some detail, but the above gives the idea.
...
Great thanks to the Boost Community for their tremendous efforts,
disciplined review, and detailed exploration of topics in considering this
library submission.
Sincerest appreciation to Niall Douglas (Author of the Outcome Library) for
pushing the envelope for low-latency  handling and for
submitting his work to the Boost Review process.
Thank you to the Boost community so much for helping me with the design
of this library. It helps a great deal to return to the drawing board
armed with so much high quality feedback.

Niall

-- 
ned Productions Limited Consulting
http://www.nedproductions.biz/ http://ie.linkedin.com/in/nialldouglas/