Operator overloading - operations on slices

[abad via Digitalmars-d-learn]

I am trying to create a generic interface to arrays. Most 
operations except those on elements of slices.

Code:
class Table(T) {
        T[] data;

        this(T[] data) {
                this.data = data;
        }

        auto ref opSlice(size_t x, size_t y) {
                return new Table!(T)(data[x .. y]);
        }

        void opIndexAssign(T value) {
                data[] = value;
        }

        void opIndexAssign(T value, size_t idx) {
                data[idx] = value;
        }

        void opAssign(T value) {
                opIndexAssign(value);
        }

        auto ref opIndexOpAssign(string op)(T value, size_t idx) {
                return mixin("data[idx] " ~ op ~ "= value");
        }
}

int main(string[] args) {
        int[] data = new int[256];
        auto t = new Table!int(data);
        t[] = -1; // OK
        t[1 .. 3] = 5; // OK
        t[0] = 6; // OK
        t[4] += 7; // OK
        t[4..6] += 7; // FAIL, does not compile
}

Am I missing some specific overload or is this just not possible?