result.hpp

Go to the documentation of this file.

// clang-format off
// clang-format on
// result.hpp - Rust-like Result<T, E> for C++17
// SPDX-License-Identifier: MIT
//
// This header provides a modern, ergonomic Result type for C++17 inspired by
// Rust. It supports combinators, helpers, and void specialization.
//
// All API is in the cpp_result namespace.
//
// --- API OVERVIEW ---
//
// Construction:
//   Result<T, E>::Ok(T)
//   Result<T, E>::Err(E)
//   Result<void, E>::Ok()
//   Result<void, E>::Err(E)
//   cpp_result::Ok<T, E>(T)
//   cpp_result::Err<T, E>(E)
//   cpp_result::Ok<E>()
//   cpp_result::Err<E>(E)
//
// Query:
//   is_ok(), is_err()
//
// Unwrap:
//   unwrap(), unwrap_err(), unwrap_or(value), unwrap_or_else(fn)
//   expect(msg), expect_err(msg)
//
// Combinators:
//   map(fn), map_err(fn), and_then(fn)
//   inspect(fn), inspect_err(fn)
//
// See the documentation below each function for usage examples.
 
#pragma once
 
#ifndef CPP_RESULT_HAS_STATEMENT_EXPR
#if defined(__GNUC__) || defined(__clang__)
#define CPP_RESULT_HAS_STATEMENT_EXPR 1
#else
#define CPP_RESULT_HAS_STATEMENT_EXPR 0
#endif
#endif
 
#ifndef CPP_RESULT_FEATURE_ALL
#define CPP_RESULT_FEATURE_ALL 1
#endif
#ifndef CPP_RESULT_FEATURE_UNWRAP
#define CPP_RESULT_FEATURE_UNWRAP CPP_RESULT_FEATURE_ALL
#endif
#ifndef CPP_RESULT_FEATURE_MAP
#define CPP_RESULT_FEATURE_MAP CPP_RESULT_FEATURE_ALL
#endif
#ifndef CPP_RESULT_FEATURE_ANDOR
#define CPP_RESULT_FEATURE_ANDOR CPP_RESULT_FEATURE_ALL
#endif
#ifndef CPP_RESULT_FEATURE_INSPECT
#define CPP_RESULT_FEATURE_INSPECT CPP_RESULT_FEATURE_ALL
#endif
#ifndef CPP_RESULT_FEATURE_CONTAINS
#define CPP_RESULT_FEATURE_CONTAINS CPP_RESULT_FEATURE_ALL
#endif
#ifndef CPP_RESULT_FEATURE_FLATTEN
#define CPP_RESULT_FEATURE_FLATTEN CPP_RESULT_FEATURE_ALL
#endif
#ifndef CPP_RESULT_FEATURE_OPTIONAL
#define CPP_RESULT_FEATURE_OPTIONAL CPP_RESULT_FEATURE_ALL
#endif

#if CPP_RESULT_HAS_STATEMENT_EXPR
#define TRY(expr)                                                              \
  ({                                                                           \
    auto &&__res = (expr);                                                     \
    using __res_type = std::decay_t<decltype(__res)>;                          \
    if (__res.is_err())                                                        \
      return __res_type::Err(__res.unwrap_err());                              \
    std::move(__res.unwrap());                                                 \
  })
#else
#define TRY(expr)                                                              \
  ([&]() -> decltype(auto) {                                                   \
    auto &&__res = (expr);                                                     \
    using __res_type = std::decay_t<decltype(__res)>;                          \
    if (__res.is_err())                                                        \
      return __res_type::Err(__res.unwrap_err());                              \
    return std::move(__res.unwrap());                                          \
  }())
#endif
 
