1. Добавление возможностей C++ std::format из C++20 в C++17 (бэкпорт новых фич в старый стандарт).
   
2. Совместимость форматной строки с форматной строкой языков Python и C++. Некоторые возможности этих языков игнорируются, но не вызывают ошибки при разборе форматной строки. В библиотеке совмещены возможности форматирования из языка `Python` и возможности форматирования `C++20` `std::format`.
   
3. Поддержка именованных аргументов для C++ при использовании соответствующих контейнеров для аргументов.
   
4. Поддержка передачи аргументов через std::initializer_list для непосредственного использования из C++.
   
5. Упор на использование библиотеки в своих скриптовых языках/DSL языках.
   
6. Поддержка Unicode в кодировке UTF-8.
   
7. Поддержка чисел с плавающей точкой произвольной размерности marty::Decimal.
   
8. Поддержка пользовательских типов строк вместо std::string и поддержка микроконтроллеров (STM32, как пример). Пока не реализовано, но весьма ready, требует отключения части кода условными макросами, также требуется модифицировать некоторые части, пока завязанные на std::string.
   
9. Возможность создания собственной системы/библиотеки форматирования на базе данной библиотеки с поддержкой вывода собственных произвольных типов данных.

 formatMessage("{} + {} = {}", 2, 2, 4)

 formatMessage("{} + {} = {}", {2, 2, 4})

template <typename Arg, typename... Args>
void foo(Arg&& arg, Args&&... args) {
    auto list = { std::forward<Arg>(args)...};
}

T=template{ name="<a>", u=string.upper, e=xml_encode }
print(T"result={{name|u|e}}")

result=<A>

T=template{ a1=align_text{ type="right", width=80, text_width=get_html_text_width } }

cout << formatMessage(
    "Pi: {Pi:f}\n"ms.arg("Pi", 3.14159)
);

// https://en.cppreference.com/w/cpp/language/user_literal
#include <string>
using std::string;

struct A {
    const char* text; size_t size;
    A& var(const char* name,...) { return *this; }
    operator string() { return "result"; }
};

A operator ""_f(const char* text, size_t size) { return A{text,size}; }

int main(int argc, char **argv) {
    string res=R"(
+----+---+
| 12 | 3 |
+----+---+
)"_f.var("a",12).var("b",3.14);
    return 0;
}

M>Есть такое, потом почищу, если руки дотянуться

I>>cout << formatMessage(
I>>    "Pi: {Pi:f}\n"ms.arg("Pi", 3.14159)
I>>);
I>>

cout << "Pi: {Pi:f}\n"ms.arg("Pi", 3.14159);

using FormatArguments = std::vector< std::pair<std::string, FormatArgumentVariant> >;

cout << "Pi: {Pi:f}\n"ms.arg("Pi", 3.14159);

using namespace marty::format::literals;

using namespace marty::format::literals;
cout << "Pi: {Pi:f}\n"_mf.arg("Pi", 3.14159);

cout << marty::format::formatMessage("Pi: {Pi:f}\n", marty::format::Args().arg("Pi", 3.14159);

static inline std::map<FormattingFlags, std::string> = {
   {FormattingFlags::unknow,  "unknown"},
// ...
};

base_error(const base_error &e) = default;
base_error& operator=(const base_error& e) = default;

if ((formattingFlags&FormattingFlags::ignoreFillIndirectErrors)==0)

    if (n>str.size())
        return "";

year = 2016
event = 'Referendum'
f'Results of the {year} {event}' # Results of the 2016 Referendum'

I>static inline std::map<FormattingFlags, std::string> = {
I>   {FormattingFlags::unknow,  "unknown"},
I>// ...
I>};
I>

#define MARTY_CPP_ENUM_DESERIALIZE_ITEM( val, valStr )                       \
        _m[lowerCaseConvert ? marty_cpp::toLower(std::string(valStr)) : std::string(valStr)] = val

I>base_error(const base_error &e) = default;
I>base_error& operator=(const base_error& e) = default;
I>

I>if ((formattingFlags&FormattingFlags::ignoreFillIndirectErrors)==0)
I>

I> не читается без пробелов вокруг &

I>    if (n>str.size())
I>        return "";
I>

int main(int argc, char* argv[])
{
    (void)(argc);
    (void)(argv);

I>>static inline std::map<FormattingFlags, std::string> = {
I>>   {FormattingFlags::unknow,  "unknown"},
I>>// ...
I>>};
I>>

M>#define MARTY_CPP_ENUM_DESERIALIZE_ITEM( val, valStr )                       \
M>        _m[lowerCaseConvert ? marty_cpp::toLower(std::string(valStr)) : std::string(valStr)] = val
M>

auto optionalError = [&](const std::string &msg)
{
    if (ignoreErrors)  // Тут по названия !ignoreErrors
        throw std::runtime_error(msg);
};

if ((formattingFlags&FormattingFlags::ignoreFormattingErrors)==0)
    throw; // Прокидываем исключение выше

inline constexpr bool isFormatSignMarker(utf32_char_t ch)
{
    return ch==utf32_char_t('-') || ch==utf32_char_t('+') /*  || ch==utf32_char_t(' ') */ ;
}

inline constexpr bool isFormatSignMarker(utf32_char_t ch)
{
   swith(ch) {
      case '-':
      case '+':
      //case ' ':
         return true;
      default:
         return false;
   }
}

static inline std::set<utf32_char_t> formatSignMarker = {
    {'-'},
    {'+'},
//    {' '},
}

inline bool isFormatSignMarker(utf32_char_t ch) {
    return formatSignMarker.contains(ch);
}

I>>inline constexpr bool isFormatSignMarker(utf32_char_t ch)
I>>{
I>>    return ch==utf32_char_t('-') || ch==utf32_char_t('+') /*  || ch==utf32_char_t(' ') */ ;
I>>}
I>>

I>>inline constexpr bool isFormatSignMarker(utf32_char_t ch)
I>>{
I>>   swith(ch) {
I>>      case '-':
I>>      case '+':
I>>      //case ' ':
I>>         return true;
I>>      default:
I>>         return false;
I>>   }
I>>}
I>>

inline
constexpr
bool isFormatTypeChar(utf32_char_t ch)
{
    return ch==utf32_char_t('?') || ch==utf32_char_t('s') || ch==utf32_char_t('b') || ch==utf32_char_t('B') || ch==utf32_char_t('c')
        || ch==utf32_char_t('d') || ch==utf32_char_t('o') || ch==utf32_char_t('x') || ch==utf32_char_t('X') || ch==utf32_char_t('a')
        || ch==utf32_char_t('A') || ch==utf32_char_t('e') || ch==utf32_char_t('E') || ch==utf32_char_t('f') || ch==utf32_char_t('F')
        || ch==utf32_char_t('g') || ch==utf32_char_t('G') || ch==utf32_char_t('n') || ch==utf32_char_t('%');
}

    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlAttr   , "html-attr" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlAttr   , "html_attr" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlAttr   , "htmlattr"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::none       , "none"      );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xml        , "xml"       );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlAttr    , "xml-attr"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlAttr    , "xml_attr"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlAttr    , "xmlattr"   );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlText    , "xml-text"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlText    , "xml_text"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlText    , "xmltext"   );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::html       , "html"      );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlText   , "html-text" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlText   , "html_text" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlText   , "htmltext"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::sql        , "sql"       );

    //! Подавление варнинга о неиспользованном аргументе
    #define MARTY_ARG_USED(x)                   (void)(x)

