#include <concepts>
#include <type_traits>

struct Thing
{
    Thing() = default;
    Thing(const Thing&) = default;

#ifdef REQUIRES_AFTER_TEMPLATE
    // Works (expected)
    template <typename T>
    requires (!std::is_same_v<T, Thing> && std::copy_constructible<T>)
    Thing(const T& /*t*/)
#else
    // Does NOT work (UNEXPECTED)
    // Conjunction short-circuit does not
    // seem to happen correctly:
    // https://en.cppreference.com/w/cpp/language/constraints#Conjunctions
    template <typename T>
    Thing(const T& /*t*/)
    requires (!std::is_same_v<T, Thing> && std::copy_constructible<T>)
#endif
    {}
};


void test(int a)
{
    auto thing = Thing(a);

    // This one breaks, when checking if
    // `Thing` models `std::copy_constructible`, because
    // the compiler tries to check
    // if the possibly-copy-constructor is a valid
    // copy constructor, which leads to checking
    // its constraints, therefore checking `std::copy_constructible` again,
    // which leads to infinite recursion
    [[maybe_unused]] auto thing_of_thing = Thing(thing);
}

#include <concepts>
#include <type_traits>

template <typename T>
struct Empty
{};

template <typename T>
constexpr bool breaks_if_instantiated = Empty<T>::value;

struct Thing
{
    Thing() = default;
    
#ifdef REQUIRES_AFTER_TEMPLATE
    // Works (expected)
    template <typename T>
    requires (!std::is_same_v<T, Thing> && breaks_if_instantiated<T>)
    Thing(const T& /*t*/)
#else
    // Works (expected)
    template <typename T>
    Thing(const T& /*t*/)
    requires (!std::is_same_v<T, Thing> && breaks_if_instantiated<T>)
#endif
    {}
};


void test(int a)
{
    // Breaks (expected)
    //auto thing_with_int = Thing(a);

    Thing thing{};

    [[maybe_unused]] auto thing_with_thing = Thing(thing);
}