Член статической строки класса шаблона неправильно инициализирован

Question

Я пытаюсь создать простую оболочку вокругglib2.0.

Я предполагал, что у меня есть шаблонный класс, который будет использоваться для получения строки форматаGVariantтип:

      template <typename T>
struct Object
{
    static const std::string format_string;
};

На данный момент я жестко запрограммировал основные целочисленные типы и строки и определил способ получения массивов и словарей следующим образом:

      // Integral types
template <>
const std::string Object<uint8_t>::format_string{"y"};
...

// String
template <>
const std::string Object<std::string>::format_string{"s"};

// Array
template <typename T>
struct Object<std::vector<T>>
{
    static const std::string format_string;
};
template <typename T>
const std::string Object<std::vector<T>>::format_string{
  "a" + Object<T>::format_string};

// Dictionary
template <typename K, typename V>
struct Object<std::map<K, V>>
{
    static const std::string format_string;
};
template <typename K, typename V>
const std::string Object<std::map<K, V>>::format_string{
  "{" + Object<K>::format_string + Object<V>::format_string + "}"};

Для кортежа я использую следующий метод вывода строки:

      template <typename T, typename... Ts>
std::string derive_string()
{
    if constexpr (sizeof...(Ts)) {
        return Object<T>::format_string + derive_string<Ts...>();
    } else {
        return Object<T>::format_string;
    }
}

// Tuple
template <typename... Ts>
struct Object<std::tuple<Ts...>>
{
    static const std::string format_string;
};

template <typename... Ts>
const std::string Object<std::tuple<Ts...>>::format_string{
  "(" + derive_string<Ts...>() + ")"};

Однако, когда я пытаюсь отладить печатьformat_stringчлен каждогоObjectсорт

      using IntArray = std::vector<int>;
using IntStrMap = std::map<int, std::string>;
using Int_Double_Bool = std::tuple<int, double, bool>;
using Int_IntStrMap_Bool = std::tuple<int, IntStrMap, bool>;
using Int_IntDoubleMap = std::tuple<int, std::map<int, double>>;

std::cout << "bool type:\n  " << Object<bool>::format_string
          << "\nuint8_t type:\n  " << Object<uint8_t>::format_string
          << "\nint16_t type:\n  " << Object<int16_t>::format_string
          << "\nuint16_t type:\n  " << Object<uint16_t>::format_string
          << "\nint32_t type:\n  " << Object<int32_t>::format_string
          << "\nuint32_t type:\n  " << Object<uint32_t>::format_string
          << "\nint64_t type:\n  " << Object<int64_t>::format_string
          << "\nuint64_t type:\n  " << Object<uint64_t>::format_string
          << "\ndouble type:\n  " << Object<double>::format_string
          << "\nstring type:\n  " << Object<std::string>::format_string
          << "\n[int] type\n  " << Object<IntArray>::format_string
          << "\n{int: str} type\n  " << Object<IntStrMap>::format_string
          << "\n(int, double, bool) type\n  "
          << Object<Int_Double_Bool>::format_string
          << "\n(int, {int: str}, bool) type\n  "
          << Object<Int_IntStrMap_Bool>::format_string
          << "\n(int, {int: double}) type\n  "
          << Object<Int_IntDoubleMap>::format_string;
          << std::endl;

Я получаю следующее:

      bool type:
  b
uint8_t type:
  y
int16_t type:
  n
uint16_t type:
  q
int32_t type:
  i
uint32_t type:
  u
int64_t type:
  x
uint64_t type:
  t
double type:
  d
string type:
  s
[int] type
  ai
{int: str} type
  {is}
(int, double, bool) type
  (idb)
(int, {int: str}, bool) type
  (i{is}b)
(int, {int: double}) type
  (i)

Как видно из двух последних распечаток объекта, кортеж, включающий типы, которые использовались где-то еще ({int: str}) выводится правильно, а тот, который не ({int: double}), не.

Что я здесь делаю неправильно?