// clang-format off
// clang-format on
#define TRYL(name, expr)                                                       \
  auto &&__res_##name = (expr);                                                \
  using __res_type_##name = std::decay_t<decltype(__res_##name)>;              \
  if (__res_##name.is_err())                                                   \
    return __res_type_##name::Err(__res_##name.unwrap_err());                  \
  auto &name = __res_##name.unwrap()
 
#include <cstdio>
#include <cstdlib>
#if CPP_RESULT_FEATURE_OPTIONAL
#include <optional>
#endif // CPP_RESULT_FEATURE_OPTIONAL
#include <type_traits>
#include <utility>
 
#define EXPECT_OR_ABORT(cond, msg)                                             \
  do {                                                                         \
    if (!(cond)) {                                                             \
      std::fputs(msg, stderr);                                                 \
      std::fputc('\n', stderr);                                                \
      std::abort();                                                            \
    }                                                                          \
  } while (0)
 
namespace cpp_result {

template <typename T, typename E> class [[nodiscard]] Result {
  static_assert(!std::is_reference_v<T> && !std::is_reference_v<E>,
                "Result<T,E> does not support reference types");
 
public:
  static inline Result Ok(T val) noexcept { return Result(std::move(val)); }

  static inline Result Err(E err) noexcept { return Result(std::move(err)); }

  constexpr bool is_ok() const noexcept { return is_ok_; }

  constexpr bool is_err() const noexcept { return !is_ok_; }
 
#if CPP_RESULT_FEATURE_UNWRAP
  inline T &unwrap() noexcept {
    EXPECT_OR_ABORT(is_ok_, "unwrap called on Result::Err()");
    return data_.value;
  }
  inline const T &unwrap() const noexcept {
    EXPECT_OR_ABORT(is_ok_, "unwrap called on Result::Err()");
    return data_.value;
  }

  inline E &unwrap_err() noexcept {
    EXPECT_OR_ABORT(!is_ok_, "unwrap_err called on Result::Ok()");
    return data_.error;
  }
  inline const E &unwrap_err() const noexcept {
    EXPECT_OR_ABORT(!is_ok_, "unwrap_err called on Result::Ok()");
    return data_.error;
  }

  inline T unwrap_or(T default_value) const noexcept {
    return is_ok_ ? data_.value : default_value;
  }

  template <typename F>
  inline T unwrap_or_else(F &&func) const noexcept(noexcept(func())) {
    return is_ok_ ? data_.value : std::forward<F>(func)();
  }

  T unwrap_or_default() const
      noexcept(std::is_nothrow_default_constructible_v<T>) {
    if (is_ok_)
      return data_.value;
    return T{};
  }

  T &expect(const char *msg) noexcept {
    EXPECT_OR_ABORT(is_ok_, msg);
    return data_.value;
  }
  const T &expect(const char *msg) const noexcept {
    EXPECT_OR_ABORT(is_ok_, msg);
    return data_.value;
  }

  E &expect_err(const char *msg) noexcept {
    EXPECT_OR_ABORT(!is_ok_, msg);
    return data_.error;
  }
  const E &expect_err(const char *msg) const noexcept {
    EXPECT_OR_ABORT(!is_ok_, msg);
    return data_.error;
  }

  template <typename Pred>
  bool is_ok_and(Pred &&pred) const
      noexcept(noexcept(pred(std::declval<T>()))) {
    return is_ok_ && pred(data_.value);
  }

  template <typename Pred>
  bool is_err_and(Pred &&pred) const
      noexcept(noexcept(pred(std::declval<E>()))) {
    return !is_ok_ && pred(data_.error);
  }
#endif // CPP_RESULT_FEATURE_UNWRAP
 
#if CPP_RESULT_FEATURE_MAP
  template <typename F, typename U = std::invoke_result_t<F, T>>
  Result<U, E> map(F &&func) const noexcept(noexcept(func(std::declval<T>()))) {
    if (is_ok_)
      return Result<U, E>::Ok(func(data_.value));
    return Result<U, E>::Err(data_.error);
  }

  template <typename F, typename E2 = std::invoke_result_t<F, E>>
  Result<T, E2> map_err(F &&func) const
      noexcept(noexcept(func(std::declval<E>()))) {
    if (is_ok_)
      return Result<T, E2>::Ok(data_.value);
    return Result<T, E2>::Err(func(data_.error));
  }

  template <typename U, typename F> U map_or(U default_value, F &&func) const {
    return is_ok_ ? func(data_.value) : default_value;
  }

  template <typename D, typename F>
  auto map_or_else(D &&default_fn, F &&func) const {
    return is_ok_ ? func(data_.value) : default_fn();
  }
#endif // CPP_RESULT_FEATURE_MAP
 
#if CPP_RESULT_FEATURE_ANDOR
  template <typename F, typename R = typename std::invoke_result_t<F, T>>
  R and_then(F &&func) const noexcept(noexcept(func(std::declval<T>()))) {
    if (is_ok_)
      return func(data_.value);
    return R::Err(data_.error);
  }

  template <typename R2> auto and_(R2 &&res) const {
    if (is_ok_)
      return std::forward<R2>(res);
    return Result<T, E>::Err(data_.error);
  }

  template <typename R2> auto or_(R2 &&res) const {
    if (!is_ok_)
      return std::forward<R2>(res);
    return *this;
  }

  template <typename F> auto or_else(F &&op) const {
    if (!is_ok_)
      return op();
    return *this;
  }
#endif // CPP_RESULT_FEATURE_ANDOR
 
#if CPP_RESULT_FEATURE_INSPECT
  template <typename F>
  const Result &inspect(F &&func) const
      noexcept(noexcept(func(std::declval<const T &>()))) {
    if (is_ok_)
      func(data_.value);
    return *this;
  }

  template <typename F>
  const Result &inspect_err(F &&func) const
      noexcept(noexcept(func(std::declval<const E &>()))) {
    if (!is_ok_)
      func(data_.error);
    return *this;
  }
#endif // CPP_RESULT_FEATURE_INSPECT
 
#if CPP_RESULT_FEATURE_CONTAINS
  bool contains(const T &value) const { return is_ok_ && data_.value == value; }

  bool contains_err(const E &error) const {
    return !is_ok_ && data_.error == error;
  }
#endif // CPP_RESULT_FEATURE_CONTAINS
 
#if CPP_RESULT_FEATURE_FLATTEN
  auto flatten() const {
    using Inner = decltype(data_.value);
    if (is_ok_)
      return data_.value;
    return Inner::Err(data_.error);
  }
#endif // CPP_RESULT_FEATURE_FLATTEN
 
#if CPP_RESULT_FEATURE_OPTIONAL
  std::optional<T> ok() const {
    return is_ok_ ? std::optional<T>(data_.value) : std::nullopt;
  }

  std::optional<E> err() const {
    return !is_ok_ ? std::optional<E>(data_.error) : std::nullopt;
  }
#endif
 
  ~Result() { destroy(); }
 
  // Move semantics
  Result(Result &&other) noexcept(std::is_nothrow_move_constructible_v<T> &&
                                  std::is_nothrow_move_constructible_v<E>)
      : is_ok_(other.is_ok_) {
    if (is_ok_)
      new (&data_.value) T(std::move(other.data_.value));
    else
      new (&data_.error) E(std::move(other.data_.error));
  }
 
  Result &
  operator=(Result &&other) noexcept(std::is_nothrow_move_assignable_v<T> &&
                                     std::is_nothrow_move_assignable_v<E>) {
    if (this != &other) {
      destroy();
      is_ok_ = other.is_ok_;
      if (is_ok_)
        new (&data_.value) T(std::move(other.data_.value));
      else
        new (&data_.error) E(std::move(other.data_.error));
    }
    return *this;
  }
 
  // Conditional copy semantics
  Result(const Result &other) noexcept(
      std::is_nothrow_copy_constructible_v<T> &&
      std::is_nothrow_copy_constructible_v<E>)
      : is_ok_(other.is_ok_) {
    if (is_ok_)
      new (&data_.value) T(other.data_.value);
    else
      new (&data_.error) E(other.data_.error);
  }
 
  Result &operator=(const Result &other) noexcept(
      std::is_nothrow_copy_assignable_v<T> &&
      std::is_nothrow_copy_assignable_v<E>) {
    if (this != &other) {
      destroy();
      is_ok_ = other.is_ok_;
      if (is_ok_)
        new (&data_.value) T(other.data_.value);
      else
        new (&data_.error) E(other.data_.error);
    }
    return *this;
  }
 
private:
  union Data {
    T value;
    E error;
    Data() {}
    ~Data() {}
  } data_;
  bool is_ok_;
 
  explicit Result(T val) noexcept : is_ok_(true) {
    new (&data_.value) T(std::move(val));
  }
 
  explicit Result(E err) noexcept : is_ok_(false) {
    new (&data_.error) E(std::move(err));
  }
 
  void destroy() noexcept { is_ok_ ? data_.value.~T() : data_.error.~E(); }
};

template <typename E> class [[nodiscard]] Result<void, E> {
  static_assert(!std::is_reference_v<E>,
                "Result<void,E> does not support reference types");
 
public:
  static inline Result Ok() noexcept { return Result(); }

  static inline Result Err(E err) noexcept { return Result(std::move(err)); }

  inline bool is_ok() const noexcept { return is_ok_; }

  inline bool is_err() const noexcept { return !is_ok_; }

  inline void unwrap() noexcept {
    EXPECT_OR_ABORT(is_ok_, "unwrap called on Result::Err()");
  }

  inline E &unwrap_err() noexcept {
    EXPECT_OR_ABORT(!is_ok_, "unwrap_err called on Result::Ok()");
    return error_;
  }
  inline const E &unwrap_err() const noexcept {
    EXPECT_OR_ABORT(!is_ok_, "unwrap_err called on Result::Ok()");
    return error_;
  }

  template <typename F, typename U = std::invoke_result_t<F>>
  Result<U, E> map(F &&func) const noexcept(noexcept(func())) {
    if (is_ok_)
      return Result<U, E>::Ok(func());
    return Result<U, E>::Err(error_);
  }

  template <typename F, typename E2 = std::invoke_result_t<F, E>>
  Result<void, E2> map_err(F &&func) const
      noexcept(noexcept(func(std::declval<E>()))) {
    if (is_ok_)
      return Result<void, E2>::Ok();
    return Result<void, E2>::Err(func(error_));
  }

  template <typename F, typename R = std::invoke_result_t<F>>
  R and_then(F &&func) const noexcept(noexcept(func())) {
    if (is_ok_)
      return func();
    return R::Err(error_);
  }

  void expect(const char msg[]) const noexcept { EXPECT_OR_ABORT(is_ok_, msg); }

  E &expect_err(const char msg[]) noexcept {
    EXPECT_OR_ABORT(!is_ok_, msg);
    return error_;
  }
 
  const E &expect_err(const char msg[]) const noexcept {
    EXPECT_OR_ABORT(!is_ok_, msg);
    return error_;
  }

  template <typename F>
  const Result &inspect(F &&func) const noexcept(noexcept(func())) {
    if (is_ok_)
      func();
    return *this;
  }

  template <typename F>
  const Result &inspect_err(F &&func) const
      noexcept(noexcept(func(std::declval<const E &>()))) {
    if (!is_ok_)
      func(error_);
    return *this;
  }

  template <typename Pred>
  bool is_err_and(Pred &&pred) const
      noexcept(noexcept(pred(std::declval<E>()))) {
    return !is_ok_ && pred(error_);
  }

  std::optional<E> err() const {
    if (!is_ok_)
      return error_;
    return std::nullopt;
  }

  template <typename R2> auto and_(R2 &&res) const {
    if (is_ok_)
      return std::forward<R2>(res);
    return Result<void, E>::Err(error_);
  }

  template <typename R2> auto or_(R2 &&res) const {
    if (!is_ok_)
      return std::forward<R2>(res);
    return *this;
  }

  template <typename U, typename F> U map_or(U default_value, F &&func) const {
    return is_ok_ ? func() : default_value;
  }

  template <typename D, typename F>
  auto map_or_else(D &&default_fn, F &&func) const {
    return is_ok_ ? func() : default_fn();
  }

  bool contains_err(const E &error) const { return !is_ok_ && error_ == error; }
 
  // Move semantics
  Result(Result &&other) noexcept(std::is_nothrow_move_constructible_v<E>)
      : is_ok_(other.is_ok_) {
    if (!is_ok_)
      new (&error_) E(std::move(other.error_));
  }
 
  Result &
  operator=(Result &&other) noexcept(std::is_nothrow_move_assignable_v<E>) {
    if (this != &other) {
      is_ok_ = other.is_ok_;
      if (!is_ok_)
        new (&error_) E(std::move(other.error_));
    }
    return *this;
  }
 
  // Conditional copy semantics
  Result(const Result &other) noexcept(std::is_nothrow_copy_constructible_v<E>)
      : is_ok_(other.is_ok_) {
    if (!is_ok_)
      new (&error_) E(other.error_);
  }
 
  Result &operator=(const Result &other) noexcept(
      std::is_nothrow_copy_assignable_v<E>) {
    if (this != &other) {
      is_ok_ = other.is_ok_;
      if (!is_ok_)
        new (&error_) E(other.error_);
    }
    return *this;
  }
 
private:
  E error_;
  bool is_ok_;
 
  Result() noexcept : is_ok_(true) {}
  explicit Result(E err) noexcept : is_ok_(false) {
    new (&error_) E(std::move(err));
  }
};
 
template <typename T, typename E> inline Result<T, E> Ok(T val) {
  return Result<T, E>::Ok(std::move(val));
}
template <typename T, typename E> inline Result<T, E> Err(E err) {
  return Result<T, E>::Err(std::move(err));
}
template <typename E> inline Result<void, E> Ok() {
  return Result<void, E>::Ok();
}
template <typename E> inline Result<void, E> Err(E err) {
  return Result<void, E>::Err(std::move(err));
}
 
} // namespace cpp_result