result.hpp

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <functional>
#include <initializer_list>
#include <stdexcept>
#include <type_traits>
#include <variant>
 
#include "type_traits.hpp"
 
namespace bricks {
 
class bad_result_access : public std::runtime_error {
 public:
  using std::runtime_error::runtime_error;
};
 
namespace detail {
 
template <typename T, typename tag>
class value_container {
 public:
  using value_type = T;
 
  explicit value_container(T value) noexcept(std::is_nothrow_move_constructible_v<T>)
      : value_(std::move(value))
  {
  }
  auto operator=(T value) noexcept(std::is_nothrow_move_assignable_v<T>) -> value_container&
  {
    value_ = std::move(value);
    return *this;
  }
 
  [[nodiscard]] constexpr auto get() noexcept -> T& { return value_; }
  [[nodiscard]] constexpr auto get() const noexcept -> const T& { return value_; }
 
  [[nodiscard]] constexpr auto operator==(const value_container& other) const noexcept -> bool
  {
    return value_ == other.value_;
  }
  [[nodiscard]] constexpr auto operator!=(const value_container& other) const noexcept -> bool
  {
    return !(*this == other);
  }
 
 private:
  T value_;
};
 
struct ok_tag {};
struct err_tag {};
 
}  // namespace detail
 
template <typename T>
using ok = detail::value_container<T, detail::ok_tag>;
 
template <typename E>
using err = detail::value_container<E, detail::err_tag>;
 
template <typename T, typename E>
class result {
  using variant_t = std::variant<ok<T>, err<E>>;
 
 public:
  using value_type = T;
  using error_type = E;
 
  result() = delete;
 
  result(const result&) noexcept(std::is_nothrow_copy_constructible_v<variant_t>) = default;
  auto operator=(const result&) noexcept(std::is_nothrow_copy_assignable_v<variant_t>)
      -> result& = default;
 
  result(result&&) noexcept = default;
  auto operator=(result&&) noexcept -> result& = default;
 
  ~result() = default;
 
  template <typename U, typename std::enable_if_t<
                            std::is_same_v<U, ok<T>> || std::is_same_v<U, err<E>>, bool> = true>
  // cppcheck-suppress noExplicitConstructor
  constexpr result(U in) noexcept(std::is_nothrow_move_constructible_v<U>)  // NOLINT
      : value_(std::move(in))
  {
  }
 
  template <typename U = T, typename std::enable_if_t<!std::is_same_v<U, E>, bool> = true>
  // cppcheck-suppress noExplicitConstructor
  constexpr result(value_type in) noexcept(std::is_nothrow_move_constructible_v<ok<T>>)  // NOLINT
      : value_(ok<T>{std::move(in)})
  {
  }
 
  template <typename U = E, typename std::enable_if_t<!std::is_same_v<T, U>, bool> = true>
  // cppcheck-suppress noExplicitConstructor
  constexpr result(error_type in) noexcept(std::is_nothrow_move_constructible_v<err<E>>)  // NOLINT
      : value_(err<E>{std::move(in)})
  {
  }
 
  template <typename F>
  [[nodiscard]] static auto from_try_or(F&& f, error_type error_value) noexcept(
      std::is_nothrow_constructible_v<err<E>, error_type>) -> result
  {
    static_assert(std::is_invocable_v<F>, "f must be invocable");
    static_assert(std::is_constructible_v<T, std::invoke_result_t<F>>,
                  "value_type must be constructible from the result of f");
 
    try {
      return ok<T>{std::invoke(std::forward<F>(f))};
    } catch (...) {
      return err<E>{error_value};
    }
  }
 
  template <typename F>
  [[nodiscard]] static auto from_try_or_default(F&& f) noexcept(
      std::is_nothrow_invocable_v<decltype(result<T, E>::from_try_or<F>)>&&
          std::is_nothrow_constructible_v<error_type>) -> result
  {
    static_assert(std::is_default_constructible_v<error_type>,
                  "error_type must be default constructible");
 
    return from_try_or(std::forward<F>(f), error_type{});
  }
 
