(Preámbulo: Soy un seguidor tardío del juego C ++ 0x y la reciente controversia sobre la eliminación de conceptos del estándar C ++ 0x me ha motivado a aprender más sobre ellos. Si bien comprendo que todas mis preguntas son completamente hipotéticas, en la medida en que los conceptos no serán válidos en C ++ por algún tiempo, en todo caso, todavía estoy interesado en aprender más sobre los conceptos, especialmente teniendo en cuenta cómo ayudaría. Entiendo mejor los méritos detrás de la reciente decisión y la controversia que siguió.

Después de haber leído algunos materiales introductorios sobre conceptos, tal como C ++ 0x (hasta hace poco) los propuso, tengo problemas para comprender mis problemas sintácticos. Sin más preámbulos, aquí están mis preguntas:

1) ¿Un tipo que admita un concepto derivado particular (ya sea de forma implícita, a través de la palabra clave auto o explícitamente a través de concept_maps) también necesitaría soportar el concepto base de forma independiente? En otras palabras, ¿el acto de derivar un concepto de otro (por ejemplo,concept B<typename T> : A<T>) implícitamente incluir una declaración 'invisible' requiere (dentro de B,requires A<T>;)? La confusión surge de la página de Wikipedia sobre conceptos que declaran:

Al igual que en la herencia de clase, los tipos que cumplen los requisitos del concepto derivado también cumplen los requisitos del concepto básico.

Eso parece decir que un tipo solo necesita satisfacer los requisitos del concepto derivado y no necesariamente los requisitos del concepto base, lo que no tiene sentido para mí. Entiendo que Wikipedia está lejos de ser una fuente definitiva; ¿Es la descripción anterior simplemente una mala elección de palabras?

2) ¿Un concepto que enumera los nombres de tipo puede ser 'automático'? Si es así, ¿cómo asignaría el compilador estos nombres de tipo automáticamente? Si no es así, ¿hay otras ocasiones en las que no sería válido usar 'auto' en un concepto?

Para aclarar, considere el siguiente código hipotético:

template<typename Type>
class Dummy {};

class Dummy2 { public: typedef int Type; };

auto concept SomeType<typename T>
{
     typename Type;
}

template<typename T> requires SomeType<T>
void function(T t)
{}

int main()
{
    function(Dummy<int>()); //would this match SomeType?
    function(Dummy2()); //how about this?
    return 0;
}

¿Alguna de estas clases coincidiría con SomeType? ¿O es necesario un concept_map para los conceptos relacionados con nombres de tipos?

3) Finalmente, me cuesta mucho entender qué axiomas se permitirían definir. Por ejemplo, ¿podría tener un concepto que defina un axioma que sea lógicamente inconsistente, como

concept SomeConcept<typename T>
{
    T operator*(T&, int);

    axiom Inconsistency(T a)
    {
         a * 1 == a * 2;
    }
} 

¿Qué haría eso? ¿Es eso incluso válido?

Aprecio que este es un conjunto de preguntas muy largo y por eso le agradezco de antemano.