Implicit Conversion for fine::Ok and fine::Error

README.md

@@ -473,29 +473,37 @@ to usual Elixir functions. Fine provides `Ok<Args...>` and `Error<Args...>`
 types for this purpose.
 
 ```c++
-fine::Ok<>()
+fine::Ok<> example() {
+  return fine::Ok();
+}
 // :ok
 
-fine::Ok<int64_t>(1)
+fine::Ok<int64_t> example() {
+  return fine::Ok(1);
+}
 // {:ok, 1}
 
-fine::Error<>()
+fine::Error<> example() {
+  return fine::Error();
+}
 // :error
 
-fine::Error<std::string>("something went wrong")
+fine::Error<std::string> example() {
+  return fine::Error("something went wrong");
+}
 // {:error, "something went wrong"}
 ```
 
 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<std::string>("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<int64_t>(42);
+  return fine::Ok(a / b, a % b);
 }
 ```
 

c_include/fine.hpp

@@ -145,23 +145,53 @@ class Term {
 // Represents a `:ok` tagged tuple, useful as a NIF result.
 template <typename... Args> class Ok {
 public:
-  Ok(const Args &...items) : items(items...) {}
+  using Items = std::tuple<Args...>;
 
-private:
-  friend struct Encoder<Ok<Args...>>;
+  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()) {}
+
+  template <typename... UArgs>
+  Ok(Ok<UArgs...> &&other) : m_items(std::move(other).items()) {}
 
-  std::tuple<Args...> items;
+  const Items &items() const & noexcept { return m_items; }
+
+  Items &items() & noexcept { return m_items; }
+
+  Items &&items() && noexcept { return std::move(m_items); }
+
+private:
+  std::tuple<Args...> m_items;
 };
 
 // Represents a `:error` tagged tuple, useful as a NIF result.
 template <typename... Args> class Error {
 public:
-  Error(const Args &...items) : items(items...) {}
+  using Items = std::tuple<Args...>;
 
-private:
-  friend struct Encoder<Error<Args...>>;
+  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()) {}
+
+  template <typename... UArgs>
+  Error(Error<UArgs...> &&other) : m_items(std::move(other).items()) {}
 
-  std::tuple<Args...> items;
+  const Items &items() const & noexcept { return m_items; }
+
+  Items &items() & noexcept { return m_items; }
+
+  Items &&items() && noexcept { return std::move(m_items); }
+
+private:
+  std::tuple<Args...> m_items;
 };
 
 namespace __private__ {
@@ -895,7 +925,7 @@ template <typename... Args> struct Encoder<Ok<Args...>> {
     auto tag = __private__::atoms::ok;
 
     if constexpr (sizeof...(Args) > 0) {
-      return fine::encode(env, std::tuple_cat(std::tuple(tag), ok.items));
+      return fine::encode(env, std::tuple_cat(std::tuple(tag), ok.items()));
     } else {
       return fine::encode(env, tag);
     }
@@ -907,7 +937,7 @@ template <typename... Args> struct Encoder<Error<Args...>> {
     auto tag = __private__::atoms::error;
 
     if constexpr (sizeof...(Args) > 0) {
-      return fine::encode(env, std::tuple_cat(std::tuple(tag), error.items));
+      return fine::encode(env, std::tuple_cat(std::tuple(tag), error.items()));
     } else {
       return fine::encode(env, tag);
     }

test/c_src/finest.cpp

@@ -76,6 +76,9 @@ struct ExError {
   static constexpr auto is_exception = true;
 };
 
+template <typename T, typename E>
+using Result = std::variant<fine::Ok<T>, fine::Error<E>>;
+
 int64_t add(ErlNifEnv *, int64_t x, int64_t y) { return x + y; }
 FINE_NIF(add, 0);
 
@@ -139,6 +142,37 @@ codec_tuple_int64_and_string(ErlNifEnv *,
 }
 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);
+}
+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);
+}
+FINE_NIF(codec_result_string_int64_error, 0);
+
+Result<std::string, int64_t>
+codec_result_string_int64_ok_conversion(ErlNifEnv *) {
+  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);
+}
+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");
+}
+FINE_NIF(codec_result_int64_string_void_ok_conversion, 0);
+
 std::vector<int64_t> codec_vector_int64(ErlNifEnv *,
                                         std::vector<int64_t> term) {
   return term;

test/lib/finest/nif.ex

@@ -28,6 +28,11 @@ defmodule Finest.NIF do
   def codec_optional_int64(_term), do: err!()
   def codec_variant_int64_or_string(_term), do: err!()
   def codec_tuple_int64_and_string(_term), do: err!()
+  def codec_result_string_int64_ok(_term), do: err!()
+  def codec_result_string_int64_error(_term), do: err!()
+  def codec_result_string_int64_ok_conversion(), do: err!()
+  def codec_result_string_int64_error_conversion(), do: err!()
+  def codec_result_int64_string_void_ok_conversion(), do: err!()
   def codec_vector_int64(_term), do: err!()
   def codec_map_atom_int64(_term), do: err!()
   def codec_resource(_term), do: err!()

test/test/finest_test.exs

@@ -217,6 +217,14 @@ defmodule FinestTest do
       assert NIF.codec_error_empty() == :error
       assert NIF.codec_error_string("this is the reason") == {:error, "this is the reason"}
     end
+
+    test "result" do
+      assert NIF.codec_result_string_int64_ok("fine") == {:ok, "fine"}
+      assert NIF.codec_result_string_int64_error(42) == {:error, 42}
+      assert NIF.codec_result_string_int64_ok_conversion() == {:ok, "fine"}
+      assert NIF.codec_result_string_int64_error_conversion() == {:error, 42}
+      assert NIF.codec_result_int64_string_void_ok_conversion() == {:ok, 201_702, "c++17"}
+    end
   end
 
   describe "resource" do