  template <typename F, typename OnError>
  [[nodiscard]] static auto from_try_or_else(F&& f, OnError&& on_error) noexcept(
      std::is_nothrow_invocable_v<OnError>&&
          std::is_nothrow_constructible_v<result<T, E>, std::invoke_result_t<OnError>>) -> result
  {
    static_assert(std::is_invocable_v<F>, "f must be invocable");
    static_assert(std::is_constructible_v<ok<T>, std::invoke_result_t<F>>,
                  "value_type must be constructible from the result of F");
    static_assert(std::is_invocable_v<OnError>, "on_error must be invocable");
 
    try {
      return ok<T>{std::invoke(std::forward<F>(f))};
    } catch (...) {
      return {std::invoke(std::forward<OnError>(on_error))};
    }
  }
 
  template <typename U>
  constexpr auto operator=(U in) noexcept -> result&
  {
    using param_t = std::decay_t<U>;
    if constexpr (std::is_same_v<param_t, ok<T>> || std::is_same_v<param_t, err<E>>) {
      value_ = std::move(in);
    } else if constexpr (std::is_same_v<param_t, T> || std::is_convertible_v<param_t, T>) {
      value_ = ok<T>{std::move(in)};
    } else if constexpr (std::is_same_v<param_t, E> || std::is_convertible_v<param_t, E>) {
      value_ = err<E>{std::move(in)};
    } else if constexpr (std::is_same_v<T, E>) {
      static_assert(always_false_v<U>,
                    "Since the value and error types are the same, use ok<T> or "
                    "err<E> instead of T or E for the assignment.");
    } else {
      static_assert(always_false_v<U>, "Unsupported type for the assignment.");
    }
    return *this;
  }
 
  [[nodiscard]] constexpr auto is_value() const noexcept -> bool
  {
    return std::holds_alternative<ok<T>>(value_);
  }
 
  [[nodiscard]] constexpr auto is_error() const noexcept -> bool
  {
    return std::holds_alternative<err<E>>(value_);
  }
 
  [[nodiscard]] constexpr auto expect(const std::string& msg) const -> value_type
  {
    if (is_error()) {
      throw bad_result_access{msg};
    }
    return std::get<ok<T>>(value_).get();
  }
 
  [[nodiscard]] constexpr auto unwrap() const -> value_type
  {
    return expect("Called `unwrap` on a result that is an error.");
  }
 
  [[nodiscard]] constexpr auto expect_error(const std::string& msg) const -> error_type
  {
    if (is_value()) {
      throw bad_result_access{msg};
    }
    return std::get<err<E>>(value_).get();
  }
 
  [[nodiscard]] constexpr auto unwrap_error() const -> error_type
  {
    return expect_error("Called `unwrap_error` on a result that is a value.");
  }
 
  [[nodiscard]] constexpr auto unwrap_or(value_type default_value) const noexcept -> value_type
  {
    if (is_error()) {
      return default_value;
    }
    return std::get<ok<T>>(value_).get();
  }
 
  [[nodiscard]] constexpr auto unwrap_or_default() const noexcept -> value_type
  {
    static_assert(std::is_default_constructible_v<value_type>,
                  "The value type must be default constructible.");
 
    return unwrap_or(value_type{});
  }
 
  template <typename F>
  [[nodiscard]] constexpr auto unwrap_or_else(F&& f) const -> value_type
  {
    if (is_error()) {
      return f(std::get<err<E>>(value_).get());
    }
    return std::get<ok<T>>(value_).get();
  }
 
  template <typename F>
  [[nodiscard]] constexpr auto map(F&& f) const
      -> result<std::invoke_result_t<F, value_type>, error_type>
  {
    if (is_error()) {
      return {std::get<err<E>>(value_).get()};
    }
    return {ok<std::invoke_result_t<F, value_type>>{f(std::get<ok<T>>(value_).get())}};
  }
 
