<format> (C++20)

namespace std {
  //   basic_format_context
  template<class Out, class CharT> class basic_format_context;
  using format_context = basic_format_context</*  */, char>;
  using wformat_context = basic_format_context</*  */, wchar_t>;

  //   basic_format_args
  template<class Context> class basic_format_args;
  using format_args = basic_format_args<format_context>;
  using wformat_args = basic_format_args<wformat_context>;

  //   basic_format_string
  template<class CharT, class... Args>
    struct basic_format_string;

  template<class... Args>
    using format_string = basic_format_string<char, type_identity_t<Args>...>;
  template<class... Args>
    using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;

  //  
  template<class... Args>
    string format(format_string<Args...> fmt, Args&&... args);
  template<class... Args>
    wstring format(wformat_string<Args...> fmt, Args&&... args);
  template<class... Args>
    string format(const locale& loc, format_string<Args...> fmt, Args&&... args);
  template<class... Args>
    wstring format(const locale& loc, wformat_string<Args...> fmt, Args&&... args);

  string vformat(string_view fmt, format_args args);
  wstring vformat(wstring_view fmt, wformat_args args);
  string vformat(const locale& loc, string_view fmt, format_args args);
  wstring vformat(const locale& loc, wstring_view fmt, wformat_args args);

  template<class Out, class... Args>
    Out format_to(Out out, format_string<Args...> fmt, Args&&... args);
  template<class Out, class... Args>
    Out format_to(Out out, wformat_string<Args...> fmt, Args&&... args);
  template<class Out, class... Args>
    Out format_to(Out out, const locale& loc, format_string<Args...> fmt, Args&&... args);
  template<class Out, class... Args>
    Out format_to(Out out, const locale& loc, wformat_string<Args...> fmt, Args&&... args);

  template<class Out>
    Out vformat_to(Out out, string_view fmt, format_args args);
  template<class Out>
    Out vformat_to(Out out, wstring_view fmt, wformat_args args);
  template<class Out>
    Out vformat_to(Out out, const locale& loc, string_view fmt, format_args args);
  template<class Out>
    Out vformat_to(Out out, const locale& loc, wstring_view fmt, wformat_args args);

  template<class Out> struct format_to_n_result {
    Out out;
    iter_difference_t<Out> size;
  };
  template<class Out, class... Args>
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                        format_string<Args...> fmt, Args&&... args);
  template<class Out, class... Args>
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                        wformat_string<Args...> fmt, Args&&... args);
  template<class Out, class... Args>
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                        const locale& loc, format_string<Args...> fmt,
                                        Args&&... args);
  template<class Out, class... Args>
    format_to_n_result<Out> format_to_n(Out out, iter_difference_t<Out> n,
                                        const locale& loc, wformat_string<Args...> fmt,
                                        Args&&... args);

  template<class... Args>
    size_t formatted_size(format_string<Args...> fmt, Args&&... args);
  template<class... Args>
    size_t formatted_size(wformat_string<Args...> fmt, Args&&... args);
  template<class... Args>
    size_t formatted_size(const locale& loc, format_string<Args...> fmt, Args&&... args);
  template<class... Args>
    size_t formatted_size(const locale& loc, wformat_string<Args...> fmt, Args&&... args);

  // 
  template<class T, class CharT = char> struct formatter;

  //  
  template<class T, class CharT>
    concept formattable = /*   */;

  template<class R, class CharT>
    concept __const_formattable_range =                            //   
      ranges::input_range<const R> &&
      formattable<ranges::range_reference_t<const R>, CharT>;

  template<class R, class CharT>
    using __fmt_maybe_const =                                      //   
      conditional_t<__const_formattable_range<R, CharT>, const R, R>;

  //   basic_format_parse_context
  template<class CharT> class basic_format_parse_context;
  using format_parse_context = basic_format_parse_context<char>;
  using wformat_parse_context = basic_format_parse_context<wchar_t>;

  //  
  //   format_kind
  enum class range_format {
    disabled,
    map,
    set,
    sequence,
    string,
    debug_string
  };

  template<class R>
    constexpr /*  */ format_kind = /*  */;

  template<ranges::input_range R>
      requires same_as<R, remove_cvref_t<R>>
    constexpr range_format format_kind<R> = /*   */;

  //   range_formatter
  template<class T, class CharT = char>
    requires same_as<remove_cvref_t<T>, T> && formattable<T, CharT>
  class range_formatter;

  //   __range_default_formatter
  template<range_format K, ranges::input_range R, class CharT>
    struct __range_default_formatter;                              //   

  //   ,   
  template<ranges::input_range R, class CharT>
    requires (format_kind<R> != range_format::disabled) &&
             formattable<ranges::range_reference_t<R>, CharT>
  struct formatter<R, CharT> : __range_default_formatter<format_kind<R>, R, CharT> { };

  // 
  //   basic_format_arg
  template<class Context> class basic_format_arg;

  template<class Visitor, class Context>
    decltype(auto) visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);

  //   __format_arg_store
  template<class Context, class... Args> class __format_arg_store; //   

  template<class Context = format_context, class... Args>
    __format_arg_store<Context, Args...>
      make_format_args(Args&&... fmt_args);
  template<class... Args>
    __format_arg_store<wformat_context, Args...>
      make_wformat_args(Args&&... args);

  //  format_error
  class format_error;
}

