Как избежать дублирования текста строкового литерала в функциях, которые принимают символы/строки разной ширины?

Мне часто приходится создавать функции манипулирования строками на C++. Мои API, как правило, написаны так, чтобы принимать std::basic_string<T> (эффективно), но я также хочу принимать std::basic_string_view<T>, когда это имеет смысл. При принятии string_view было несколько проблем, над которыми я работал, но с литералами я обнаружил только боль.

Теперь, будучи хорошим разработчиком, я ненавижу как встроенные литералы, так и дублирование кода.

Я обнаружил, что пытаюсь написать это:

template <typename CharType>
constexpr const CharType* HELLO_WORLD = "Hello World!";

Это не работает, особенно потому, что если CharType нет char, мне нужен u или U или L.

Мне бы хотелось решение, которое выглядит так:

template <typename CharType>
static const CharType* HELLO_WORLD = <CharType>"Hello World!";

Моя текущая альтернатива требует макросов, которые создают структуры, специализирующиеся на макросах:

#define DEFINE_STRING_LITERAL(name, str)                 \
    template <typename CharType>                         \
    struct name {};                                      \
                                                         \
    template <>                                          \
    struct name<char> {                                  \
        static constexpr const char* value = str;        \
    };                                                   \
                                                         \
    template <>                                          \
    struct name<wchar_t> {                               \
        static constexpr const wchar_t* value = L##str;  \
    };                                                   \
                                                         \
    template <>                                          \
    struct name<char16_t> {                              \
        static constexpr const char16_t* value = u##str; \
    };                                                   \
                                                         \
    template <>                                          \
    struct name<char32_t> {                              \
        static constexpr const char32_t* value = U##str; \
    };

Что определяется следующим образом:

DEFINE_STRING_LITERAL(HELLO_WORLD ,"value");

и используется следующим образом:

HELLO_WORLD<CharType>::value

Это нормально, я могу запихнуть макрос куда-нибудь в заголовок и забыть о нем. Но мне не нравится синтаксис определения. Это не похоже на определение, а затем пытаться найти, где оно определено, с помощью статических инструментов, если мне нужно его изменить, — это головная боль. Кроме того, он не выводится по типу, что затрудняет чтение полученного кода.

Компилятор знает, какие литеральные префиксы с какими типами связаны. Я знаю это, потому что он не скомпилируется, если я его испорчу. Итак, есть ли способ избежать этой специализации структур и получить что-то ближе к однострочнику, который я хотел бы видеть?

Если у кого-то есть лучшее решение, которое больше похоже на стандарт C++, а не на использование макроса для определения типа на лету, это было бы здорово.

P.S. Вероятно, я мог бы создать константный класс со своим собственным синтаксисом и хранить char*, но тогда мне нужно будет копировать строки, а не позволять компилятору управлять ими. Мне бы также хотелось, чтобы это были действительно статические литералы, поскольку я не могу использовать динамические const CharType* в качестве значений в параметрах шаблона.