resultado de std.algorithm.map

Se supone que no debes saber o preocuparte por lo que std.algorithm.map vuelve más allá de que se trata de un rango del mismo género que el pasado (forward, bidireccional, aleatorio, etc.). Es así con la mayoría de las funciones basadas en rango. Casi siempre devuelven un nuevo rango que envuelve el que se pasó o exactamente el mismo tipo de rango que se pasó (por ejemplo, map hace lo primero; find hace esto último). Utilizar auto:

ulong[] x = [1, 2, 3];
auto y = map!"a"(x);

El rango devuelto por map es perezoso. No hace nada hasta que itera sobre él (luego llama a la función dada en cada sucesiva front del rango subyacente). Es más eficiente de esa manera (además de permitir rangos infinitos). El tipo de retorno exacto depende del tipo de rango que pasó y es local para map para que no puedas crear uno directamente. Necesitas usar auto inferir el tipo o typeof para obtener el tipo:

typeof(map!"a"(x)) y = map!"a"(x);

Sin embargo, generalmente solo usas typeof cuando necesita una variable que no puede inicializar directamente. auto es casi siempre el camino a seguir.

Si necesita crear una matriz a partir del resultado de map (o de cualquier otro rango), luego use std.array.array:

ulong[] y = array(map!"a"(x));

Si no sabes mucho sobre rangos, probablemente deberías leer este. Desafortunadamente, actualmente no hay un artículo en dlang.org que explique los rangos, pero ese enlace es para un capítulo en un libro que uno de los miembros de la comunidad D escribió en turco y ha estado traduciendo al inglés, y cubre rangos bastante bien.

EDITAR:

Walter Bright escribió recientemente un artículo específicamente sobre los tipos que son locales para una función pero devueltos por la función que también puede ayudarlo. Incluso tienen un nombre genial: Voldemort Types in D.

El rango de resultados es 'perezoso', no representa el resultado final.

Se puede convertir en una matriz si importa std.array y la envuelve así:

ulong[] y = array(std.algorithm.map!"a"(x));

or

ulong[] y = std.algorithm.map!"a"(x).array;

si está utilizando dmd 2.059 o posterior

El resultado del mapa también se puede iterar directamente con foreach:

auto result = std.algorithm.map!"a"(x);
foreach (element; result)
  writeln(to!string(element));

Result es un tipo dentro map() que no se puede nombrar porque es un Tipo Voldemort.

El actual código fuente en Fobos se ve algo como esto:

template map(fun...) if (fun.length >= 1)
{
    auto map(Range)(Range r) if (isInputRange!(Unqual!Range))
    {
        //...
        struct Result
        {
            //...
        }
        return Result(r);
    }
}

Si estudias el código fuente notarás que Result no es más que un rango: tiene el habitual popFront() y empty() métodos y otros métodos según el tipo de rango que se deba devolver. Si utiliza la inferencia de tipos,

auto r = map!("a*a")(data);

r se escribirá como Result, pero no puedes instanciarlo directamente.