struct Tuple(Ts...)

{

    Ts values;

    static assert(is(CommonLvalueType!Ts));

    static assert(!is(CommonLvalueType!Ts == void));

    alias opStaticIndex(size_t i) = values[i];

    CommonLvalueType!Ts[] opIndex()

    {

        return (&values[0])[0 .. values.length];

    }

    CommonLvalueType!Ts opIndex(size_t index)

    in (index < values.length)

    {

        final switch (index)

        {

            static foreach (i; 0 .. values.length)

            {

                case i: return values[i];

            }

        }

    }

}

​

unittest

{

    alias Tup = Tuple!(int, immutable(int));

    Tup tup;

    static assert(is(typeof(tup[]) == const(int)[]));

    static assert(is(typeof(tup.opIndex()) == const(int)[]));

    // proposed rewrite of tup[0] and tup[1]

    static assert(is(typeof(tup.opStaticIndex!0) == int));

    static assert(is(typeof(tup.opStaticIndex!1) == immutable(int)));

    int i = 0;

    // rewrite of tup[i]:

    static assert(is(typeof(tup.opIndex(i)) == const(int)));

}

​

template CommonLvalueType(Ts...)

{

    static bool cond();

    // note: non-template `alias Helper = ...` does not work.

    private alias Helper() = typeof({

        Ts values;

        static if (Ts.length != 0) return *mixin({

            string result;

            static foreach (i; 0 .. Ts.length - 1)

                result ~= mixin("`cond() ? &(values[", i, "]) :`");

            return result ~ mixin("`&(values[", Ts.length - 1, "])`");

        }());

    }());

​

    static if (is(Helper!()))

    {

        alias CommonLvalueType = Helper!();

        // just to be absolutely sure

        static foreach (T; Ts)

        {

            static assert(T.sizeof == CommonLvalueType.sizeof);

        }

    }

    else alias CommonLvalueType = void;

}