  template <typename F>
  [[nodiscard]] constexpr auto map_error(F&& f) const
      -> result<value_type, std::invoke_result_t<F, error_type>>
  {
    if (is_value()) {
      return {std::get<ok<T>>(value_).get()};
    }
    return {err<std::invoke_result_t<F, error_type>>{f(std::get<err<E>>(value_).get())}};
  }
 
  template <typename F>
  [[nodiscard]] constexpr auto map_or(std::invoke_result_t<F, value_type> default_value,
                                      F&& f) const -> std::invoke_result_t<F, value_type>
  {
    if (is_error()) {
      return default_value;
    }
    return f(std::get<ok<T>>(value_).get());
  }
 
  template <typename F, typename G>
  [[nodiscard]] constexpr auto map_or_else(G&& default_f, F&& f) const
      -> std::invoke_result_t<F, value_type>
  {
    if (is_error()) {
      return default_f(std::get<err<E>>(value_).get());
    }
    return f(std::get<ok<T>>(value_).get());
  }
 
  template <typename U>
  [[nodiscard]] constexpr auto and_instead(const result<U, error_type>& res) const
      -> result<U, error_type>
  {
    if (is_error()) {
      return {std::get<err<E>>(value_).get()};
    }
    return {res};
  }
 
  template <typename Op>
  [[nodiscard]] constexpr auto and_then(Op&& op) const
      -> result<typename std::invoke_result_t<Op, value_type>::value_type, error_type>
  {
    if (is_error()) {
      return {std::get<err<E>>(value_).get()};
    }
    return {op(std::get<ok<T>>(value_).get())};
  }
 
  template <typename F>
  [[nodiscard]] constexpr auto or_instead(const result<value_type, F>& res) const
      -> result<value_type, F>
  {
    if (is_value()) {
      return {std::get<ok<T>>(value_).get()};
    }
    return {res};
  }
 
  template <typename Op>
  [[nodiscard]] constexpr auto or_else(Op&& op) const
      -> result<value_type, typename std::invoke_result_t<Op, error_type>::error_type>
  {
    if (is_value()) {
      return {std::get<ok<T>>(value_).get()};
    }
    return {op(std::get<err<E>>(value_).get())};
  }
 
  [[nodiscard]] constexpr auto operator==(const result& other) const noexcept -> bool
  {
    return value_ == other.value_;
  }
  [[nodiscard]] constexpr auto operator!=(const result& other) const noexcept -> bool
  {
    return !(*this == other);
  }
 
  friend constexpr auto std::hash<result>::operator()(const result& r) const noexcept
      -> std::size_t;
 
 private:
  variant_t value_;
};
 
template <typename F, typename std::enable_if_t<std::is_invocable_v<F>, bool> = true>
[[nodiscard]] static auto result_from_try(F&& f) noexcept
    -> result<std::invoke_result_t<F>, std::exception_ptr>
{
  try {
    return ok<std::invoke_result_t<F>>{std::invoke(std::forward<F>(f))};
  } catch (...) {
    return err<std::exception_ptr>{std::current_exception()};
  }
}
 
}  // namespace bricks
 
template <typename T, typename E>
struct std::hash<bricks::result<T, E>> {
  [[nodiscard]] constexpr auto operator()(const bricks::result<T, E>& r) const noexcept
      -> std::size_t
  {
    return hash<std::variant<bricks::ok<T>, bricks::err<E>>>{}(r.value_);
  }
};
 
template <typename T, typename tag>
struct std::hash<bricks::detail::value_container<T, tag>> {
  [[nodiscard]] constexpr auto operator()(
      const bricks::detail::value_container<T, tag>& r) const noexcept -> std::size_t
  {
    return hash<T>{}(r.get());
  }
};