Fix all warnings in enumeration details code/tests

5 files changed, 140 insertions, 151 deletions

diff --git a/lib/enumDetails.h b/lib/enumDetails.h
index dfae082..49906d4 100644
--- a/lib/enumDetails.h
+++ b/lib/enumDetails.h
@@ -9,11 +9,11 @@
 /// EnumDetailsBase
 // Shared helpers
 struct EnumDetailsBase {
-	template<size_t len>
+	template<size_t Len>
 	constexpr static auto
 	strArr(auto input, auto start, auto end)
 	{
-		std::array<char, len> out;
+		std::array<char, Len> out;
 		input.copy(out.begin(), end - start, start);
 		return out;
 	}
@@ -33,22 +33,22 @@ protected:
 		return std::string_view {__PRETTY_FUNCTION__};
 	};
 
-	constexpr static auto typeNameStart {typeraw().find(SEARCH_TYPE) + SEARCH_TYPE.length()};
-	constexpr static auto typeNameEnd {typeraw().find_first_of("];", typeNameStart)};
-	constexpr static auto typeNameLen {typeNameEnd - typeNameStart};
-	constexpr static auto typeNameArr {strArr<typeNameLen>(typeraw(), typeNameStart, typeNameEnd)};
+	constexpr static auto TYPE_NAME_START {typeraw().find(SEARCH_TYPE) + SEARCH_TYPE.length()};
+	constexpr static auto TYPE_NAME_END {typeraw().find_first_of("];", TYPE_NAME_START)};
+	constexpr static auto TYPE_NAME_LEN {TYPE_NAME_END - TYPE_NAME_START};
+	constexpr static auto TYPE_NAME_ARR {strArr<TYPE_NAME_LEN>(typeraw(), TYPE_NAME_START, TYPE_NAME_END)};
 
 public:
-	constexpr static std::string_view typeName {typeNameArr.data(), typeNameArr.size()};
+	constexpr static std::string_view TYPE_NAME {TYPE_NAME_ARR.data(), TYPE_NAME_ARR.size()};
 };
 
 /// EnumValueDetails
 // Extracts the value name and constructs string_views of the parts
-template<auto value> struct EnumValueDetails : public EnumTypeDetails<decltype(value)> {
+template<auto Value> struct EnumValueDetails : public EnumTypeDetails<decltype(Value)> {
 #ifndef ENUM_PROBE
 private:
 #endif
-	using T = EnumTypeDetails<decltype(value)>;
+	using T = EnumTypeDetails<decltype(Value)>;
 
 	constexpr static auto
 	raw()
@@ -56,26 +56,23 @@ private:
 		return std::string_view {__PRETTY_FUNCTION__};
 	};
 
-	constexpr static auto nameStart {raw().find_last_of(": ") + 1};
-	constexpr static auto nameEnd {raw().find_first_of("];", nameStart)};
-	constexpr static auto nameLen {nameEnd - nameStart};
-	constexpr static auto nameArr {EnumValueDetails::template strArr<nameLen>(raw(), nameStart, nameEnd)};
+	constexpr static auto NAME_START {raw().find_last_of(": ") + 1};
+	constexpr static auto NAME_END {raw().find_first_of("];", NAME_START)};
+	constexpr static auto NAME_LEN {NAME_END - NAME_START};
+	constexpr static auto NAME_ARR {EnumValueDetails::template strArr<NAME_LEN>(raw(), NAME_START, NAME_END)};
 
 public:
-	constexpr static std::string_view valueName {nameArr.data(), nameArr.size()};
-	constexpr static auto valid {valueName.back() < '0' || valueName.back() > '9'};
-#pragma GCC diagnostic push
-#ifdef __clang__
-#	pragma GCC diagnostic ignored "-Wenum-constexpr-conversion"
-#endif
-	constexpr static auto raw_value {value};
-#pragma GCC diagnostic pop
+	constexpr static std::string_view VALUE_NAME {NAME_ARR.data(), NAME_ARR.size()};
+	constexpr static auto VALID {VALUE_NAME.back() < '0' || VALUE_NAME.back() > '9'};
+	constexpr static auto RAW_VALUE {Value};
 };
 
 /// EnumValueCollection
 // Customisation point for specifying the range of underlying values your enum can have
 template<typename E> struct EnumValueCollection {
-	using Vs = std::make_integer_sequence<int, 256>;
+	using Underlying = std::underlying_type_t<E>;
+	static constexpr Underlying UPPER = std::numeric_limits<Underlying>::max();
+	using Vs = std::make_integer_sequence<Underlying, UPPER>;
 };
 
 /// EnumDetails
