make sure we do not override the rule of 5

README.md

@@ -57,10 +57,11 @@ auto main() -> int
 
 On top of providing strong type utilities, `stronk` also enables unit-like behavior:
 
-```cpp :file=./examples/unit_energy_example.cpp:line_start=0:line_end=23
+```cpp :file=./examples/unit_energy_example.cpp:line_start=0:line_end=24
 #include <ratio>
 
 #include <stronk/prefabs.h>
+#include <stronk/stronk.h>
 #include <stronk/unit.h>
 
 // We introduce a unit type with a default set of skills with the `stronk_default_unit` prefab
@@ -85,7 +86,7 @@ void watts_and_identity_units()
 
 Different units can be combined by multiplying or dividing them:
 
-```cpp :file=./examples/unit_energy_example.cpp:line_start=24:line_end=45
+```cpp :file=./examples/unit_energy_example.cpp:line_start=25:line_end=46
 // Lets introduce hours as a new unit_like type
 struct Hours : twig::stronk<Hours, double, twig::unit>
 {
@@ -111,7 +112,7 @@ void watt_hours_and_generating_new_units()
 
 These new generated types are also units which can be used to generate new units:
 
-```cpp :file=./examples/unit_energy_example.cpp:line_start=46:line_end=65
+```cpp :file=./examples/unit_energy_example.cpp:line_start=47:line_end=66
 // Lets introduce a type for euros, and start combining more types.
 struct Euro : twig::stronk<Euro, double, twig::unit>
 {
@@ -191,8 +192,12 @@ In case you want to specialize the resulting type of unit multiplication and div
 
 By default the units are generated with the `stronk_default_prefab` type.
 
-```cpp :file=./examples/specializers_example.cpp:line_end=29
-#include <stronk/specializers.h>
+```cpp :file=./examples/specializers_example.cpp:line_end=33
+#include <cstdint>
+#include <type_traits>
+
+#include <stronk/stronk.h>
+#include <stronk/unit.h>
 
 // Lets consider the following units:
 struct Distance : twig::stronk<Distance, double, twig::unit>

examples/specializers_example.cpp

@@ -1,4 +1,8 @@
-#include <stronk/specializers.h>
+#include <cstdint>
+#include <type_traits>
+
+#include <stronk/stronk.h>
+#include <stronk/unit.h>
 
 // Lets consider the following units:
 struct Distance : twig::stronk<Distance, double, twig::unit>
@@ -48,4 +52,4 @@ auto main() -> int
     using SpeedDeduced = decltype(Distance {} / Time {});
     static_assert(std::is_same_v<SpeedDeduced, Speed>);
 }
-static_assert(__LINE__ == 51UL, "update readme if this changes");
+static_assert(__LINE__ == 55UL, "update readme if this changes");

examples/unit_energy_example.cpp

@@ -1,6 +1,7 @@
 #include <ratio>
 
 #include <stronk/prefabs.h>
+#include <stronk/stronk.h>
 #include <stronk/unit.h>
 
 // We introduce a unit type with a default set of skills with the `stronk_default_unit` prefab
@@ -70,4 +71,4 @@ auto main() -> int
     watt_hours_and_generating_new_units();
     introducing_another_type();
 }
-static_assert(__LINE__ == 73UL, "update readme if this changes");
+static_assert(__LINE__ == 74UL, "update readme if this changes");

include/stronk/stronk.h

@@ -24,10 +24,18 @@ struct stronk : public Skills<Tag>...
 
     constexpr stronk() noexcept(std::is_nothrow_default_constructible_v<T>) = default;
 
+    template<typename ConvertConstructibleT>
+        requires(std::constructible_from<underlying_type, ConvertConstructibleT>
+                 && !std::same_as<ConvertConstructibleT, self_t>)
+    STRONK_FORCEINLINE constexpr explicit stronk(ConvertConstructibleT&& value)
+        : _you_should_not_be_using_this_but_rather_unwrap(std::forward<ConvertConstructibleT>(value))
+    {
+    }
+
     template<typename... ConvertConstructibleTs>
         requires(std::constructible_from<underlying_type, ConvertConstructibleTs...>
-                 && sizeof...(ConvertConstructibleTs) >= 1)
-    STRONK_FORCEINLINE constexpr explicit stronk(ConvertConstructibleTs&&... values)
+                 && sizeof...(ConvertConstructibleTs) >= 2)
+    STRONK_FORCEINLINE constexpr stronk(ConvertConstructibleTs&&... values)
         : _you_should_not_be_using_this_but_rather_unwrap(std::forward<ConvertConstructibleTs>(values)...)
     {
     }

include/stronk/utilities/equality.h

@@ -7,22 +7,24 @@ namespace twig::stronk_details
 {
 
 template<std::floating_point T>
-inline constexpr auto default_abs_tol = []() -> T {
+inline constexpr auto default_abs_tol = []() -> T
+{
     if constexpr (std::is_same_v<T, float>) {
-        return T(1e-5);
+        return T {1e-5F};
     } else if constexpr (std::is_same_v<T, double>) {
-        return T(1e-8);
+        return T {1e-8};
     } else {
         static_assert(not_implemented_type<T>());
     }
 };
 
 template<std::floating_point T>
-inline constexpr auto default_rel_tol = []() -> T {
+inline constexpr auto default_rel_tol = []() -> T
+{
     if constexpr (std::is_same_v<T, float>) {
-        return T(1e-3);
+        return T {1e-3F};
     } else if constexpr (std::is_same_v<T, double>) {
-        return T(1e-5);
+        return T {1e-5};
     } else {
         static_assert(not_implemented_type<T>());
     }

tests/src/extensions_tests.cpp

@@ -1,9 +1,11 @@
 #include <sstream>
 #include <string>
 
+#include <absl/hash/hash.h>
 #include <fmt/core.h>
 #include <gtest/gtest.h>
 #include <nlohmann/json.hpp>
+#include <nlohmann/json_fwd.hpp>
 #include <stronk/extensions/absl.h>
 #include <stronk/extensions/fmt.h>
 #include <stronk/extensions/gtest.h>

tests/src/specializers_tests.cpp

@@ -1,6 +1,10 @@
+#include <cstdint>
+#include <type_traits>
+
 #include <gtest/gtest.h>
 #include <stronk/can_stream.h>
 #include <stronk/specializers.h>
+#include <stronk/stronk.h>
 #include <stronk/unit.h>
 
 namespace twig::tests

tests/src/unit_tests.cpp

@@ -1,9 +1,12 @@
+#include <cstdint>
 #include <ratio>
+#include <type_traits>
 
 #include <gtest/gtest.h>
 #include <stronk/extensions/gtest.h>
 #include <stronk/prefabs.h>
 #include <stronk/specializers.h>
+#include <stronk/stronk.h>
 #include <stronk/unit.h>
 #include <stronk/utilities/type_list.h>