outcome(TResult const& s) : m_s(s), m_success(true) {}

outcome(TResult&& s) : m_s(std::move(s)), m_success(true) {}

outcome(TFailure const& f) : m_f(f), m_success(false) {}

outcome(TFailure&& f) : m_f(std::move(f)), m_success(false) {}

outcome(outcome const& other) : m_success(other.m_success)

{

if (m_success) {

new (&m_s) TResult(other.m_s);

}

else {

new (&m_f) TFailure(other.m_f);

}

}

outcome(outcome&& other) noexcept : m_success(other.m_success)

{

if (m_success) {

new (&m_s) TResult(std::move(other.m_s));

}

else {

new (&m_f) TFailure(std::move(other.m_f));

}

}

~outcome() { destroy(); }

outcome& operator=(outcome&& other) noexcept

{

assert(this != &other);

destroy();

if (other.m_success) {

new (&m_s) TResult(std::move(other.m_s));

}

else {

new (&m_f) TFailure(std::move(other.m_f));

}

m_success = other.m_success;

return *this;

}

TResult const& get_result() const&

{

assert(m_success);

return m_s;

}

TResult&& get_result() &&

{

assert(m_success);

return std::move(m_s);

}

TFailure const& get_failure() const&

{

assert(!m_success);

return m_f;

}

TFailure&& get_failure() &&

{

assert(!m_success);

return std::move(m_f);

}

bool is_success() const { return m_success; }

void destroy()

{

if (m_success) {

m_s.~TResult();

}

else {

m_f.~TFailure();

}

}

union {

TResult m_s;

TFailure m_f;

};

bool m_success;