@@ -84,45 +81,36 @@ template<typename E> struct EnumDetails {
 #ifndef ENUM_PROBE
 private:
 #endif
-	template<auto... n>
+	using Underlying = std::underlying_type_t<E>;
+
+	template<auto... N>
 	constexpr static auto
-	get_valids(std::integer_sequence<int, n...>)
+	getValids(std::integer_sequence<Underlying, N...>)
 	{
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wconversion"
-#ifdef __clang__
-#	pragma GCC diagnostic ignored "-Wenum-constexpr-conversion"
-#endif
-		return std::array {EnumValueDetails<static_cast<E>(n)>::valid...};
-#pragma GCC diagnostic pop
+		return std::array {EnumValueDetails<static_cast<E>(N)>::VALID...};
 	}
 
-	template<auto... n>
+	template<auto... N>
 	constexpr static auto
-	get_values(std::integer_sequence<int, n...>)
+	getValues(std::integer_sequence<Underlying, N...>)
 	{
-#pragma GCC diagnostic push
-#ifdef __clang__
-#	pragma GCC diagnostic ignored "-Wenum-constexpr-conversion"
-#endif
-		return std::array {EnumValueDetails<static_cast<E>(n)>::raw_value...};
-#pragma GCC diagnostic pop
+		return std::array {EnumValueDetails<static_cast<E>(N)>::RAW_VALUE...};
 	}
 
-	template<auto... n>
+	template<auto... N>
 	constexpr static auto
-	get_valueNames(std::integer_sequence<int, n...>)
+	getValueNames(std::integer_sequence<int, N...>)
 	{
-		return std::array {EnumValueDetails<values[n]>::valueName...};
+		return std::array {EnumValueDetails<VALUES[N]>::VALUE_NAME...};
 	}
 
 	using EVC = EnumValueCollection<E>;
-	constexpr static auto valid_flags {get_valids(typename EVC::Vs {})};
-	constexpr static auto valid_count {std::count_if(valid_flags.begin(), valid_flags.end(), std::identity {})};
+	constexpr static auto VALID_FLAGS {getValids(typename EVC::Vs {})};
+	constexpr static auto VALID_COUNT {std::count_if(VALID_FLAGS.begin(), VALID_FLAGS.end(), std::identity {})};
 
 	constexpr static auto
-	lookup(const auto key, const auto & search,
-			const auto & out) -> std::optional<typename std::decay_t<decltype(out)>::value_type>
+	lookup(const auto key, const auto & search, const auto & out)
+			-> std::optional<typename std::decay_t<decltype(out)>::value_type>
 	{
 		if (const auto itr = std::find(search.begin(), search.end(), key); itr != search.end()) {
 			return out[static_cast<std::size_t>(std::distance(search.begin(), itr))];
@@ -131,32 +119,32 @@ private:
 	}
 
 public:
-	constexpr static auto values {[]() {
-		constexpr auto values {get_values(typename EVC::Vs {})};
-		static_assert(std::is_sorted(values.begin(), values.end()), "Candidate values must be sorted");
-		std::array<E, valid_count> out;
-		std::copy_if(values.begin(), values.end(), out.begin(), [valid = valid_flags.begin()](auto) mutable {
+	constexpr static auto VALUES {[]() {
+		constexpr auto VALUES {getValues(typename EVC::Vs {})};
+		static_assert(std::ranges::is_sorted(VALUES), "Candidate values must be sorted");
+		std::array<E, VALID_COUNT> out;
+		std::copy_if(VALUES.begin(), VALUES.end(), out.begin(), [valid = VALID_FLAGS.begin()](auto) mutable {
 			return *valid++;
 		});
 		return out;
 	}()};
-	constexpr static auto names {get_valueNames(std::make_integer_sequence<int, valid_count> {})};
+	constexpr static auto NAMES {getValueNames(std::make_integer_sequence<int, VALID_COUNT> {})};
 
 	constexpr static bool
-	is_valid(E value) noexcept
+	isValid(E value) noexcept
 	{
-		return std::binary_search(values.begin(), values.end(), value);
+		return std::binary_search(VALUES.begin(), VALUES.end(), value);
 	}
 
 	constexpr static std::optional<E>
 	parse(std::string_view name) noexcept
 	{
-		return lookup(name, names, values);
+		return lookup(name, NAMES, VALUES);
 	}
 
 	constexpr static std::optional<std::string_view>
-	to_string(E value) noexcept
+	toString(E value) noexcept
 	{
-		return lookup(value, values, names);
+		return lookup(value, VALUES, NAMES);
 	}
 };
diff --git a/lib/stream_support.h b/lib/stream_support.h
index 5f276fd..7f1df96 100644
--- a/lib/stream_support.h
+++ b/lib/stream_support.h
@@ -81,7 +81,7 @@ namespace std {
 	inline std::ostream &
 	operator<<(std::ostream & s, const E & e)
 	{
-		return s << EnumTypeDetails<E>::typeName << "::" << EnumDetails<E>::to_string(e).value();
+		return s << EnumTypeDetails<E>::TYPE_NAME << "::" << EnumDetails<E>::toString(e).value();
 	}
 
 	template<typename T>
diff --git a/test/enumDetailsData.h b/test/enumDetailsData.h
index b7bd601..6383838 100644
--- a/test/enumDetailsData.h
+++ b/test/enumDetailsData.h
@@ -1,23 +1,24 @@
 #pragma once
+#include <cstdint>
 #include <enumDetails.h>
 
-enum GlobalUnscoped { aa, b, c };
-enum class GlobalScoped { aa, b, c };
+enum GlobalUnscoped : uint8_t { Aa, B, C };
+enum class GlobalScoped : int8_t { Aa, B, C };
 
 namespace ns {
-	enum Unscoped { aa, b, c };
-	enum class Scoped { aa, b, c };
+	enum Unscoped : int8_t { Aa, B, C };
+	enum class Scoped : int8_t { Aa, B, C };
 }
 
 namespace test1 {
-	enum class DefaultDense { a, bee, ci, de };
+	enum class DefaultDense : int8_t { A, Bee, Ci, De };
 }
 
 namespace test2 {
-	enum class NumberedSparse { a = 0, bee = 3, ci = -20, de = 100 };
+	enum class NumberedSparse : int8_t { A = 0, Bee = 3, Ci = -20, De = 100 };
 }
 
 template<> struct EnumValueCollection<test2::NumberedSparse> {
 	// Any ordered integer_sequence which includes all enumeration values
-	using Vs = std::integer_sequence<int, -100, -20, 0, 3, 10, 100, 1000>;
+	using Vs = std::integer_sequence<int8_t, -100, -20, 0, 3, 10, 100, 110>;
 };
diff --git a/test/test-enumDetails.cpp b/test/test-enumDetails.cpp
index 0e759e5..6bcd627 100644
--- a/test/test-enumDetails.cpp
+++ b/test/test-enumDetails.cpp
@@ -7,47 +7,47 @@
 #include <enumDetails.h>
 #include <stream_support.h>
 
-constexpr std::array INVALID_NAMES {"", "missing", "GlobalScoped::aa", "GlobalScoped", "ns::aa", "a", "bb"};
-constexpr std::array VALID_NAMES {"aa", "b", "c"};
-template<typename E> constexpr std::array VALID_VALUES {E::aa, E::b, E::c};
+constexpr std::array INVALID_NAMES {"", "missing", "GlobalScoped::Aa", "GlobalScoped", "ns::Aa", "A", "Bb"};
+constexpr std::array VALID_NAMES {"Aa", "B", "C"};
+template<typename E> constexpr std::array VALID_VALUES {E::Aa, E::B, E::C};
 // Not a template, else Boost test framework throws printing the context
 constexpr std::array INVALID_VALUES {-1, 3, 20};
 
 #define TESTS_FOR_TYPE(TYPE) \
-	BOOST_DATA_TEST_CASE(invalid_check_##TYPE, INVALID_VALUES, in) \
+	BOOST_DATA_TEST_CASE(invalid_check_##TYPE, INVALID_VALUES, input) \
 	{ \
-		BOOST_CHECK(!EnumDetails<TYPE>::is_valid(static_cast<TYPE>(in))); \
+		BOOST_CHECK(!EnumDetails<TYPE>::isValid(static_cast<TYPE>(input))); \
 	} \
-	BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, in) \
+	BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, input) \
 	{ \
-		BOOST_CHECK(!EnumDetails<TYPE>::parse(in).has_value()); \
+		BOOST_CHECK(!EnumDetails<TYPE>::parse(input).has_value()); \
 	} \
-	BOOST_DATA_TEST_CASE(invalid_to_string_##TYPE, INVALID_VALUES, in) \
+	BOOST_DATA_TEST_CASE(invalid_to_string_##TYPE, INVALID_VALUES, input) \
 	{ \
-		BOOST_CHECK(!EnumDetails<TYPE>::to_string(static_cast<TYPE>(in)).has_value()); \
+		BOOST_CHECK(!EnumDetails<TYPE>::toString(static_cast<TYPE>(input)).has_value()); \
 	} \
-	BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES<TYPE>, in) \
+	BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES<TYPE>, input) \
 	{ \
-		BOOST_CHECK(EnumDetails<TYPE>::is_valid(in)); \
+		BOOST_CHECK(EnumDetails<TYPE>::isValid(input)); \
 	} \
-	BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES<TYPE>, in, out) \
+	BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES<TYPE>, input, output) \
 	{ \
-		const auto v = EnumDetails<TYPE>::parse(in); \
-		BOOST_CHECK_IF(vo, v.has_value()) { \
-			BOOST_CHECK_EQUAL(v.value(), out); \
+		const auto parsed = EnumDetails<TYPE>::parse(input); \
+		BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \
+			BOOST_CHECK_EQUAL(parsed.value(), output); \
 		} \
 	} \
-	BOOST_DATA_TEST_CASE(valid_to_string_##TYPE, VALID_VALUES<TYPE> ^ VALID_NAMES, in, out) \
+	BOOST_DATA_TEST_CASE(valid_to_string_##TYPE, VALID_VALUES<TYPE> ^ VALID_NAMES, input, output) \
 	{ \
-		const auto v = EnumDetails<TYPE>::to_string(in); \
-		BOOST_CHECK_IF(vo, v.has_value()) { \
-			BOOST_CHECK_EQUAL(v.value(), out); \
+		const auto parsed = EnumDetails<TYPE>::toString(input); \
+		BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \
+			BOOST_CHECK_EQUAL(parsed.value(), output); \
 		} \
 	}
 
 TESTS_FOR_TYPE(GlobalScoped)
 TESTS_FOR_TYPE(GlobalUnscoped)
-using ns_unscoped = ns::Unscoped;
-using ns_scoped = ns::Scoped;
-TESTS_FOR_TYPE(ns_unscoped)
-TESTS_FOR_TYPE(ns_scoped)
+using NsUnscoped = ns::Unscoped;
+using NsScoped = ns::Scoped;
+TESTS_FOR_TYPE(NsUnscoped)
+TESTS_FOR_TYPE(NsScoped)
diff --git a/test/test-static-enumDetails.cpp b/test/test-static-enumDetails.cpp
index 5f81753..932a2af 100644
--- a/test/test-static-enumDetails.cpp
+++ b/test/test-static-enumDetails.cpp
@@ -3,76 +3,76 @@
 #include <enumDetails.h>
 
 // Test type name
-static_assert(EnumTypeDetails<GlobalUnscoped>::typeName == "GlobalUnscoped");
-static_assert(EnumTypeDetails<GlobalScoped>::typeName == "GlobalScoped");
-static_assert(EnumTypeDetails<ns::Unscoped>::typeName == "ns::Unscoped");
-static_assert(EnumTypeDetails<ns::Scoped>::typeName == "ns::Scoped");
+static_assert(EnumTypeDetails<GlobalUnscoped>::TYPE_NAME == "GlobalUnscoped");
+static_assert(EnumTypeDetails<GlobalScoped>::TYPE_NAME == "GlobalScoped");
+static_assert(EnumTypeDetails<ns::Unscoped>::TYPE_NAME == "ns::Unscoped");
+static_assert(EnumTypeDetails<ns::Scoped>::TYPE_NAME == "ns::Scoped");
 
-static_assert(EnumValueDetails<GlobalUnscoped::aa>::valueName == "aa");
-static_assert(EnumValueDetails<GlobalScoped::aa>::valueName == "aa");
-static_assert(EnumValueDetails<ns::Unscoped::aa>::valueName == "aa");
-static_assert(EnumValueDetails<ns::Scoped::aa>::valueName == "aa");
+static_assert(EnumValueDetails<GlobalUnscoped::Aa>::VALUE_NAME == "Aa");
+static_assert(EnumValueDetails<GlobalScoped::Aa>::VALUE_NAME == "Aa");
+static_assert(EnumValueDetails<ns::Unscoped::Aa>::VALUE_NAME == "Aa");
+static_assert(EnumValueDetails<ns::Scoped::Aa>::VALUE_NAME == "Aa");
 
 namespace test1 {
-	static_assert(EnumValueDetails<DefaultDense::a>::valid);
-	static_assert(EnumValueDetails<DefaultDense::de>::valid);
-	static_assert(EnumValueDetails<static_cast<DefaultDense>(0)>::valid);
-	static_assert(EnumValueDetails<static_cast<DefaultDense>(3)>::valid);
-	static_assert(!EnumValueDetails<static_cast<DefaultDense>(-1)>::valid);
-	static_assert(!EnumValueDetails<static_cast<DefaultDense>(4)>::valid);
-	static_assert(EnumValueDetails<DefaultDense::a>::valueName == "a");
-	static_assert(EnumValueDetails<DefaultDense::de>::valueName == "de");
-	using ED_DD = EnumDetails<DefaultDense>;
-	static_assert(EnumValueCollection<DefaultDense>::Vs::size() == 256);
-	static_assert(ED_DD::valid_flags.size() == 256);
-	static_assert(ED_DD::values.size() == 4);
-	static_assert(std::is_sorted(ED_DD::values.begin(), ED_DD::values.end()));
-	static_assert(ED_DD::values.at(0) == DefaultDense::a);
-	static_assert(ED_DD::values.at(3) == DefaultDense::de);
-	static_assert(ED_DD::names.at(0) == "a");
-	static_assert(ED_DD::names.at(3) == "de");
+	static_assert(EnumValueDetails<DefaultDense::A>::VALID);
+	static_assert(EnumValueDetails<DefaultDense::De>::VALID);
+	static_assert(EnumValueDetails<static_cast<DefaultDense>(0)>::VALID);
+	static_assert(EnumValueDetails<static_cast<DefaultDense>(3)>::VALID);
+	static_assert(!EnumValueDetails<static_cast<DefaultDense>(-1)>::VALID);
+	static_assert(!EnumValueDetails<static_cast<DefaultDense>(4)>::VALID);
+	static_assert(EnumValueDetails<DefaultDense::A>::VALUE_NAME == "A");
+	static_assert(EnumValueDetails<DefaultDense::De>::VALUE_NAME == "De");
+	using EdDd = EnumDetails<DefaultDense>;
+	static_assert(EnumValueCollection<DefaultDense>::Vs::size() == 127);
+	static_assert(EdDd::VALID_FLAGS.size() == 127);
+	static_assert(EdDd::VALUES.size() == 4);
+	static_assert(std::ranges::is_sorted(EdDd::VALUES));
+	static_assert(EdDd::VALUES.at(0) == DefaultDense::A);
+	static_assert(EdDd::VALUES.at(3) == DefaultDense::De);
+	static_assert(EdDd::NAMES.at(0) == "A");
+	static_assert(EdDd::NAMES.at(3) == "De");
 
-	static_assert(ED_DD::is_valid(DefaultDense::a));
-	static_assert(ED_DD::is_valid(DefaultDense::de));
-	static_assert(!ED_DD::is_valid(DefaultDense(-1)));
-	static_assert(!ED_DD::parse("").has_value());
-	static_assert(!ED_DD::parse("nonsense").has_value());
-	static_assert(ED_DD::parse("bee").value() == DefaultDense::bee);
-	static_assert(ED_DD::parse("ci").value() == DefaultDense::ci);
-	static_assert(ED_DD::to_string(DefaultDense::de).value() == "de");
-	static_assert(!ED_DD::to_string(static_cast<DefaultDense>(10)).has_value());
+	static_assert(EdDd::isValid(DefaultDense::A));
+	static_assert(EdDd::isValid(DefaultDense::De));
+	static_assert(!EdDd::isValid(DefaultDense(-1)));
+	static_assert(!EdDd::parse("").has_value());
+	static_assert(!EdDd::parse("nonsense").has_value());
+	static_assert(EdDd::parse("Bee").value() == DefaultDense::Bee);
+	static_assert(EdDd::parse("Ci").value() == DefaultDense::Ci);
+	static_assert(EdDd::toString(DefaultDense::De).value() == "De");
+	static_assert(!EdDd::toString(static_cast<DefaultDense>(10)).has_value());
 }
 
 namespace test2 {
-	static_assert(EnumValueDetails<NumberedSparse::bee>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(0)>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(3)>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(-20)>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(100)>::valid);
-	static_assert(!EnumValueDetails<static_cast<NumberedSparse>(2)>::valid);
-	static_assert(EnumValueDetails<NumberedSparse::a>::valueName == "a");
-	static_assert(EnumValueDetails<NumberedSparse::de>::valueName == "de");
-	using ED_NS = EnumDetails<NumberedSparse>;
+	static_assert(EnumValueDetails<NumberedSparse::Bee>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(0)>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(3)>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(-20)>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(100)>::VALID);
+	static_assert(!EnumValueDetails<static_cast<NumberedSparse>(2)>::VALID);
+	static_assert(EnumValueDetails<NumberedSparse::A>::VALUE_NAME == "A");
+	static_assert(EnumValueDetails<NumberedSparse::De>::VALUE_NAME == "De");
+	using EdNs = EnumDetails<NumberedSparse>;
 	static_assert(EnumValueCollection<NumberedSparse>::Vs::size() == 7);
-	static_assert(ED_NS::values.size() == 4);
-	static_assert(ED_NS::valid_flags.size() == 7);
-	static_assert(std::is_sorted(ED_NS::values.begin(), ED_NS::values.end()));
-	static_assert(ED_NS::values.at(0) == NumberedSparse::ci);
-	static_assert(ED_NS::values.at(1) == NumberedSparse::a);
-	static_assert(ED_NS::values.at(2) == NumberedSparse::bee);
-	static_assert(ED_NS::values.at(3) == NumberedSparse::de);
-	static_assert(ED_NS::names.at(0) == "ci");
-	static_assert(ED_NS::names.at(1) == "a");
-	static_assert(ED_NS::names.at(2) == "bee");
-	static_assert(ED_NS::names.at(3) == "de");
+	static_assert(EdNs::VALUES.size() == 4);
+	static_assert(EdNs::VALID_FLAGS.size() == 7);
+	static_assert(std::ranges::is_sorted(EdNs::VALUES));
+	static_assert(EdNs::VALUES.at(0) == NumberedSparse::Ci);
+	static_assert(EdNs::VALUES.at(1) == NumberedSparse::A);
+	static_assert(EdNs::VALUES.at(2) == NumberedSparse::Bee);
+	static_assert(EdNs::VALUES.at(3) == NumberedSparse::De);
+	static_assert(EdNs::NAMES.at(0) == "Ci");
+	static_assert(EdNs::NAMES.at(1) == "A");
+	static_assert(EdNs::NAMES.at(2) == "Bee");
+	static_assert(EdNs::NAMES.at(3) == "De");
 
-	static_assert(ED_NS::is_valid(NumberedSparse::a));
-	static_assert(ED_NS::is_valid(NumberedSparse::de));
-	static_assert(!ED_NS::is_valid(NumberedSparse(-1)));
-	static_assert(!ED_NS::parse("").has_value());
-	static_assert(!ED_NS::parse("nonsense").has_value());
-	static_assert(ED_NS::parse("bee").value() == NumberedSparse::bee);
-	static_assert(ED_NS::parse("ci").value() == NumberedSparse::ci);
-	static_assert(ED_NS::to_string(NumberedSparse::ci).value() == "ci");
-	static_assert(!ED_NS::to_string(static_cast<NumberedSparse>(10)).has_value());
+	static_assert(EdNs::isValid(NumberedSparse::A));
+	static_assert(EdNs::isValid(NumberedSparse::De));
+	static_assert(!EdNs::isValid(NumberedSparse(-1)));
+	static_assert(!EdNs::parse("").has_value());
+	static_assert(!EdNs::parse("nonsense").has_value());
+	static_assert(EdNs::parse("Bee").value() == NumberedSparse::Bee);
+	static_assert(EdNs::parse("Ci").value() == NumberedSparse::Ci);
+	static_assert(EdNs::toString(NumberedSparse::Ci).value() == "Ci");
+	static_assert(!EdNs::toString(static_cast<NumberedSparse>(10)).has_value());
 }