namespace std {
  template<class CharT, class... Args>
  struct basic_format_string {
  private:
    basic_string_view<CharT> str;         //   

  public:
    template<class T> consteval basic_format_string(const T& s);

    constexpr basic_string_view<CharT> get() const noexcept { return str; }
  };
}

template<class T, class CharT>
  concept formattable =
    semiregular<formatter<remove_cvref_t<T>, CharT>> &&
    requires(formatter<remove_cvref_t<T>, CharT> f,
             const formatter<remove_cvref_t<T>, CharT> cf,
             T t,
             basic_format_context<__fmt_iter_for<CharT>, CharT> fc,
             basic_format_parse_context<CharT> pc) {
        { f.parse(pc) } -> same_as<basic_format_parse_context<CharT>::iterator>;
        { cf.format(t, fc) } -> same_as<__fmt_iter_for<CharT>>;
    };

namespace std {
  template<class CharT>
  class basic_format_parse_context {
  public:
    using char_type = CharT;
    using const_iterator = typename basic_string_view<CharT>::const_iterator;
    using iterator = const_iterator;

  private:
    iterator begin_;                                    //   
    iterator end_;                                      //   
    enum indexing { unknown, manual, automatic };       //   
    indexing indexing_;                                 //   
    size_t next_arg_id_;                                //   
    size_t num_args_;                                   //   

  public:
    constexpr explicit basic_format_parse_context(basic_string_view<CharT> fmt,
                                                  size_t num_args = 0) noexcept;
    basic_format_parse_context(const basic_format_parse_context&) = delete;
    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;

    constexpr const_iterator begin() const noexcept;
    constexpr const_iterator end() const noexcept;
    constexpr void advance_to(const_iterator it);

    constexpr size_t next_arg_id();
    constexpr void check_arg_id(size_t id);

    template<class... Ts>
    constexpr void check_dynamic_spec(size_t id) noexcept;
    constexpr void check_dynamic_spec_integral(size_t id) noexcept;
    constexpr void check_dynamic_spec_string(size_t id) noexcept;
  };
}

namespace std {
  template<class Out, class CharT>
  class basic_format_context {
    basic_format_args<basic_format_context> args_;      //   
    Out out_;                                           //   

  public:
    using iterator = Out;
    using char_type = CharT;
    template<class T> using formatter_type = formatter<T, CharT>;

    basic_format_arg<basic_format_context> arg(size_t id) const noexcept;
    std::locale locale();

