import std.stdio: writeln;

import std.algorithm: each, equal;

import std.datetime.stopwatch: benchmark;

enum Mb = 1024*1024;

​

struct Stride( Type : Elem[], Elem )

{

    private Elem[] range;

    private int currFront;

    private int strideCount;

    this( Elem[] r, int s )

    {

        range = r;

        strideCount = s;

    }

    pragma( inline ) @property length() const { return range.length / strideCount; }

    pragma( inline ) @property empty() const { return currFront > range.length; }

    pragma( inline ) @property ref Elem front() { return range[ currFront ]; }

    pragma( inline ) void popFront() { currFront += strideCount; }

}

​

pragma( inline ) auto stride( Range )( Range r, int a )

{

    return Stride!Range( r, a );

}

​

pragma( inline ) auto fill( Range, Value )( Range r, Value v )

{

    foreach( ref e; r )

    {

        e = v;

    }

    return r;

}

​

void main()

{

    enum strideAmount = 3;

    enum arraySize = 50 * Mb;

    alias Type = byte;

    auto a = new Type[arraySize/Type.sizeof];

    auto b = new Type[arraySize/Type.sizeof];

    auto c = new Type[arraySize/Type.sizeof];

    a[] = -1;

    b[] = -1;

    c[] = -1;

    benchmark!({

        for(auto i=0; i<a.length; i+=strideAmount) {

            a[i] = 0;

        }

    }, {

        b[0..$].stride(strideAmount).fill(cast(Type) 0); //yes the cast is needed for smaller types like byte

    }, {

        c[0..$].stride(strideAmount).each!((ref x) => x = 0);

    })(1).each!writeln;

    assert(a.equal(b) && b.equal(c));

}

​