template <typename ... Args>
void Print(char const * const format,
           Args const & ... args) noexcept
{
    printf(format, Argument(args)...);
}

for (auto const &curr: Parametrs)
{
    checkFormat(parser, curr);
}

template <typename ... Args>
bool validate_format(const char* fmt)
{
    // распарсить формат и проверить его соответствие типам Args 
    // например используя рекурсивное применение вспомогательного шаблона к Args
    return ...;
}

std::printf("%5.3ang", angle); // Тут автоматически перевод радиан в углы.

constexpr bool checkCharOrNo(char const *&frmt, char const ch)
{
    if (*frmt == ch)
    {
        ++frmt;
        return true;
    }
    return false;
}

constexpr bool checkDigitOrNo(char const *&frmt)
{
    while (*frmt >= '0' && *frmt <= '9')
    {
        ++frmt;
    }
    return true;
}

constexpr bool checkFloat(char const *frmt)
{
    while (*frmt != '\0')
    {
        if (checkCharOrNo(frmt, '%'))
        {
            checkDigitOrNo(frmt);
            if (checkCharOrNo(frmt, '.'))
            {
                checkDigitOrNo(frmt);
            }
            return *frmt == 'f';
        }
        ++frmt;
    }
    return false;
}

static_assert(checkFloat("Angle: %f."));
static_assert(checkFloat("Angle: %10f."));
static_assert(checkFloat("Angle: %10.f.")); // Запретить в своём парсере.
static_assert(checkFloat("Angle: %10.3f."));

constexpr bool check(char const *str)
{
    return str != nullptr;
}

constexpr void print_f(char const *str)
{
    static_assert(check(str)); // Compile time.
    std::printf(str);          // Run time.
}

#if (DEBUG)
#define print_f(format, ...)                       \
    static_assert(checkArgs(format, __VA_ARGS__)); \
    printStr(format, __VA_ARGS__);
#elif (RELEASE)
// В Release хотим компилироваться без макросов. Для очистки совести.
#endif

template <size_t Size, typename... Parameters>
constexpr bool checkArgs(char const (&format)[Size],
                         Parameters const &... parameters)
{
    // В прототипе проверим длину формата и наличие нуля.
    char const *end = format;
    while (*end++ != '\0');
    size_t const len = end - format - 1;
    return len>0 && len<128;
}

// Тут начинается тихий ужас. В зависимости от конфигурации имя функции печати
// должно быть разным.
template <size_t Size, typename... Parameters>
constexpr void
#if (DEBUG)
printStr
#else
print_f
#endif
(char const (&format)[Size], Parameters const &... parameters)
{
    if (!checkArgs(format, parameters...)) throw -1; // Для Release.
    std::snprintf(buff, std::size(buff), format, parameters...);
}

void newTest()
{
    print_f("Angle: %0.3f. Mode: %s.", 12.8, "Prepare");
}

my_printf(fmt, 0.56f, 10, "some string");

void newTest()
{
    double d = std::rand();
    char* s = "Jim";

    bool const res1 =
        print_f("Angle: %0.3f. Mode: %s. Name: %s.", d, "Prepare", s);
    bool const res2 =
        print_f("My float: %f.", 12.8);
    bool const res3 =
        print_f("Hello, world !");
}

template <size_t N>
constexpr void processArray(char const (&)[N])
{
    static_assert(N > 0); // Я знаю, что массив не может быть размера ноль.
}

template <typename T>
constexpr void processType()
{
    // Для аргументов типов "строковый литерал".
    static_assert(std::is_array_v<T>);
    // А вот тут уже значения, а не типы, но приведение типов не работает с
    // массивами. Ну, наверное, не работает. Скорее всего…
    processArray(T{});
}

template <>
constexpr void processType<char *>()
{
}

template <>
constexpr void processType<double>()
{
}

template <size_t N>
constexpr void validateFormatArgs()
{
    static_assert(N == 0);
}

template <size_t N, typename T, typename... Rest>
constexpr void validateFormatArgs()
{
    processType<T>();
    validateFormatArgs<N-1, Rest...>();
}

template <size_t Size, typename... Parameters>
constexpr bool checkArgs(char const (&format)[Size],
                         Parameters const &... parameters)
{
    // Compile time навигация по типам.
    validateFormatArgs<sizeof...(Parameters), Parameters...>();
}

void my_printf(int x, int y, char const *format, ...)
    __attribute__((format(printf, 3, 4)));

void my_printf(int x, int y, char const *format, ...)
{
}

// Можно было бы написать так с преобразованием радиан в углы.
print_f("%ang", 0.3);
// Но зачем это делать если можно написать так?
std::printf("%f", toAng(0.3));
// В обоих случаях нужно явно указать, что в данных радианы.

Angle<double, AngType::Radian> ang = {};
double angles[3] = {};
std::string str;
print_f("%ang %ang_arr %s", ang, angles, str);