#include <array>
#include <iostream>
#include <string>

#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repeat_from_to.hpp>

struct
{
#define DEFINE_STRUCT_VISITOR_OPERATOR(_, N, __) \
   template <typename T, typename F> \
   requires requires{[](T&& t, F&& f) { \
      auto&& [BOOST_PP_ENUM_PARAMS(N, f_)] = t; \
      return f(BOOST_PP_ENUM_PARAMS(N, f_)); \
   };} \
   constexpr decltype(auto) operator()(T&& t, F&& f) const { \
      auto&& [BOOST_PP_ENUM_PARAMS(N, f_)] = t; \
      return f(BOOST_PP_ENUM_PARAMS(N, f_)); \
   }
   BOOST_PP_REPEAT_FROM_TO(1, 51, DEFINE_STRUCT_VISITOR_OPERATOR, )
#undef DEFINE_STRUCT_VISITOR_OPERATOR
} inline constexpr VisitStruct;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Use cases

// Formatted structure printing
decltype(auto) PrintStruct(auto&& o, const auto& t, const auto&...x)
{
   o << "{" << t;
   ((o << "," << x),...);
   o << "}";
   return o;
}

template <typename T, typename O>
concept PrintableStruct = requires (T t, O o) { VisitStruct(t, [&o](auto&&...x) {PrintStruct(o, x...); }); };

template <typename O>
O&& operator << (O&& o, const PrintableStruct<O> auto& t)
{
   VisitStruct(t, [&o](auto&&...x){PrintStruct(o, x...);});
   return std::forward<O>(o);
};

// Просто определяем структуру.
// Оператор вывова в поток определяется автоматически :)
struct Foo
{
   int i{};
   double d{};
   std::string s;
};

int main()
{
   // Структуры могут быть локальными и даже анонимными.
   // Структуры могут агрегировать другие структуры, массивы и кортежи
   struct
   {
      int a = 1, b = 2, c = 3;
      std::array<int, 3> a2 = {100, 200, 300};
      Foo a3[3] = {{42, 3.14, "Hello"}, {123, 2.71, "World"}, {555, 1.61, "Hello, World"}};
      struct
      {
         int i{};
         double d{};
         const char* s;
      } s = {777, 1.23, "C++20"};
   } bar;

   std::cout << bar << std::endl;
}