Allow CTAD for fine::Ok and fine::Error

Class Template Argument Deduction allows class templates to be inferred
from constructor arguments, which removes the need for `fine::ok` and
`fine::error` as special factory functions.

Author: brodeuralexis

README.md

@@ -470,27 +470,26 @@ When it comes to NIFs, errors often indicate unexpected failures and
 raising an exception makes sense, however you may also want to handle
 certain errors gracefully by returning `:ok`/`:error` tuples, similarly
 to usual Elixir functions. Fine provides `Ok<Args...>` and `Error<Args...>`
-types for this purpose, along with their respective factories `fine::ok` and
-`fine::error`:
+types for this purpose.
 
 ```c++
 fine::Ok<> example() {
-  return fine::ok();
+  return fine::Ok();
 }
 // :ok
 
 fine::Ok<int64_t> example() {
-  return fine::ok(1); // implicit conversion
+  return fine::Ok(1);
 }
 // {:ok, 1}
 
 fine::Error<> example() {
-  return fine::error();
+  return fine::Error();
 }
 // :error
 
 fine::Error<std::string> example() {
-  return fine::error("something went wrong"); // implicit conversion
+  return fine::Error("something went wrong");
 }
 // {:error, "something went wrong"}
 ```
@@ -499,12 +498,12 @@ You can use `std::variant` to express a union of possible result types
 a NIF may return:
 
 ```c++
-std::variant<fine::Ok<int64_t>, fine::Error<std::string>> find_meaning(ErlNifEnv *env) {
-  if (...) {
-    return fine::error("something went wrong");
+std::variant<fine::Ok<int64_t, int64_t>, fine::Error<std::string>> divmod(ErlNifEnv *env, int64_t a, int64_t b) {
+  if (b == 0) {
+    return fine::Error("division by zero");
   }
 
-  return fine::ok(42);
+  return fine::Ok(a / b, a % b);
 }
 ```
 

c_include/fine.hpp

@@ -142,38 +142,27 @@ class Term {
   ERL_NIF_TERM term;
 };
 
