Merge branch 'main' into difference_equality

Author: rollbear

ChangeLog

@@ -1,3 +1,7 @@
+        * strong::affine_point<D> can now be defaulted as
+          strong::affine_point<>, in which case a difference type will be
+          generated using the same tag as the strong affine point type.
+
         * operator% is now conditionally supported for arithmetic types,
           provided that the underlying type supports the operation.
 

README.md

@@ -114,6 +114,10 @@ can thus be used as key in `std::map`<> or `std::set<>`.
   one dimentional affine points are pointer (with `D` being `ptrdiff_t`,) or
   `std::time_point<>` (with `std::duration<>` as `D`.) An example of a
   multidimensional affine point is a coordinate (with a vector type for `D`.)
+  `D` can be defaulted, using `strong::affine_point<>`, in which case the
+  difference type shares the same tag.
+  The difference type from a `strong::affine_point<D>` can be obtained using
+  `type::difference`, regardless of whether `D` is explicit or defaulted.
   It is natural that `D` is of a `strong::difference` type. This is a good name
   from a mathematical point of view, but perhaps a bit too academic, and not
   well aligned with the other names.
@@ -134,7 +138,7 @@ can thus be used as key in `std::map`<> or `std::set<>`.
 
 * `strong::iterator` adds functionality needed depending on iterator category.
   If the iterator type is a `random_access_iterator`, the strong type
-  is `strong::indexed<>` and `strong::affine_point<difference_type>`. It should be
+  is `strong::indexed<>` and `strong::affine_point<difference>`. It should be
   possible to specify the index type and affine_point type.
 
 * `strong::range` adds the functionality needed to iterate over the elements.

include/strong_type/strong_type.hpp

@@ -782,7 +782,7 @@ class difference::modifier<::strong::type<T, Tag, M...>>
   }
 };
 
-template <typename D>
+template <typename D = void>
 struct affine_point
 {
   template <typename T>
@@ -809,26 +809,27 @@ class affine_point<D>::modifier<::strong::type<T, Tag, M...>>
 {
   using type = ::strong::type<T, Tag, M...>;
   static_assert(impl::subtractable<T>::value, "it must be possible to subtract instances of your underlying type");
-  using diff_type = decltype(std::declval<const T&>() - std::declval<const T&>());
-  static_assert(std::is_constructible<D, diff_type>::value,"");
+  using base_diff_type = decltype(std::declval<const T&>() - std::declval<const T&>());
 public:
+  using difference = std::conditional_t<std::is_same<D, void>{}, strong::type<base_diff_type, Tag, strong::difference>, D>;
+  static_assert(std::is_constructible<difference, base_diff_type>::value, "");
   STRONG_NODISCARD
   friend
   STRONG_CONSTEXPR
-  D
+  difference
   operator-(
     const type& lh,
     const type& rh)
   {
-    return D(value_of(lh) - value_of(rh));
+    return difference(value_of(lh) - value_of(rh));
   }
 
   friend
   STRONG_CONSTEXPR
   type&
   operator+=(
     type& lh,
-    const D& d)
+    const difference& d)
   noexcept(noexcept(value_of(lh) += impl::access(d)))
   {
     value_of(lh) += impl::access(d);
@@ -840,7 +841,7 @@ class affine_point<D>::modifier<::strong::type<T, Tag, M...>>
   type&
   operator-=(
     type& lh,
-    const D& d)
+    const difference& d)
   noexcept(noexcept(value_of(lh) -= impl::access(d)))
   {
     value_of(lh) -= impl::access(d);
@@ -853,7 +854,7 @@ class affine_point<D>::modifier<::strong::type<T, Tag, M...>>
   type
   operator+(
     type lh,
-    const D& d)
+    const difference& d)
   {
     return lh += d;
   }
@@ -863,7 +864,7 @@ class affine_point<D>::modifier<::strong::type<T, Tag, M...>>
   STRONG_CONSTEXPR
   type
   operator+(
-    const D& d,
+    const difference& d,
     type rh)
   {
     return rh+= d;
@@ -875,12 +876,13 @@ class affine_point<D>::modifier<::strong::type<T, Tag, M...>>
   type
   operator-(
     type lh,
-    const D& d)
+    const difference& d)
   {
     return lh -= d;
   }
 };
 
+
 struct pointer
 {
   template <typename T>

test.cpp

@@ -319,6 +319,9 @@ static_assert(is_addable<dhandle,handle>{},"");
 static_assert(is_addable<handle,dhandle>{},"");
 static_assert(!is_range<dhandle>{}, "");
 
+using ddhandle = strong::type<int, struct int_tag, strong::affine_point<>>;
+static_assert(std::is_same<ddhandle::difference, strong::type<int, struct int_tag, strong::difference>>{}, "");
+
 using ri = strong::type<int*, struct ipt, strong::iterator>;
 
 static_assert(!std::is_default_constructible<ri>{},"");
@@ -987,6 +990,17 @@ TEST_CASE("affine_point types can be subtracted")
   REQUIRE(value_of(d) == 5);
 }
 
+TEST_CASE("affine point type with defaulted difference type yields it when subtracting")
+{
+    using T = strong::type<int, struct i_, strong::affine_point<>>;
+
+    T t1{3};
+    T t2{8};
+    auto d = t2 - t1;
+    static_assert(std::is_same<decltype(d), strong::type<int, struct i_, strong::difference>>{},"");
+    REQUIRE(value_of(d) == 5);
+}
+
 TEST_CASE("affine_point types can be added with the delta type")
 {
   using D = strong::type<int, struct i_>;