opSlice() or opIndex() for the entire slice?

[Ali Çehreli via Digitalmars-d-learn]

The documentation says "To overload a[], simply define opIndex with no 
parameters":

  http://dlang.org/operatoroverloading.html#Slice
And it works with some uses of a[]. However, opSlice() seems to be 
needed to actually use the returned slice further.

Note that opSlice() also seems to be for backward compatibility: "For 
backward compatibility, a[] and a[i..j] can also be overloaded by 
implementing opSlice() with no arguments and opSlice(i, j) with two 
arguments, respectively. This only applies for one-dimensional slicing, 
and dates from when D did not have full support for multidimensional 
arrays. This usage of opSlice is discouraged."

How can I achieve the last line in main() without needing opSlice()? I 
am trying to let the Slice type handle opAssign() and friends.

import std.stdio;

struct Collection
{
    int[] elements;

    /* Handles the slice operations */
    struct Slice
    {
        int[] slice;

        Slice opAssign(int value)
        {
            slice[] = value;
            return this;
        }
    }

    Slice opIndex()
    {
        writeln("opIndex");
        return Slice(elements);
    }

    Slice opSlice()
    {
        writeln("opSlice");
        return Slice(elements);
    }
}

void main()
{
    auto c = Collection([ 0, 1, 2, 3]);

    // This works with either operator but opIndex is favored. (You can
    // comment out opSlice() and it will still work.)
    writeln(c[]);

    // This requires opSlice.
    c[] = 42;
}

Ali