A Refcounted Array Type

[Walter Bright via Digitalmars-d]

This is pretty straightforward. More could be done:

1. small array optimization
2. support for ranges as constructor args
3. present a range interface
4. support for malloc/free instead of GC
5. bounds checking
6. the array[] and the count could be allocated together
7. array[] could be just a pointer
but the basic idea is there, I didn't want to hide it behind all the other flesh 
a professional type would have.

Note the return in opIndex(). This is DIP25 at work!

Compile:
    dmd rcarray -unittest -main -dip25

===========================================

struct RCArray(E) {

    this(E[] a)
    {
        array = a.dup;
        start = 0;
        end = a.length;
        count = new int;
        *count = 1;
    }

    ~this()
    {
        if (count && --*count == 0)
            delete array;
    }

    this(this)
    {
        if (count)
            ++*count;
    }

    size_t length()
    {
        return end - start;
    }

    ref E opIndex(size_t i) return // here's the magic
    {
        return array[start + i];
    }

    RCArray opSlice(size_t lwr, size_t upr)
    {
        RCArray result = this;
        result.start = start + lwr;
        result.end = start + upr;
        return result;
    }

  private:
    E[] array;
    size_t start, end;
    int* count;
}

unittest
{
    static int[3] s = [7, 6, 4];
    auto r = RCArray!int(s);
    assert(r.length == 3);
    assert(r[0] == 7);
    assert(r[1] == 6);
    assert(r[2] == 4);
    assert(*r.count == 1);

    {
        auto r2 = r;
        assert(r2[0] == 7);
        assert(r2[1] == 6);
        assert(r2[2] == 4);
        assert(*r.count == 2);

        r[1] = 3;
        assert(r2[0] == 7);
        assert(r2[1] == 3);
        assert(r2[2] == 4);
    }
    assert(*r.count == 1);

    auto r3 = r[1 .. 3];
    r[2] = 9;
    assert(r3[0] == 3);
    assert(r3[1] == 9);

  /+
    ref int test(ref RCArray!int rr)
    {
        return rr[1]; // this gives error
    }
   +/
}