How to return range constructs?

[Robin]

Hiho,

for experimental and learning reasons I am working on a simple 
matrix library for D. And since ranges seem to be a cool feature 
of the D language I am currently trying to understand them and 
use them more in my codes.

So I thought that it would be a nice feature if I could create 
methods to return specific ranges for certain matrix instances, 
e.g. something like getRowRange(size_t row) or 
getColumnRange(size_t col) which returns a range to easily 
iterate through a single row- or column vector of a matrix 
instance with a simple foreach loop.

I store the matrix data within a single dimensional array for 
performance purposes instead of a jagged array:

private
{
        T[] data;
        Dimension dim;
}

The Dimension 'dim' is an object holding the number of rows and 
columns as well as some handy methods and properties such as 
isSquare etc.

So my question is: How to define such a method which returns a 
range for a single row or column vector? The range should be 
modifiable depending on whether the matrix instance is 
const/immutable or not. Or isn't that possible at all? I thought 
that it could be tricky for row vectors since their data wouldn't 
be dense in memory.

I've looked into the std.range documentation but doesn't seem to 
get a clue how to get this working. And if it works - what range 
type would fit best for my purposes - or do I need to create a 
sub-class of a certain range type specially fit for my matrix?

My try so far:

module neoLab.core.ColumnVectorRange;

import std.range;
import neoLab.core.Matrix;

final class ColumnVectorRange(T) : RandomAccessFinite!T {
        private
        {
                T[] data;
                size_t cur = 0;
                size_t length = 0;
        }

        this(const ref Matrix m, size_t row)
        in
        {
                assert(row < m.getDimension().rows, "Row index is invalid.");
        }
        body
        {
                this.data = m.data;
                this.length = m.getDimension().cols;
        }

        ColumnVectorRange!T save() {
                // What does this do?
        }

        override T opIndex(size_t index) {
                return this.data[index]; // this correct?
        }

        override T moveAt(size_t index) {
                return this.data[this.cur]; // this good?
        }

        override size_t length() {
                return this.length;
        }

        override alias opDollar = this.length; // Is this nessecary?

        override ColumnVectorRange!E opSlice(size_t, size_t) {
                // What does this do in particular?
        }
}

I highly appreciate tips and answers! =)

Thanks in advance.

Robin