Why are static arrays not ranges?

[jmh530 via Digitalmars-d-learn]

On Monday, 21 September 2015 at 20:33:10 UTC, Jack Stouffer wrote:
>
> That's ridiculous. Do I have to wrap my static arrays in 
> structs to get range primitives?
>
> Is there an actual reason for this?

I had done basically the same thing. Below is my naive 
implementation.

import std.traits;
import std.range;
import std.array : array;
import std.stdio : writeln;
import std.algorithm : map;

struct hybrid_array(T : U[N], U, size_t N)
	if ( isStaticArray!T )
{
	T static_array;
	private auto _length = static_array.length;
	auto domain = iota(0, static_array.length);
	
	this(T x)
	{
		static_array = x;
	}
	
	@property bool empty()
     {
         return domain.empty;
     }

     @property size_t length()
     {
         return _length;
     }

     @property U front()
     {
		assert(!empty);
         return static_array[domain.front];
     }

     void popFront()
     {
		assert(!empty);
         domain.popFront;
		_length--;
     }
	
	@property hybrid_array save()
     {
         return this;
     }
	
	@property U back()
     {
		assert(!empty);
         return static_array[domain.back];
     }

     void popBack()
     {
		assert(!empty);
         domain.popBack;
		_length++;
     }
	
	U opIndex(size_t val)
     {
		assert(!empty);
         return static_array[domain[val]];
     }
}

void main()
{
	int[5] x = [0, 10, 2, 6, 1];
	//auto squares = map!(a => a * a)(x); //doesn't work
	
	auto range = iota(0, x.length).array;
	
	alias h_array = hybrid_array!(int[5]);
	auto y = h_array(x);
	
	writeln( isRandomAccessRange!(typeof(y)) );
	
	auto squares = map!(a => a * a)(y); //success, does work
	writeln(squares);
}