This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of C++23 status.

3746. optional's spaceship with U with a type derived from optional causes infinite constraint meta-recursion

Section: 22.5.8 [optional.comp.with.t] Status: C++23 Submitter: Ville Voutilainen Opened: 2022-07-25 Last modified: 2023-11-22

Priority: Not Prioritized

View all other issues in [optional.comp.with.t].

View all issues with C++23 status.

Discussion:

What ends up happening is that the constraints of operator<=>(const optional<T>&, const U&) end up in three_way_comparable_with, and then in partially-ordered-with, and the expressions there end up performing a conversion from U to an optional, and we end up instantiating the same operator<=> again, evaluating its constraints again, until the compiler bails out.

See an online example here.

All implementations end up with infinite meta-recursion.

The solution to the problem is to stop the meta-recursion by constraining the spaceship with U so that U is not publicly and unambiguously derived from a specialization of optional, SFINAEing that candidate out, and letting 22.5.6 [optional.relops]/20 perform the comparison instead.

[2022-08-23; Reflector poll]

Set status to Tentatively Ready after five votes in favour during reflector poll.

[2022-11-12 Approved at November 2022 meeting in Kona. Status changed: Voting → WP.]

Proposed resolution:

This wording is relative to N4910.

[Drafting note: This proposed wording removes the only use of is-optional. ]

  1. Modify 22.5.2 [optional.syn], header <optional> synopsis, as indicated:

    […]
    namespace std {
      // 22.5.3 [optional.optional], class template optional
      template<class T>
        class optional;
    
      template<class T>
        constexpr bool is-optional = false; // exposition only
      template<class T>
        constexpr bool is-optional<optional<T>> = true; // exposition only
      template<class T>
        concept is-derived-from-optional = requires(const T& t) { // exposition only
          []<class U>(const optional<U>&){ }(t);
        };
      […]
      // 22.5.8 [optional.comp.with.t], comparison with T
      […]
      template<class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
      template<class T, class U> requires (!is-derived-from-optional<U>) && three_way_comparable_with<T, U>
        constexpr compare_three_way_result_t<T, U>
          operator<=>(const optional<T>&, const U&);
      […]
    }
    
  2. Modify 22.5.8 [optional.comp.with.t] as indicated:

    template<class T, class U> requires (!is-derived-from-optional<U>) && three_way_comparable_with<T, U>
      constexpr compare_three_way_result_t<T, U>
        operator<=>(const optional<T>&, const U&);
    

    -25- Effects: Equivalent to: return x.has_value() ? *x <=> v : strong_ordering::less;