#include <iostream>

template <typename type_t>
struct object
{
    void print() { std::cout << "base template"; }
};

template <>
struct object<int>
{
    void print() { std::cout << "specialized template"; }
};

int main()
{
    object<int> obj; // force base template here
    obj.print();

    return 0;
}

struct base_api
{
  void print() { std::cout << "base template"; }
};

template <typename type_t>
struct object : base_api
{
  ...
};

template <>
struct object<int> : base_api
{
    void print() { std::cout << "specialized template"; }
};

int main()
{
    object<int> obj;
    obj.base_api::print();

    return 0;
}

obj.base_api::print();

using reftime_t = std::chrono::duration<int64, std:ratio<1, 10000000>>;

template <>
struct std::formatter<reftime_t> {
    // ...
};

V>using reftime_t = std::chrono::duration<int64, std:ratio<1, 10000000>>;
V>

struct reftime_for_std_format_t {
  reftime_t val_;
};

[[nodiscard]]
inline reftime_for_std_format_t wrap(reftime_t v) { return { v }; }

std::format("Duration is {}", wrap(your_reftime_value));

Если явно не запрещено, программа может добавить специализацию шаблона для любого шаблона класса стандартной библиотеки в пространство имен std при условии, что (а) добавленное объявление зависит по крайней мере от одного определенного в программе типа и (б) специализация соответствует требованиям стандартной библиотеки для оригинальный шаблон .

Это же не я, это стандартная библиотека такую свинью подложила, std. Вот эти вот классы, они в std определены и специализировать мне их предлагают по стандарту. А я говорил, что люди принимающие стандарты, по ходу вообще не думают, последнее время.

archive_t arch = pack(custom_class{}, as<archive_t>);

V>archive_t arch = pack(custom_class{}, as<archive_t>);
V>

int a = ...;
std::time_t b = ...;
print(std::cout, "Value {} at {}", a, b);

S>int a = ...;
S>std::time_t b = ...;
S>print(std::cout, "Value {} at {}", a, b);
S>

namespace my_namespace
{
struct my_trait{};
}

namespace std
{
std::print_as(std::cout, std::format_as<my_namespace::my_trait>(), "Value {} at {}", a, b);
}

template <typename type_t, template <typename> typename traits_t>
struct object {
    using t_traits = traits_t<type_t>;
    void print() { t_traits::print(this); }
};

template <typename type_t>
struct trait1 {
    static void print(type_t * p) { std::cout << "trait 1"; }
};

template <typename type_t>
struct trait2 {
    static void print(type_t * p) { std::cout << "trait 2"; }
};

int main() {
    object<int, trait1> obj;
    obj.print();
    return 0;
}

• Пользователь мог бы определять кастомные форматтеры в том же пространстве имен, что и пользовательские типы. Это удобнее писать и удобнее читать, потому что не нужно рвать пространства имен или выносить определения в какие-то отдельные места;
  
• При определении кастомных форматтеров пользователь мог бы использовать дополнительные параметры по умолчанию — как в списке шаблонных параметров, так и в списке формальных параметров функции, что дает возможность использования SFINAE и вообще дает большую гибкость в тех случаях, когда кастомизацию нужно сделать не для одного конкретного типа, а для какого-нибудь сеймейства типов, объединенных каким-то признаком;
  
• Как частный случай — форматтер, определенный для базового класса автоматом будет работать и для всех производных, для которых не предоставлена своя собственая версия форматтера;
  
• Используя квалифицированные вызовы, пользователь мог бы внутри кастомго форматтера повторно использовать форматтеры из других пространств имен, что дает возможность декорирования форматтеров.

#include <type_traits>
#include <fmt/format.h>

struct A {
  virtual ~A() {}
  virtual std::string name() const { return "A"; }
};

struct B : A {
  virtual std::string name() const { return "B"; }
};

template <typename T>
struct fmt::formatter<T, std::enable_if_t<std::is_base_of<A, T>::value, char>> :
    fmt::formatter<std::string> {
  template <typename FormatCtx>
  auto format(const A& a, FormatCtx& ctx) const {
    return fmt::formatter<std::string>::format(a.name(), ctx);
  }
};

int main() {
  B b;
  A& a = b;
  fmt::print("{}", a); // prints "B"
}

void parse(parsing_ctx &);
void format(const T & v, formatting_ctx &);

some_state parse(parsing_ctx &);
void format(const some_state & state, const T & v, formatting_ctx &);

namespace htlib::v2
{
template<typename type_t>
struct is_point {

    static std::false_type test(...);
    template<htlib::v2::uint_t dimensions, typename other_t>
    static std::true_type test(const htlib::v2::pointxd_t<dimensions, other_t>&);

    static constexpr bool value = decltype(test(std::declval<type_t>()))::value;
};
template<typename type_t>
inline constexpr bool is_point_v = is_point<type_t>::value;

} // namespace htlib::v2

template<typename char_t, typename point_t>
class std::formatter<point_t, char_t, std::enable_if_t<htlib::v2::is_point_v<point_t>>>
{
//...
}

template<htlib::v2::uint_t dimensions, typename other_t>
void formatter(const htlib::v2::pointxd_t<dimensions, other_t>&);

template <typename T>
struct fmt::formatter<T, std::enable_if_t<std::is_base_of<A, T>::value, char>> {};

template <typename T>
struct fmt::formatter<T, std::enable_if_t<std::is_base_of<С, T>::value, char>> {};

• можно определять пользовательские форматтеры в одном пространстве имен с пользовательскими типами,
  
• можно предоставлять форматтеры по умолчанию для целых пространств имен
  
