Metaprogramación en C++ y en D

Creo que nada está mejor calificado para mostrar el increíble poder (TM) del sistema de plantillas D que este renderizador que encontré hace años:

¡Sí! Esto es realmente lo que genera el compilador ... es el "programa", y bastante colorido, de hecho.

Editar

La fuente parece estar de vuelta en línea.

Los mejores ejemplos de metaprogramación D son los módulos de biblioteca estándar D que hacen un uso intensivo de ti frente a los módulos C++ Boost y STL. Echa un vistazo a D's std.intervalo, std.algoritmo, std.funcional y std.paralelismo . Ninguno de estos sería fácil de implementar en C++, al menos con el tipo de API limpia y expresiva que tienen los módulos D.

La mejor manera de aprender D metaprogramación, en mi humilde opinión, es por este tipo de ejemplos. Aprendí en gran parte leyendo el código a std.algoritmo y std.range, que fueron escritos por Andrei Alexandrescu (un gurú de la metaprogramación de plantillas C++ que se ha involucrado mucho con D). Luego usé lo que aprendí y contribuí con la ets.módulo de paralelismo.

También tenga en cuenta que D tiene evaluación de funciones en tiempo de compilación (CTFE) que es similar a C++1x constexpr pero mucho más general en que un subconjunto grande y creciente de funciones que pueden ser evaluadas en tiempo de ejecución pueden ser evaluadas sin modificar en tiempo de compilación. Esto es útil para la generación de código en tiempo de compilación, y el código generado se puede compilar usando string mixins.

Bien, en D puede imponer fácilmente restricciones estáticas en los parámetros de la plantilla y escribir código dependiendo del argumento de la plantilla real con static if.
Es posible simular eso para casos simples con C++ usando especialización de plantillas y otros trucos (ver boost) pero es un PITA y muy limitado porque el compilador no expone muchos detalles sobre los tipos.

Una cosa que C++ realmente no puede hacer es la sofisticada generación de código en tiempo de compilación.

Aquí hay un fragmento de código D que hace un map() personalizado que devuelve sus resultados por referencia.

Crea dos arrays de longitud 4, asignacada par correspondiente de elementos al elemento con el valor mínimo, y lo multiplica por 50, y almacena el resultado de nuevo en el array original.

Algunas características importantes a tener en cuenta son las siguientes:

• Las plantillas son variádicas: map() podría tomar cualquier número de argumento.

• El código es (relativamente) corto ! La estructura Mapper, que es la lógica central, es de solo 15 líneas yet y sin embargo puede hacer mucho con tan poco. Mi punto no es que esto sea imposible en C++, pero ciertamente no es tan compacto y limpio.

import std.metastrings, std.typetuple, std.range, std.stdio;

void main() {
    auto arr1 = [1, 10, 5, 6], arr2 = [3, 9, 80, 4];

    foreach (ref m; map!min(arr1, arr2)[1 .. 3])
        m *= 50;

    writeln(arr1, arr2); // Voila! You get:  [1, 10, 250, 6][3, 450, 80, 4]
}

auto ref min(T...)(ref T values) {
    auto p = &values[0];
    foreach (i, v; values)
        if (v < *p)
            p = &values[i];
    return *p;
}

Mapper!(F, T) map(alias F, T...)(T args) { return Mapper!(F, T)(args); }

struct Mapper(alias F, T...) {
    T src;  // It's a tuple!

    @property bool empty() { return src[0].empty; }

    @property auto ref front() {
        immutable sources = FormatIota!(q{src[%s].front}, T.length);
        return mixin(Format!(q{F(%s)}, sources));
    }

    void popFront() { foreach (i, x; src) { src[i].popFront(); } }

    auto opSlice(size_t a, size_t b) {
        immutable sliced = FormatIota!(q{src[%s][a .. b]}, T.length);
        return mixin(Format!(q{map!F(%s)}, sliced));
    }
}


// All this does is go through the numbers [0, len),
// and return string 'f' formatted with each integer, all joined with commas
template FormatIota(string f, int len, int i = 0) {
    static if (i + 1 < len)
        enum FormatIota = Format!(f, i) ~ ", " ~ FormatIota!(f, len, i + 1);
    else
        enum FormatIota = Format!(f, i);
}

Escribí mis experiencias con las plantillas de D, los mixins de cadenas y los mixins de plantillas: http://david.rothlis.net/d/templates /

Debería darte una idea de lo que es posible en D't No creo que en C++ puedas acceder a un identificador como una cadena, transformar esa cadena en tiempo de compilación y generar código a partir de la cadena manipulada.

Mi conclusión: Extremadamente flexible, extremadamente potente y utilizable por meros mortales, pero el compilador de referencia todavía es algo buggy cuando se trata de las cosas más avanzadas de metaprogramación en tiempo de compilación.

Manipulación de cadenas, incluso análisis de cadenas.

Esta es una biblioteca MP que genera analizadores decentes recursivos basados en gramáticas definidas en cadenas usando (más o menos) BNF. No lo he tocado en años, pero solía funcionar.

En D puede comprobar el tamaño de un tipo y los métodos disponibles en él y decidir qué implementación desea utilizar

Esto se usa por ejemplo en el core.atomic módulo

bool cas(T,V1,V2)( shared(T)* here, const V1 ifThis, const V2 writeThis ){
    static if(T.sizeof == byte.sizeof){
       //do 1 byte CaS
    }else static if(T.sizeof == short.sizeof){
       //do 2 byte CaS
    }else static if( T.sizeof == int.sizeof ){
       //do 4 byte CaS
    }else static if( T.sizeof == long.sizeof ){
       //do 8 byte CaS
    }else static assert(false);
}

Solo para contrarrestar el post de trazado de rayos D, aquí hay un trazador de rayos en tiempo de compilación de C++ (metatrace):

(por cierto, utiliza principalmente metaprogramación C++2003; sería más legible con los nuevos constexpr s)

Hay algunas cosas tranquilas que puede hacer en la metaprogramación de plantillas en D que no puede hacer en C++. Lo más importante es que usted puede hacer plantilla metaprogramación SIN TANTO DOLOR!