Ambiguous formatter<std::optional<T>> between fmt/std.h and fmt/ranges.h on C++26 (P3168R2)

[indiosmo]

With C++26 std::optional range support, including both <fmt/std.h> and <fmt/ranges.h> fails with ambiguous template instantiation.

Environment

• fmt 12.1.0 (also reproduces on current master at the time of writing)
• GCC 16.1.0, libstdc++ (ships P3168R2)
• -std=c++26
• Linux x86_64

Reproduction

#include <optional>
#include <string>

#include <fmt/format.h>
// commenting either works.
// ranges prints: ["hi"] []
// std prints: optional("hi") none
#include <fmt/ranges.h>
#include <fmt/std.h>

int main() {
  std::optional<std::string> some{"hi"};
  std::optional<std::string> none{};
  fmt::print("{} {}\n", some, none);
}

[indiosmo]

The way I solved it at least for now is by explicitly forcing range_format::disabled for std::optional, as I don't have a use case for formatting it as a range.

FMT_BEGIN_NAMESPACE

template <typename T, typename Char>
struct range_format_kind<std::optional<T>, Char> : std::integral_constant<range_format, range_format::disabled>
{
};

FMT_END_NAMESPACE

I suppose the solution at the library level first needs a design decision as to whether you want to support optional through ranges at all.

I would argue that it should stay in fmt/std.h and disabling it in fmt/ranges.h specifically keeps the behavior unchanged from previous versions and is the semantics users would expect from optional vs ["value"] and [].

[indiosmo]

I think there's a stronger argument for picking one,.
I'm going to try this now, but I suppose we could construct code in a way where we silently get the same struct serializing in two different ways if we have two separate TUs each including either fmt/std.h or fmt/ranges.h and returning a string with the serialized struct.

[indiosmo]

Ok, so not two different ways, but we now get link order dependent behavior.
If we have two TUs, each including one of the fmt headers, the one that gets linked first is the one that gets used, so still a very surprising behavior as the TU including fmt/std.h will serialize as range and vice-versa.

CMakeLists.txt

add_executable(sandbox
  main.cpp
  # flip the order here and you get std output
  serialize_with_ranges.cpp
  serialize_with_std.cpp
)

target_link_libraries(sandbox
  PRIVATE
    fmt::fmt
)

main.cpp

#include <optional>
#include <string>

#include <fmt/format.h>

#include "serialize_with_ranges.hpp"
#include "serialize_with_std.hpp"

int main()
{
  std::optional<std::string> some{"hi"};
  std::optional<std::string> none{};

  fmt::print("serialize_with_std:    some={} none={}\n", serialize_with_std(some), serialize_with_std(none));
  fmt::print("serialize_with_ranges: some={} none={}\n", serialize_with_ranges(some), serialize_with_ranges(none));

  return 0;
}

Serialize with ranges TU

Header

#pragma once

#include <optional>
#include <string>

// Implementation TU includes <fmt/ranges.h>.
std::string serialize_with_ranges(const std::optional<std::string>& value);

Cpp

#include "serialize_with_ranges.hpp"

#include <fmt/format.h>
#include <fmt/ranges.h>

std::string serialize_with_ranges(const std::optional<std::string>& value)
{
  return fmt::format("{}", value);
}

Serialize with std TU

Header

#pragma once

#include <optional>
#include <string>

// Implementation TU includes <fmt/std.h>.
std::string serialize_with_std(const std::optional<std::string>& value);

cpp

#include "serialize_with_std.hpp"

#include <fmt/format.h>
#include <fmt/std.h>

std::string serialize_with_std(const std::optional<std::string>& value)
{
  return fmt::format("{}", value);
}

Output

[2/2] Linking CXX executable sandbox/sandbox
using compdb
---------------
running sandbox
---------------

serialize_with_std:    some=["hi"] none=[]
serialize_with_ranges: some=["hi"] none=[]

[phprus]

Possible fix: #4761

[indiosmo]

Possible fix: #4761

Sorry I was already working on a PR #4762

#4761 putting it in is_range seems maybe to broad, and with the optional_like trait might trigger for unintended types as well.
I've also tried to follow the style from fmt/std.h with the guards and the feature test macros, and be as specific as possible as to only disable std::optional.

This works now

#include <optional>
#include <string>
#include "fmt/std.h"
#include "fmt/ranges.h"
#include "fmt/base.h"

int main()
{
  std::optional<std::string> some{"hi"};
  std::optional<std::string> none{};

  fmt::print("serialize_with_std:    some={} none={}\n", some, none);

  return 0;
}

using compdb
---------------
running sandbox
---------------

serialize_with_std:    some=optional("hi") none=none