[ag] better format, print + as opt-in

[GuillaumeDua]

Dependencies

• Parts: #262 , #263
• Closes #57

---

Pocs

• 135

• [x] opt-in for iostream, fmt (in a similar way to ensure)
• fmt::formatter : use range/tuple (depends on #131 )
  • using type wrapper for indent informations ? -> template-types instanciation bloat
  • using value wrapper ?
  • using styled/view propagation ? -> formatter depends on itself
  • using views combination
  • somehow a range-of-tuplelike support
  • using template-specialized indented view
  • WIP: style/parse propagation
    • sub-contextes -> format depends on tuple-size (poor API)

---

📘💡Design

API:

csl::ag::concepts::aggregate auto value = /* some aggregate value */;

// 1: express intent: parse is "how", join is "what"
fmt::println("{indented}", csl::ag::io::join(value));
fmt::println("{indexed,indented}", csl::ag::io::join(value));
fmt::println("{indexed,typenamed,indented}", csl::ag::io::join(value));
fmt::println("{indexed,typenamed,compact}", csl::ag::io::join(value));

// 2: vs. join is "how" + "what"
fmt::println("{}",   csl::ag::io::join<opt_ins...>(value));
fmt::println("{:n}", csl::ag::io::join<opt_ins...>(value)); // none
fmt::println("{:c}", csl::ag::io::join<opt_ins...>(value)); // compact => clash with indented

// 3: vs. same as 2, with opt-in presentation/style
csl::ag::io::join<opt_ins...>(value, presentation);

// 4: vs. "how" + "what" as view composition
fmt::println("{}", csl::ag::io::join<presentation::indented>(value));
fmt::println("{}", value | join<presentation::indented>);
fmt::println("{}", value | indexed | typenamed | join<presentation>);

Call: split formatting style and join_view, see #262 , #263

• formatting style : produces opening/closing bracket, separator
  • none
  • compact
  • indented
• join_view composition => delegated formatters modifiers (formatters of proxy types)

📘💡 Back to design:

• using parse to pick a strategy
  • WIP, working
  • With typenamed, indented
  • ✅ LGTM as an MVP -> ok-ish (clang >= 19 only)
  • yet, should be improved with view composition
  • gcc-13.1 ok - but requires constexpr variants ... (clang >= 19)
  • depth as compile-time argument: https://godbolt.org/z/aja6cTqa6

📘💡Back to design (2):

• runtime formatting: https://godbolt.org/z/13sx9zv3P (requires constexpr std::variant)
• compile-time formatting : https://godbolt.org/z/7Ec3ez7d1
  • triggers Clang >= 18 error definition with same mangled name see the version here with csl::ag instead of std::tuples
• ✅ depth as template argument: https://godbolt.org/z/3hdaEGcjf
  • larger/earlier compiler support
• ✅ depth decorator: https://godbolt.org/z/sdG5ccsvj, with universal tuple/aggregate API
  • with default formatter: https://godbolt.org/z/GEK98zT5h

Implementation design:

// simple formatter
struct fmt::formatter<csl::ag::concepts::aggregate>{}; // parse {} or {:n}
struct fmt::formatter<join_view<csl::ag::concepts::aggregate>>{};

template <std::size_t depth> struct presentation_factory; // -> as tttp
fmt::println("value = {}", csl::ag::io::join<presentation::indented>(value))

// indexed<T> -> std::index_sequence<csl::ag::size_v | std::tuple_size_v>, or std::views::enumerate
// typenamed<T> - with detection not T::csl_ag_io_product

fmt::println("value = {}", csl::ag::io::join<presentation::indented>(
   indexed{ typenamed { value } }
))
fmt::println("{}", value | indexed | typenamed | join<presentation>)

---

Recursive lambda quick impl:

 const auto printer = overload{
      [](const auto & self, std::size_t depth, const csl::ag::concepts::aggregate auto & value){
          fmt::println("{:\t>{}}{{", "", depth);
          using type = std::remove_cvref_t<decltype(value)>;
          [&]<std::size_t ... indexes>(std::index_sequence<indexes...>){
              ((std::invoke(
                  self,
                  self, depth + 1, csl::ag::get<indexes>(value)
              ), ...));
          }(std::make_index_sequence<csl::ag::size_v<type>>{});
          fmt::println("{:\t>{}}}}", "", depth);
      },
      [](const auto & /* self */, std::size_t depth, const auto & value){
          fmt::println("{:\t>{}}{}", "", depth, value);
      }
  };

  printer(printer, 0, value);

---

💡 Ideas

💡 views composition join_view<strategies...>

see #262

struct A{ int i; };
struct B{ A a; char c; }

csl::ag::join_view<typenamed, indented /*etc...*/>(B{}, ",");

💡 Idea : flatten,rewrap<T is aggregate ? view<aggregate> : T>

see #263

[GuillaumeDua]

Reopen, as not fully completed in #241 / #233