Add nearly comparison support for Unit type.

Comparing the Unit type will always return true.

nearly/src/nearly_eq.rs

@@ -474,3 +474,29 @@ impl_nearly_tuple!(
     Lhs Lhs Lhs Lhs Lhs Lhs Lhs Lhs Lhs Lhs Lhs Lhs,
     Rhs Rhs Rhs Rhs Rhs Rhs Rhs Rhs Rhs Rhs Rhs Rhs,
     11 10 9 8 7 6 5 4 3 2 1 0);
+
+//////////
+// unit //
+//////////
+
+impl EpsTolerance for () {
+    type T = ();
+    const DEFAULT: () = ();
+}
+
+impl UlpsTolerance for () {
+    type T = ();
+    const DEFAULT: () = ();
+}
+
+impl NearlyEqEps for () {
+    fn nearly_eq_eps(&self, _other: &Self, _eps: EpsToleranceType<Self>) -> bool {
+        true
+    }
+}
+
+impl NearlyEqUlps for () {
+    fn nearly_eq_ulps(&self, _other: &Self, _ulps: UlpsToleranceType<Self>) -> bool {
+        true
+    }
+}

nearly/tests/unit_test.rs

@@ -0,0 +1,24 @@
+use nearly::Tolerance;
+use nearly::{NearlyEq, NearlyEqEps, NearlyEqTol, NearlyEqUlps};
+
+#[test]
+fn nearly_eq_unit() {
+    let a = ();
+    let b = ();
+
+    assert!(a.nearly_eq_eps(&b, ()));
+    assert!(a.nearly_eq_ulps(&b, ()));
+    assert!(a.nearly_eq_tol(&b, Tolerance::<()>::new((), ())));
+    assert!(a.nearly_eq(&b));
+}
+
+#[test]
+fn nearly_ne_unit() {
+    let a = ();
+    let b = ();
+
+    assert!(!a.nearly_ne_eps(&b, ()));
+    assert!(!a.nearly_ne_ulps(&b, ()));
+    assert!(!a.nearly_ne_tol(&b, Tolerance::<()>::new((), ())));
+    assert!(!a.nearly_ne(&b));
+}