Add comparison operations for fine::Term (#10)

Author: brodeuralexis

c_include/fine.hpp

@@ -142,6 +142,36 @@ class Term {
   ERL_NIF_TERM term;
 };
 
+inline static bool operator==(const fine::Term &lhs,
+                              const fine::Term &rhs) noexcept {
+  return enif_compare(lhs, rhs) == 0;
+}
+
+inline static bool operator!=(const fine::Term &lhs,
+                              const fine::Term &rhs) noexcept {
+  return enif_compare(lhs, rhs) != 0;
+}
+
+inline static bool operator<(const fine::Term &lhs,
+                             const fine::Term &rhs) noexcept {
+  return enif_compare(lhs, rhs) < 0;
+}
+
+inline static bool operator<=(const fine::Term &lhs,
+                              const fine::Term &rhs) noexcept {
+  return enif_compare(lhs, rhs) <= 0;
+}
+
+inline static bool operator>(const fine::Term &lhs,
+                             const fine::Term &rhs) noexcept {
+  return enif_compare(lhs, rhs) > 0;
+}
+
+inline static bool operator>=(const fine::Term &lhs,
+                              const fine::Term &rhs) noexcept {
+  return enif_compare(lhs, rhs) >= 0;
+}
+
 // Represents a `:ok` tagged tuple, useful as a NIF result.
 template <typename... Args> class Ok {
 public:

test/c_src/finest.cpp

@@ -325,6 +325,35 @@ std::nullopt_t shared_mutex_shared_lock_test(ErlNifEnv *) {
 }
 FINE_NIF(shared_mutex_shared_lock_test, 0);
 
+bool compare_eq(ErlNifEnv *, fine::Term lhs, fine::Term rhs) noexcept {
+  return lhs == rhs;
+}
+FINE_NIF(compare_eq, 0);
+
+bool compare_ne(ErlNifEnv *, fine::Term lhs, fine::Term rhs) noexcept {
+  return lhs != rhs;
+}
+FINE_NIF(compare_ne, 0);
+
+bool compare_lt(ErlNifEnv *, fine::Term lhs, fine::Term rhs) noexcept {
+  return lhs < rhs;
+}
+FINE_NIF(compare_lt, 0);
+
+bool compare_le(ErlNifEnv *, fine::Term lhs, fine::Term rhs) noexcept {
+  return lhs <= rhs;
+}
+FINE_NIF(compare_le, 0);
+
+bool compare_gt(ErlNifEnv *, fine::Term lhs, fine::Term rhs) noexcept {
+  return lhs > rhs;
+}
+FINE_NIF(compare_gt, 0);
+
+bool compare_ge(ErlNifEnv *, fine::Term lhs, fine::Term rhs) noexcept {
+  return lhs >= rhs;
+}
+FINE_NIF(compare_ge, 0);
 } // namespace finest
 
 FINE_INIT("Elixir.Finest.NIF");

test/lib/finest/nif.ex

@@ -59,5 +59,12 @@ defmodule Finest.NIF do
   def shared_mutex_unique_lock_test(), do: err!()
   def shared_mutex_shared_lock_test(), do: err!()
 
+  def compare_eq(_lhs, _rhs), do: err!()
+  def compare_ne(_lhs, _rhs), do: err!()
+  def compare_lt(_lhs, _rhs), do: err!()
+  def compare_le(_lhs, _rhs), do: err!()
+  def compare_gt(_lhs, _rhs), do: err!()
+  def compare_ge(_lhs, _rhs), do: err!()
+
   defp err!(), do: :erlang.nif_error(:not_loaded)
 end

test/test/finest_test.exs

@@ -313,4 +313,42 @@ defmodule FinestTest do
       NIF.shared_mutex_shared_lock_test()
     end
   end
+
+  describe "comparison" do
+    test "equal" do
+      refute NIF.compare_eq(64, 42)
+      refute NIF.compare_eq(nil, %{})
+      assert NIF.compare_eq("fine", "fine")
+    end
+
+    test "not equal" do
+      assert NIF.compare_ne(64, 42)
+      assert NIF.compare_ne(nil, %{})
+      refute NIF.compare_ne("fine", "fine")
+    end
+
+    test "less than" do
+      refute NIF.compare_lt(64, 42)
+      assert NIF.compare_lt(nil, %{})
+      refute NIF.compare_lt("fine", "fine")
+    end
+
+    test "less than equal" do
+      refute NIF.compare_le(64, 42)
+      assert NIF.compare_le(nil, %{})
+      assert NIF.compare_le("fine", "fine")
+    end
+
+    test "greater than" do
+      assert NIF.compare_gt(64, 42)
+      refute NIF.compare_gt(nil, %{})
+      refute NIF.compare_gt("fine", "fine")
+    end
+
+    test "greater than equal" do
+      assert NIF.compare_ge(64, 42)
+      refute NIF.compare_ge(nil, %{})
+      assert NIF.compare_ge("fine", "fine")
+    end
+  end
 end