reimplement formatter<tuple_join_view>

[sunmy2019]

PR for #2451. I reimplemented that formatter.

It supports the following code: (Tested on clang12 and gcc11, for std=c++11/17/20)

    std::tuple<int, int, int, int> a{1, 1, -1, -1};
    fmt::print("{:+03}\n", fmt::join(a, ", "));
    fmt::print(FMT_STRING("{:-010}\n"), fmt::join(a, ", "));
    fmt::print(FMT_COMPILE("{:-010}\n"), fmt::join(a, ", "));

    std::tuple<int, long, unsigned, unsigned long> b{1, 1, -1, -1};
    fmt::print("{:010}\n", fmt::join(b, ", "));
    fmt::print(FMT_STRING("{:010}\n"), fmt::join(b, ", "));
    fmt::print(FMT_COMPILE("{:010}\n"), fmt::join(b, ", "));

    std::tuple<float, double, long double> c{1.1, 1.11, -1.111};
    fmt::print("{:3.6f}\n", fmt::join(c, ", "));

    std::tuple<> d;
    fmt::print("{}\n", fmt::join(d, ", "));

I add two functions parse_subroutine and format_subroutine as subroutines of parse and format, respectively.

I have no idea the best appropriate function name. It may need a change. Also the index_helper can be replaced by std::integral_constant.

This code is only a prototype to demostrate my ideas, and not in its best shape. Comments are welcome.

[vitaut]

Thanks for the PR!

I have no idea the best appropriate function name. It may need a change.

I suggest renaming parse_subroutine and format_subroutine to do_parse and do_format respectively which is a common pattern for helper functions like this.

Also the index_helper can be replaced by std::integral_constant.

Please do, replace index_helper with std::integral_constant.

[vitaut]

Thank you!

[cgmb]

Very cool.

[vitaut]

One potential optimization is to create one formatter per type instead of one formatter per tuple element. Then std::tuple<int, int, int, int> will only need one formatter and call to parse.

[sunmy2019]

One potential optimization is to create one formatter per type instead of one formatter per tuple element. Then std::tuple<int, int, int, int> will only need one formatter and call to parse.

This can be done with a lot of extra work, though. We basically need to

1. deduplicate the same types T.
2. find the correct formatter for each args.

I think this is possible with these technologies demonstrated below. https://godbolt.org/z/h41q9Wav5

// check whether T is in Ts...
template <typename T, typename... Ts>
struct appear : public std::integral_constant<bool, false> {};

template <typename T, typename T1, typename... Ts>
struct appear<T, T1, Ts...>
    : public std::integral_constant<
          bool, std::is_same<T, T1>::value ? true : appear<T, Ts...>::value> {};

// we need this helper function to unpack std::tuple
template <typename T, typename... Ts>
typename std::conditional<appear<T, Ts...>::value, std::tuple<Ts...>,
                          std::tuple<T, Ts...>>::type
    get_type(std::tuple<Ts...>);


// deduplicate to get std::tuple<...>
// for example:
// deduplicate<int, int, double, int>::type is std::tuple<double, int>
template <typename... Ts>
struct deduplicate {
  using type = std::tuple<>;
};

template <typename T, typename... Ts>
struct deduplicate<T, Ts...> {
  using type = decltype(get_type<T>(std::declval<typename deduplicate<Ts...>::type>()));
};

and for the second part

// get the index of a type from the tuple
template <typename T, typename... Ts>
struct get_index : public std::integral_constant<size_t, 0> {};

template <typename T, typename T1, typename... Ts>
struct get_index<T, T1, Ts...>
    : public std::integral_constant<
          size_t,
          std::is_same<T, T1>::value ? 0 : get_index<T, Ts...>::value + 1> {};

template <typename T, typename T1>
struct get_tuple_index;

template <typename T, typename... Ts>
struct get_tuple_index<T, std::tuple<Ts...>> {
  size_t value = get_index<T, Ts...>::value;
};

As for this, we also need to handle std::decay_t. I think it's technically possible. It remains only a design choice.