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

[GuillaumeDua]

Dependencies

• Parts: [ag] fmt::formatter view composition #262 , [ag] fmt::formatter-s factory #263
• Closes [ag] io: format/to_string : compact vs. pretty #57

---

Pocs

• [ag] remove gcl coupling and injections #135
• opt-in for iostream, fmt (in a similar way to ensure)
• fmt::formatter : use range/tuple (depends on [ag] tuple-like interface compliance: std::get<T> ? #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 */;

csl::ag::io::join<opt_ins...>(value , presentation);

// vs.
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