#define MARTY_CPP_ENUM_SERIALIZE_BEGIN( enumTypeName, mapType, doLower )     \
inline                                                                       \
mapType< enumTypeName, std::string > enum_serialize_make_map_##enumTypeName()\
{                                                                            \
     /* static  */ mapType< enumTypeName, std::string >  _m;                 \
    if (_m.empty())                                                          \
    {

inline                                                                       \
const mapType< enumTypeName, std::string >& enum_serialize_get_map_##enumTypeName() \
{                                                                            \
    static mapType< enumTypeName, std::string > m = enum_serialize_make_map_##enumTypeName();\
    return m;                                                               \
}

inline                                                                       \
std::string enum_serialize_##enumTypeName( enumTypeName v )                  \
{                                                                            \
    const auto &m = enum_serialize_get_map_##enumTypeName();                 \
    mapType< enumTypeName, std::string >::const_iterator it = m.find(v);     \
    if (it==m.end())                                                         \
        return std::string();                                                \
                                                                             \
    return it->second;                                                       \
}

template<typename StringType> inline
std::vector<StringType> simple_string_split(const StringType &str, const typename StringType::value_type delim, typename StringType::size_type nSplits = -1)

StringType::size_type

	Скрытый текст

• '%' — форматный символ, вывод процентов, плавучку умножает на 100, целые — не трогает, выводит, как 'd', затем выводит символ процента
  
• 'n' — форматный символ — вывод как 'd', но с локалью текущего пользователя. Обрабатывается в форматной строке, но локаль юзера не использует.
  
• '=' — маркер выравнивания по ширине
  
• '~' — маркер биткаста — знаковое целое конвертируется побитно в беззнаковое соответствующего типа — не надо ручками кастить, когда хочется хекс или бин вывести. "~X" выведет "FFFFFFFF" для -1 при 32х-битном целом.
  
• '!' — маркер инверсии регистра — при выводе хексов позволяет делать префикс в другом регистре — "!#X" выведет "0xDEADBEAF"
  
• 'h'/'H' — форматный символ для вывода хексов, без префикса, но суффиксом 'h'/'H', как в асме (если не задана опция '#' — то разницы не будет)
  
• 's'/'S' — форматный символ для типа bool — выводит bool, как строки true/false (TRUE/FALSE). Маркер инверсии регистра позволяет печатать True/False (tRUE/fALSE)
  
• 'y', 'Y' — форматный символ для типа bool и целых типов — выводит bool, как строки yes/no
  
• 't', 'T' — форматный символ для целых чисел, позволяет их выводить как bool — чтобы а) не кастить инты руками в бул, б) чтобы можно было использовать в своей скриптоте, где нет типа бул.
  
• Для форматных символов 'y', 'Y' и 't', 'T' маркер/опция '#' (alternate form) выводит первый символ строкового представления типа bool (или целого) — 't'/'T'/'f'/'F'/'y'/'Y'/'n'/'N'.
  Это равносильно, как задать точность ".1" при выводе строки.
  
• вывод const void* как указателя — хекс, размер по ширине типа указателя на платформе, также выводит инты как указатели, но соответственно своему размеру.
  
• '_', ',' и ''' — маркеры разделителя групп разрядов, для хекс и бин — по 4 разряда, для дек и окт — по 3. Задаются после ширины поля и после точности поля (для плавучки, если дробную часть надо разбить на разряды тоже).