Re: Changing Template Static Ifs to Recursion

[jmh530 via Digitalmars-d-learn]

On Wednesday, 31 May 2017 at 21:02:07 UTC, jmh530 wrote:
On Wednesday, 31 May 2017 at 19:22:18 UTC, Stefan Koch wrote:

You could also use string mixins.
Which will be more efficient then recursion.

I try to avoid string mixins unless I can't help it. 
Nevertheless, I made an effort to try to get it to work and 
below seems to be working. I still have to use some recursion 
to generate the string.

The downside is that this version can't be @nogc, correct?


One advantage of the mixin version is that I don't have to 
explicitly get the type of the result. In ag0aep6g's example, it 
works easily enough for arrays, but if the indexing is more 
complicated, then it becomes a pain to get the correct types.

I struggled a little to get it @nogc, but eventually got it there 
by changing the helper code to free-standing functions that use 
enums to force CTFE. The code is below:

private
{
        const(char[]) opIndex_i(size_t i)() @nogc
        {
                return "this.underlying[" ~ i.stringof ~ "][slices[" ~
                                                                        i.stringof ~ 
"]]";
        }
                
        const(char[]) GenResult(alias f, T...)() @nogc
        {
                const(char[]) GenParens(U...)() @nogc
                {
                        static if (U.length > 0)
                        {
                                static if (U.length == 1)
                                {
                                        enum result = f!(U.length - 1);
                                }
                                else static if (U.length > 1)
                                {
					enum result = GenParens!(U[0 .. $ - 1]) ~ ", " ~ f!(U.length 
- 1);
                                }
                                return result;
                        }
                }
                
                enum parens = GenParens!(T);
                return "foo!(Names)(" ~ parens ~ ")";
        }
}

struct Foo(T...)
{
        alias U = Tuple!T;
        U underlying;
        alias underlying this;
        
        alias Names = U.fieldNames;
        alias Types = U.Types;
        
        /// Alternate access to tuple
        auto index(size_t dimension)() const @property
        {
                return underlying[dimension];
        }
        
        auto ref opIndex(Slices...)(Slices slices) @nogc
        if (Slices.length == Types.length)
    {
                return mixin(GenResult!(opIndex_i, Slices));
    }
}