std:: semiregular

#include <concepts>
#include <iostream>
template<std::semiregular T>
// Crédito Alexander Stepanov
// los conceptos son requisitos sobre T
// Requisito sobre T: T es semiregular
// T a(b); o T a = b; => constructor de copia
// T a; => constructor por defecto
// a = b; => asignación
struct Single
{
    T value;
    // La inicialización por agregación para Single se comporta como el siguiente constructor:
    // explicit Single(const T& x) : value(x) {}
    // Las funciones miembro especiales declaradas implícitamente se comportan como las siguientes definiciones,
    // excepto que pueden tener propiedades adicionales:
    // Single(const Single& x) : value(x.value) {}
    // Single() {}
    // ~Single() {}
    // Single& operator=(const Single& x) { value = x.value; return *this; }
    // el operador de comparación no está definido; no es requerido por el concepto `semiregular`
    // bool operator==(Single const& other) const = delete;
};
void print(std::semiregular auto x)
{
    std::cout << x.value << '\n';
}
int main()
{
    Single<int> myInt1{4};      // inicialización por agregación: myInt1.value = 4
    Single<int> myInt2(myInt1); // constructor de copia
    Single<int> myInt3;         // constructor por defecto
    myInt3 = myInt2;            // operador de asignación por copia
//  myInt1 == myInt2;           // Error: operator== no está definido
    print(myInt1); // ok: Single<int> es un tipo `semiregular`
    print(myInt2);
    print(myInt3);
}   // Las variables Single<int> se destruyen aquí