    iterator out();
    void advance_to(iterator it);
  };
}

template<ranges::input_range R>
    requires same_as<R, remove_cvref_t<R>>
  constexpr range_format format_kind<R> = /*   */;

namespace std {
  template<class T, class CharT = char>
    requires same_as<remove_cvref_t<T>, T> && formattable<T, CharT>
  class range_formatter {
    formatter<T, CharT> underlying_;                        //   
    basic_string_view<CharT> separator_ =                   //   
      __STATICALLY_WIDEN<CharT>(", ");
    basic_string_view<CharT> __opening_bracket_ =           //   
      __STATICALLY_WIDEN<CharT>("[");
    basic_string_view<CharT> __closing_bracket_ =           //   
      __STATICALLY_WIDEN<CharT>("]");

  public:
    constexpr void set_separator(basic_string_view<CharT> sep);
    constexpr void set_brackets(basic_string_view<CharT> opening,
                                basic_string_view<CharT> closing);
    constexpr formatter<T, CharT>& underlying() { return underlying_; }
    constexpr const formatter<T, CharT>& underlying() const { return underlying_; }

    template<class ParseContext>
      constexpr typename ParseContext::iterator
        parse(ParseContext& ctx);

    template<ranges::input_range R, class FormatContext>
        requires formattable<ranges::range_reference_t<R>, CharT> &&
                 same_as<remove_cvref_t<ranges::range_reference_t<R>>, T>
      typename FormatContext::iterator
        format(R&& r, FormatContext& ctx) const;
  };
}

namespace std {
  template<ranges::input_range R, class CharT>
  struct __range_default_formatter<range_format::sequence, R, CharT> {
  private:
    using __maybe_const_r = __fmt_maybe_const<R, CharT>;
    range_formatter<remove_cvref_t<ranges::range_reference_t<__maybe_const_r>>,
                    CharT> underlying_;       //   

  public:
    constexpr void set_separator(basic_string_view<CharT> sep);
    constexpr void set_brackets(basic_string_view<CharT> opening,
                                basic_string_view<CharT> closing);

    template<class ParseContext>
      constexpr typename ParseContext::iterator
        parse(ParseContext& ctx);

    template<class FormatContext>
      typename FormatContext::iterator
        format(__maybe_const_r& elems, FormatContext& ctx) const;
  };
}

namespace std {
  template<ranges::input_range R, class CharT>
  struct __range_default_formatter<range_format::map, R, CharT> {
  private:
    using __maybe_const_map = __fmt_maybe_const<R, CharT>;          //   
    using __element_type =                                          //   
      remove_cvref_t<ranges::range_reference_t<__maybe_const_map>>;
    range_formatter<__element_type, CharT> underlying_;             //   
  public:
    constexpr __range_default_formatter();

    template<class ParseContext>
      constexpr typename ParseContext::iterator
        parse(ParseContext& ctx);

    template<class FormatContext>
      typename FormatContext::iterator
        format(__maybe_const_map& r, FormatContext& ctx) const;
  };
}

namespace std {
  template<ranges::input_range R, class CharT>
  struct __range_default_formatter<range_format::set, R, CharT> {
  private:
    using __maybe_const_set = __fmt_maybe_const<R, CharT>;          //   
    range_formatter<remove_cvref_t<ranges::range_reference_t<__maybe_const_set>>,
                    CharT> underlying_;                             //   
  public:
    constexpr __range_default_formatter();

    template<class ParseContext>
      constexpr typename ParseContext::iterator
        parse(ParseContext& ctx);

    template<class FormatContext>
      typename FormatContext::iterator
        format(__maybe_const_set& r, FormatContext& ctx) const;
  };
}

namespace std {
  template<range_format K, ranges::input_range R, class CharT>
    requires (K == range_format::string || K == range_format::debug_string)
  struct __range_default_formatter<K, R, CharT> {
  private:
    formatter<basic_string<CharT>, CharT> underlying_;              //   