• можно повторно использовать предопределенные наборы форматтеров для новых типов при помощи using-declarations
  
• еще одна важная деталь: фабрика форматтера получает параметром объект и теперь форматтер может быть чувствителен к свойствам объекта, для которого он создается, а не просто конструироваться по дефолту, как раньше. Например, форматтер может использовать полиморфно идиому pImpl и создавать различные внутренние имплементации форматирования в зависимости от каких-то runtime свойств объекта.

V>Наверное вопрос в этом, как выкрутится теперь. Ситуация простая. У std::formatter есть специализация для вывода std::chrono::duration<>. У меня в библиотеках везде используется своя специализация времени:

V>using reftime_t = std::chrono::duration<int64, std:ratio<1, 10000000>>;
V>

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

V>template <>
V>struct std::formatter<reftime_t> {
V>    // ...
V>};
V>

я автоматически лишаюсь возможности вызвать стандартную реализацию и вынужден повторять всю логику заново. Это не дело, я считаю

namespace xtr
{
    struct timespec : std::timespec
    {
        timespec() = default;

        timespec(std::timespec ts) : std::timespec(ts)
        {
        }
    };
}

template<>
struct fmt::formatter<xtr::timespec>
{
    template<typename ParseContext>
    constexpr auto parse(ParseContext& ctx)
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const xtr::timespec ts, FormatContext& ctx)
    {
        std::tm temp;
        return fmt::format_to(
            ctx.out(),
            "{:%Y-%m-%d %T}.{:06}",
            *::gmtime_r(&ts.tv_sec, &temp),
            ts.tv_nsec / 1000);
    }
};

#include <string>
#include <iostream>
#include <typeinfo>
#include <utility>

#include <fmt/core.h>
#include <fmt/chrono.h>
#include <fmt/xchar.h>

namespace my
{
// rg45 forward wrapper

template <typename T>
struct wrapper
{
    T t;

    explicit wrapper(T&& t) : t(std::forward<T>(t)) {}

    T&& forward() { return std::forward<T>(t); }
};

template <typename T>
wrapper<T> wrap(T&& t) { return wrapper<T>(std::forward<T>(t)); }



// own format wrapper

template<typename... Params>
std::string format(const std::string_view& format_string, Params&& ...params)
{
    return fmt::format(format_string, wrap(params)...);
}

} // namespace my



// dispatch formatter

template<typename char_t, typename type_t>
class fmt::formatter<my::wrapper<type_t>, char_t>
{
public:
    constexpr auto parse(basic_format_parse_context<char_t>& ctx) -> decltype(ctx.begin())
    {
        auto it = ctx.begin();
        auto end = ctx.end();

        it = std::find(it, end, '}');

        if (it != end && *it != '}')
            throw format_error("invalid format");

        return it;
    }

    template<typename it_t>
    auto format(my::wrapper<type_t>& data, basic_format_context<it_t, char_t>& ctx) const -> decltype(ctx.out())
    {
        return format_to(ctx.out(), "***{}***", data.forward());
    }
};



// test

int main()
{
    std::cout << my::format("{} | {} | {:.e}", 1, "str", 2.5);
}

***1*** | ***str*** | ***2.5***

V>template<typename... Params>
V>std::string format(const std::string_view& format_string, Params&& ...params)
V>{
V>    return fmt::format(format_string, wrap(params)...);
V>}
V>

    return fmt::format(format_string, wrap(std::forward<Params>(params))...);

// dispatch formatter

template<typename char_t, typename type_t>
class fmt::formatter<my::wrapper<type_t>, char_t>
{
public:
    constexpr auto parse(basic_format_parse_context<char_t>& ctx) -> decltype(ctx.begin())
    {
        return my::parse(...);
    }

    template<typename it_t>
    auto format(my::wrapper<type_t>& data, basic_format_context<it_t, char_t>& ctx) const -> decltype(ctx.out())
    {
        return my::format(...);
    }
};

// or 

template<typename char_t, typename type_t>
class fmt::formatter<my::wrapper<type_t>, char_t>
{
    my::formatter<type_t, char_t> m_formatter;

public:
    constexpr auto parse(basic_format_parse_context<char_t>& ctx) -> decltype(ctx.begin())
    {
        return m_formatter.parse(...);
    }

    template<typename it_t>
    auto format(my::wrapper<type_t>& data, basic_format_context<it_t, char_t>& ctx) const -> decltype(ctx.out())
    {
        return m_formatter.format(...);
    }
};

R>Ну я уже запал на вариант с фабрикой

template<typename U>
explicit wrapper(U&& t) : t(std::forward<U>(t)) {}

V>Кстати с wrapper-ом точно что-то не то, т.к. T&& у wrapper(T&& t) не является универсальной ссылкой. Наверное должно быть так:

V>template<typename U>
V>explicit wrapper(U&& t) : t(std::forward<U>(t)) {}
V>

Еще есть вариант что библиотека fmt обрабатывает стандартные типы внутри себя, без использования fmt::formatters, и из-за этого вся последовательность логики ломается.

#include <iostream>

template <typename T>
struct wrapper
{
    T t;

    explicit wrapper(T&& t) : t(std::forward<T>(t)) {}

    T&& forward() { return std::forward<T>(t); }
};

template <typename T>
wrapper<T> wrap(T&& t) { return wrapper<T>(std::forward<T>(t)); }

int main()
{
    int value = 42;
    
    std::cout << "Value before: " << value << std::endl;

    wrap(value).forward() = 43;

    std::cout << "Value after: " << value << std::endl;
}