Changing Template Static Ifs to Recursion

[jmh530 via Digitalmars-d-learn]

I have a struct that I am using like a Tuple, but I want to be 
able to opIndex in a different way than Tuple's opIndex. I want 
to be able to opIndex whatever is underlying the Tuple.

The code below works, but is kind of annoying because to extend 
you have to keep adding static ifs. I want to change it to a 
recursion that can handle any length. I tried a few different 
options, but not having much luck.

Would appreciate any advice!

Note: I left out the function foo, but think of foo is to Foo as 
tuple is to Tuple.

import std.typecons : Tuple;

struct Foo(T...)
{
	alias U = Tuple!T;
	U underlying;
	alias underlying this;
	
	alias Names = U.fieldNames;
	alias Types = U.Types;
	
	template process(B...)
	{
		auto ref process(A...)(A a)
		{
			alias fooB = foo!(B);
			
			static if (A.length == 1)
			{
				return fooB(this.underlying[0][a[0]]);
			}
			else static if (A.length == 2)
			{
				return fooB(this.underlying[0][a[0]],
					    this.underlying[1][a[1]]);
			}
			else static if (A.length == 3)
			{
				return fooB(this.underlying[0][a[0]],
					    this.underlying[1][a[1]],
					    this.underlying[2][a[2]]);
			}
		}
	}
	
	auto ref opIndex(Slices...)(Slices slices)
		if (Slices.length == Types.length)
	{
		return process!(Names)(slices);
	}
}