d是矩形.

​​原文​​

bool isRectangular(A)(A a) if (isArray!A)
    {
        size_t[] dummy;
        return isRectangular(a, dummy);
    }
    bool isRectangular(A)(A a, out size_t[] shape) if (isArray!A)
    {
        size_t first_length = a[0].length;
        foreach (e; a)
        {
            if (e.length != first_length) return false;
        }
        shape = [a.length, first_length];
        return true;
    }
    unittest
    {
        size_t[] shape;
        assert(isRectangular([[1, 2], [3, 4], [5, 6]], shape));
        assert(shape == [3, 2]);
        assert(!isRectangular([[1, 2], [], [3, 4]]));
    }

//一维数组

    bool isRectangular(A)(A a, out size_t[] shape) if (isArray!A)
    {
        shape = [a.length];
        alias E = typeof(a[0]);
        static if (isArray!E)
        {
            size_t first_length = a[0].length;
            shape ~= first_length;
            foreach (e; a)
            {
                if (e.length != first_length) return false;
            }
        }
        return true;
    }
    unittest /* one dimension */
    {
        size_t[] shape;
        assert(isRectangular([1, 2, 3], shape));
        assert(shape == [3]);
    }

//递归,

    bool isRectangular(A)(A a, out size_t[] shape) if (isArray!A)
    {
        shape = [a.length];
        alias E = typeof(a[0]);
        static if (isArray!E)
        {
            size_t[] first_shape;
            if (!isRectangular(a[0], first_shape)) return false;
            shape ~= first_shape;
            foreach (e; a)
            {
                size_t[] e_shape;
                if (!isRectangular(e, e_shape)) return false;
                if (e_shape != first_shape) return false;
            }
        }
        return true;
    }
    unittest /* higher dimensions */
    {
        size_t[] shape;
        assert(isRectangular([
            [[ 1,  2,  3,  4], [ 5,  6,  7,  8], [ 9, 10, 11, 12]],
            [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]
        ], shape));
        assert(shape == [2, 3, 4]);
    }

//还可改进,但不管了.

import std.range.primitives:;
template FlatElementType(A) if (isArray!A)
{
    alias E = ElementType!A;
    static if (isArray!E)
    {
        alias FlatElementType = FlatElementType!E;
    }
    else
    {
        alias FlatElementType = E;
    }
}
unittest
{
    static assert(is(FlatElementType!(int[]) == int));
    static assert(is(FlatElementType!(int[][]) == int));
    static assert(is(FlatElementType!(int[][][]) == int));
}
auto flatten(A)(A a) if (isArray!A)
{
    FlatElementType!A[] result;
    foreach (i; a)
    {
        static if (isArray!(typeof(i)))
            result ~= flatten(i);
        else
            result ~= i;
    }
    return result;
}
unittest
{
    assert(flatten([[1, 2], [3, 4, 5], [6]]) ==
        [1, 2, 3, 4, 5, 6]);
    assert(flatten([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) ==
        [1, 2, 3, 4, 5, 6, 7, 8]);
}