tuple slicing operator

[Meta via Digitalmars-d-learn]

On Saturday, 9 August 2014 at 16:39:34 UTC, Vlad Levenfeld wrote:
> I may be misunderstanding the intended semantics of the [] 
> operator but I've come to interpret x[] to mean "give me x as a 
> range" and this is the meaning I intend when I overload it in 
> my own structs.
>
> But -
>
> auto z = tuple (1,1,1);
> pragma (msg, typeof(z)); // Tuple!(int, int, int)
> pragma (msg, typeof(z[])); // (int, int, int)

Tuples are special. Tuple internally keeps a compiler tuple that 
it aliases to itself. Compiler tuples have a built-in "static 
slice" operator that no other type has. Since Tuple aliases a 
compiler tuple to itself internally, doing `z[]` actually 
forwards to the compiler tuple's static slice operator (which is 
why z[] gives you a type of (int, int, int) instead of 
Tuple!(int, int, int)). It is a bit confusing, but tuples are a 
messy part of the D language.

Other than that, thinking of `x[]` as "give me x as a range" is 
not really correct. For one thing, any type can overload the [] 
operator, so x[] can mean anything. Second, it's more correct to 
think of x[] as meaning "give me a *slice* of x", since [] is the 
slice operator. Usually slices *are* ranges, but they don't have 
to be, and it's not a good assumption to make.


> In generic code I tend to use [] to make sure a variable is a 
> range before I use it (like static arrays, or structs following 
> my interpretation of []). So now whenever tuples might come 
> into the mix I have to pass the argument through an overloaded 
> convenience function that can tell a range or tuple type from 
> one-element variadic argument.
>
> I've got a lot of difficulty with that last part so I am 
> wondering, is there a better way to do this?

In generic code, you should always use template constraints and 
static if along with the appropriate traits to check facts about 
a type. Take a look at std.traits and std.range, which have 
templates that can tell you whether a type T is an input range, 
forward range, etc., an array, etc.