Syntactic Sugar for Construction of Empty Dynamic Arrays of a Given Type

[Nordlöw]

Is there a convenicene function for assigning an empty dynamic 
array of a given type to a variable?

    cast(int[])[];
I'm using this in ForwardDifference constructor:

auto forwardDifference(R)(R r) if (isInputRange!R)
{
    import std.range: front, empty, popFront, dropOne;

    struct ForwardDifference
    {
        R _range;
        alias E = ElementType!R;                       // Input 
ElementType
        alias D = typeof(_range.front - _range.front); // Element 
Difference Type. TODO: Use this as ElementType of range
        D _front;
        bool _initialized = false;

        this(R range)
        in { assert(!range.empty); }
        body {
            auto tmp = range;
            if (tmp.dropOne.empty) // TODO: This may be an 
unneccesary cost but is practical to remove extra logic
                static if (isArray!R) // TODO: Construct R in a 
generic way that include dynamic arrays?
                    _range = cast(D[])[];
                else
                    _range = R(); // return empty range
            else
                _range = range; // store range internally (by 
reference)
        }

        @property:
        auto ref front() {
            if (!_initialized) { popFront(); }
            return _front;
        }
        auto ref moveFront() {
            popFront();
            return _front;
        }
        void popFront() {
            if (empty is false) {
                _initialized = true;
                E rf = _range.front;
                _range.popFront();
                if (_range.empty is false)
                {
                    _front = _range.front - rf;
                }
            }
        }
        bool empty() {
            return _range.empty;
        }
    }

    return ForwardDifference(r);
}