problem with opIndex

[Joseph]

I am trying to have a multi-dimensional array and opIndex has to 
have both an arbitrary number of parameters and allow for slicing.

The problem is if I create opIndex for non-slicing, it looks like

ref auto opIndex(T...)(T index)

and this one catches all templates. But slices do not return the 
same value. I need to somehow have two opIndex's, one for slice 
handling and one for non-slices.

Trying to accomplish

arr[1..4, 5..8, 3, 3..4]

I already have the single index case arr[3, 4, 3, 1]

and the only difference is that for a slice, the indices are 
int[2]'s.

To make this work, I need to somehow know if any of the 
parameters is a slice or not.

Heres what I've got so far:

struct sMArray(F)
{
	import std.traits, std.meta, core.stdc.stdlib;
	size_t[] dimensions;		// The dimensions of the multi-array
	size_t[] offset;			// The offset of the multi-array(for slices)
	void[] data;				// An array of the actual element data in bytes
	void[] parent;				// The parent array or slice, if null, no 
parent.
	
	
	this(T...)(T args)			// Give the dimensions with one 
element(first or last) being a flag array to initialize with
     {			
		static if (isArray!(T[0]))
		{
			auto dat = T[0];
			dimensions = args[1..$];
			enum start = 1;
			enum end = T.length;

		} else
		{
			static if (isArray!(T[$-1]))
			{
				auto dat = T[$-1];
				enum start = 0;
				enum end = T.length-1;
			} else
			{
				int[] dat = null;
				enum start = 0;
				enum end = T.length;
			}				
		}


		foreach(a; args[start..end]) 		
			dimensions ~= a;

		int totalSize = 1;
		foreach(d; dimensions)
			totalSize *= d;

		data = malloc(totalSize*F.sizeof)[0..totalSize*F.sizeof];

		if (dat != null)
			for(int i = 0; i < dat.length; i++)
				(cast(typeof(dat))data)[i] = dat[i];

     }

	ref auto opIndex()
	{
		return data;
	}

	// Index a single element, e.g., data[0, 1] or takes a 
slice/view of the array and returns that as another sMArray
     ref auto opIndex(T...)(T idx)
	{ 		
		if (T.length != dimensions.length) assert(0, "sMArray invalid 
indexing!");
		size_t i = 0;
		static foreach(k, t; T)
		{
			static if (k == 0)
				i = idx[0];
			else
				i += idx[k]*dimensions[k-1];
		}

		debug { if (i >= data.length) assert(0, "sMArray invalid index! 
Too Large."); }
		return (cast(F[])data)[i];
	}

	// Support for `x..y` notation in slicing operator for the given 
dimension.
     size_t opSlice(size_t dim)(size_t start, size_t end)
		in { assert(start >= 0 && end <= this.opDollar!dim); }
     body
     {
         return [start, end];
     }

	size_t GetDim(int i)
	{
		return dimensions[i];
	}

	// Support `$` in slicing notation, e.g., arr[1..$, 0..$-1].
	@property size_t opDollar(size_t dim)() { return 
dimensions[dim]; }





	~this()
	{
		free(data.ptr);
	}



}