-namespace __private__ {
-template <class T> struct UnwrapRefwrapper {
-  using type = T;
-};
-
-template <class T> struct UnwrapRefwrapper<std::reference_wrapper<T>> {
-  using type = T &;
-};
-
-template <class T>
-using UnwrapDecayType =
-    typename UnwrapRefwrapper<typename std::decay<T>::type>::type;
-} // namespace __private__
-
 // Represents a `:ok` tagged tuple, useful as a NIF result.
 template <typename... Args> class Ok {
 public:
   using Items = std::tuple<Args...>;
 
-  Ok(Items &&items) : m_items(std::forward<Items>(items)) {}
+  template <typename = std::enable_if_t<std::is_default_constructible_v<Items>>>
+  Ok() : m_items() {}
+
+  explicit Ok(Args... items) : m_items{std::move(items)...} {}
 
   template <typename... UArgs>
-  Ok(const Ok<UArgs...> &other) : m_items{other.items()} {}
+  Ok(const Ok<UArgs...> &other) : m_items(other.items()) {}
 
   template <typename... UArgs>
-  Ok(Ok<UArgs...> &&other) : m_items{other.items()} {}
+  Ok(Ok<UArgs...> &&other) : m_items(std::move(other).items()) {}
 
   const Items &items() const & noexcept { return m_items; }
 
   Items &items() & noexcept { return m_items; }
 
-  Items &&items() && noexcept { return m_items; }
+  Items &&items() && noexcept { return std::move(m_items); }
 
 private:
   std::tuple<Args...> m_items;
@@ -184,37 +173,27 @@ template <typename... Args> class Error {
 public:
   using Items = std::tuple<Args...>;
 
-  Error(Items &&items) : m_items(std::forward<Items>(items)) {}
+  template <typename = std::enable_if_t<std::is_default_constructible_v<Items>>>
+  Error() : m_items() {}
+
+  explicit Error(Args... items) : m_items{std::move(items)...} {}
 
   template <typename... UArgs>
-  Error(const Error<UArgs...> &other) : m_items{other.items()} {}
+  Error(const Error<UArgs...> &other) : m_items(other.items()) {}
 
   template <typename... UArgs>
-  Error(Error<UArgs...> &&other) : m_items{other.items()} {}
+  Error(Error<UArgs...> &&other) : m_items(std::move(other).items()) {}
 
   const Items &items() const & noexcept { return m_items; }
 
   Items &items() & noexcept { return m_items; }
 
-  Items &&items() && noexcept { return m_items; }
+  Items &&items() && noexcept { return std::move(m_items); }
 
 private:
   std::tuple<Args...> m_items;
 };
 
-template <typename... Args>
-inline static Ok<__private__::UnwrapDecayType<Args>...> ok(Args &&...args) {
-  return Ok<__private__::UnwrapDecayType<Args>...>{
-      std::make_tuple(std::forward<Args>(args)...)};
-}
-
-template <typename... Args>
-inline static Error<__private__::UnwrapDecayType<Args>...>
-error(Args &&...args) {
-  return Error<__private__::UnwrapDecayType<Args>...>{
-      std::make_tuple(std::forward<Args>(args)...)};
-}
-
 namespace __private__ {
 template <typename T> struct ResourceWrapper {
   T resource;

test/c_src/finest.cpp

@@ -144,32 +144,32 @@ FINE_NIF(codec_tuple_int64_and_string, 0);
 
 Result<std::string, int64_t> codec_result_string_int64_ok(ErlNifEnv *,
                                                           std::string term) {
-  return fine::ok(term);
+  return fine::Ok(term);
 }
 FINE_NIF(codec_result_string_int64_ok, 0);
 
 Result<std::string, int64_t> codec_result_string_int64_error(ErlNifEnv *,
                                                              int64_t term) {
-  return fine::error(term);
+  return fine::Error(term);
 }
 FINE_NIF(codec_result_string_int64_error, 0);
 
 Result<std::string, int64_t>
 codec_result_string_int64_ok_conversion(ErlNifEnv *) {
-  return fine::ok("fine");
+  return fine::Ok("fine");
 }
 FINE_NIF(codec_result_string_int64_ok_conversion, 0);
 
 Result<std::string, int64_t>
 codec_result_string_int64_error_conversion(ErlNifEnv *) {
   uint16_t result = 42;
-  return fine::error(result);
+  return fine::Error(result);
 }
 FINE_NIF(codec_result_string_int64_error_conversion, 0);
 
 std::variant<fine::Ok<int64_t, std::string>, fine::Error<>>
 codec_result_int64_string_void_ok_conversion(ErlNifEnv *) {
-  return fine::ok(static_cast<int32_t>(201702), "c++17");
+  return fine::Ok(static_cast<int32_t>(201702), "c++17");
 }
 FINE_NIF(codec_result_int64_string_void_ok_conversion, 0);
 
@@ -197,19 +197,19 @@ FINE_NIF(codec_struct, 0);
 ExError codec_struct_exception(ErlNifEnv *, ExError term) { return term; }
 FINE_NIF(codec_struct_exception, 0);
 
-fine::Ok<> codec_ok_empty(ErlNifEnv *) { return fine::ok(); }
+fine::Ok<> codec_ok_empty(ErlNifEnv *) { return fine::Ok(); }
 FINE_NIF(codec_ok_empty, 0);
 
 fine::Ok<int64_t> codec_ok_int64(ErlNifEnv *, int64_t term) {
-  return fine::ok(term);
+  return fine::Ok(term);
 }
 FINE_NIF(codec_ok_int64, 0);
 
-fine::Error<> codec_error_empty(ErlNifEnv *) { return fine::error(); }
+fine::Error<> codec_error_empty(ErlNifEnv *) { return fine::Error(); }
 FINE_NIF(codec_error_empty, 0);
 
 fine::Error<std::string> codec_error_string(ErlNifEnv *, std::string term) {
-  return fine::error(term);
+  return fine::Error(term);
 }
 FINE_NIF(codec_error_string, 0);