  public:
    template<class ParseContext>
      constexpr typename ParseContext::iterator
        parse(ParseContext& ctx);

    template<class FormatContext>
      typename FormatContext::iterator
        format(/*   */& str, FormatContext& ctx) const;
  };
}

namespace std {
  template<class Context>
  class basic_format_arg {
  public:
    class handle;

  private:
    using char_type = typename Context::char_type;                  //   

    variant<monostate, bool, char_type,
            int, unsigned int, long long int, unsigned long long int,
            float, double, long double,
            const char_type*, basic_string_view<char_type>,
            const void*, handle> value;                             //   

    template<class T> explicit basic_format_arg(T&& v) noexcept;    //   
    explicit basic_format_arg(float n) noexcept;                    //   
    explicit basic_format_arg(double n) noexcept;                   //   
    explicit basic_format_arg(long double n) noexcept;              //   
    explicit basic_format_arg(const char_type* s);                  //   

    template<class traits>
      explicit basic_format_arg(
        basic_string_view<char_type, traits> s) noexcept;           //   

    template<class traits, class Allocator>
      explicit basic_format_arg(
        //   
        const basic_string<char_type, traits, Allocator>& s) noexcept;

    explicit basic_format_arg(nullptr_t) noexcept;                  //   

    template<class T>
      explicit basic_format_arg(T* p) noexcept;                     //   

  public:
    basic_format_arg() noexcept;

    explicit operator bool() const noexcept;

    template<class Visitor>
      decltype(auto) visit(this basic_format_arg arg, Visitor&& vis);
    template<class R, class Visitor>
      R visit(this basic_format_arg arg, Visitor&& vis);
  };
}

namespace std {
  template<class Context>
  class basic_format_arg<Context>::handle {
    const void* ptr_;                                           //   
    void (*format_)(basic_format_parse_context<char_type>&,
                    Context&, const void*);                     //   

    template<class T> explicit handle(T&& val) noexcept;        //   

    friend class basic_format_arg<Context>;                     //   

  public:
    void format(basic_format_parse_context<char_type>&, Context& ctx) const;
  };
}

namespace std {
  template<class Context, class... Args>
  class __format_arg_store {                                    //   
    array<basic_format_arg<Context>, sizeof...(Args)> args;     //   
  };
}

namespace std {
  template<class Context>
  class basic_format_args {
    size_t size_;                               //   
    const basic_format_arg<Context>* data_;     //   

  public:
    basic_format_args() noexcept;

    template<class... Args>
      basic_format_args(const __format_arg_store<Context, Args...>& store) noexcept;

    basic_format_arg<Context> get(size_t i) const noexcept;
  };
}

namespace std {
  template<class CharT, formattable<CharT>... Ts>
  struct formatter<__pair_or_tuple<Ts...>, CharT> {
  private:
    tuple<formatter<remove_cvref_t<Ts>, CharT>...> underlying_;     //   
    basic_string_view<CharT> separator_ =                           //   
      __STATICALLY_WIDEN<CharT>(", ");
    basic_string_view<CharT> opening_bracket_ =                     //   
      __STATICALLY_WIDEN<CharT>("(");
    basic_string_view<CharT> closing_bracket_ =                     //   
      __STATICALLY_WIDEN<CharT>(")");

  public:
    constexpr void set_separator(basic_string_view<CharT> sep);
    constexpr void set_brackets(basic_string_view<CharT> opening,
                                basic_string_view<CharT> closing);

    template<class ParseContext>
      constexpr typename ParseContext::iterator
        parse(ParseContext& ctx);

    template<class FormatContext>
      typename FormatContext::iterator
        format(/*   */& elems, FormatContext& ctx) const;
  };
}

namespace std {
  class format_error : public runtime_error {
  public:
    explicit format_error(const string& what_arg);
    explicit format_error(const char* what_arg);
  };
}