Fix join for specific types (#1981)

[kamibo]

Try to apply the same rules for iterator value type (join) as for
regular types.

Try to convert iterator value type to a formattable one.
For instance if the join operation refers to an enum class iterator
(such as std::byte) then try to use the enum class underlying type.

Also try to use a fallback formatter if available.

I agree that my contributions are licensed under the {fmt} license, and agree to future changes to the licensing.

[kamibo]

This is definitely not so nice.
Also TBH I'm not sure that using FMT_BUFFER_CONTEXT is correct here.

[vitaut]

Thanks for the PR.

You shouldn't be changing the formatter specialization for arg_join. Instead it's enough to add a formatter specialization for byte using FORMAT_AS here: https://github.com/fmtlib/fmt/blob/master/include/fmt/format.h#L3521 and add a cast in the implementation of FORMAT_AS.

[kamibo]

I agree that it would fix the std::byte issue.
However it would not fix "similar issues".
Don't you think it would be nice to treat range value type the same way as "simple type"?
Ok let's take the std::byte issue from #1981, this is what I've understood so far:

fmt::print("{}", std::byte(42));

This works because of the conversion done here

fmt/include/fmt/core.h

Line 1229 in 3f4839c

return map(static_cast<typename std::underlying_type<T>::type>(val));

However

std::vector<std::byte> vv;

fmt::print("{}", fmt::join(vv, ","));

This does not work because no conversion occurs.
Here is the type used

fmt/include/fmt/format.h

Line 3679 in 3f4839c

: formatter<typename std::iterator_traits<It>::value_type, Char> {

Am I missing something?

So I tried to apply the same conversion.
I agree that while it works, it is not satisfying but it solves "all the cases".

[vitaut]

Conversion is just an implementation detail. The current way of detecting if type is formattable is to check has_formatter which in turn checks formatter specializations. I don't think it's necessary to change that. formatter specialization for byte is useful anyway and adding it makes byte work with join and any other adapter.

[kamibo]

I'm sorry but I feel quiet confused.
The issue is beyond std::byte.
It does not work regarding conversion issue and also it is not work with any "fallback formatter" (ostream).
For instance, in the code I work on, we have this:

struct RouteWithEvents
{
   ...
};

inline std::ostream& operator<<(std::ostream& os, const RouteWithEvents& route_with_events)
{
  return os << fmt::format("RouteWithEvents(Route: {}: {})", route_with_events.route, route_with_events.events_on_route);
}

using RoutesWithEvents = std::vector<RouteWithEvents>;

inline std::ostream& operator<<(std::ostream& os, const RoutesWithEvents& routes_with_events)
{
  return os << fmt::format("RoutesWithEvents({})", fmt::join(routes_with_events, ", "));
} 

Unless I missed something, this just doesn't work since 6.0.0 version while it works nicely with the previous version (5.3.0).
Do you consider this is not an issue?

[vitaut]

Do you consider this is not an issue?

I'm OK with adding support for fallback formatter to join but it should be done via has_fallback_formatter.

[vitaut]

Closing this in favor of std::byte-specific change: 4a6eadb.

[kamibo]

Ok Thanks for your answer @vitaut!