Troubles creating templated inout objects

[Timoses]

On Tuesday, 10 July 2018 at 18:01:59 UTC, Steven Schveighoffer 
wrote:
> You are overthinking :) inout typically is much easier than you 
> expect, until you need to create temporary structs or types 
> with inout members, then it becomes problematic.
>
> https://run.dlang.io/is/kosYuC
>
> I had to put in a static if, because your function doesn't work 
> once you get down to the array type. See the // fixme comment.

Ok, well that helped a tiny bit for the example.

I'm trying to reproduce the errors from my project. It's starting 
to get out of control : D. inout is on a rampage!

https://run.dlang.io/is/5TN7XX

I guess it's the same as for immutable initialization of arrays. 
I can't seem to find a proper response to this one..

	import std.traits;

	struct S
	{
		int[3] arr;
	}
	struct SS
	{
		S s;
	}

	interface I
	{
		inout(I) opIndex(size_t idx) inout;
	}

	class Test(T) : I
	{
		T member;

		this(inout T mem) inout
		{
			this.member = mem;
		}

		inout(Test!T) get() inout
		{
			return new inout Test!(Unqual!(typeof(member)))(member);
		}

		inout(I) opIndex(size_t idx) inout
		{
			static if (is(T == struct))
			{
				switch (idx)
				static foreach (index, t; T.tupleof)
				{
					case index:
						return new inout
							Test!(Unqual!(typeof(this.member.tupleof[index])))
										(this.member.tupleof[index]);
					default:
						return null;
				}
			}
			else
				return null;
		}
	}

	auto test(T)(inout T t)
	{
		return new inout Test!(Unqual!T)(t);
	}

	class TestA(T : T[])
	{
		Test!T[] arr;

                 // ERROR: Can't initialize inout variable in a 
for loop...
		this(inout(T[]) arr) inout
		{
			// 1: Nope
			foreach (mem; arr)
			    this.arr ~= test(mem);

			// 2: Nope
			//Test!T[] a;
			//foreach (mem; arr)
			//   a ~= test(mem);

			import std.algorithm : map;
			// 3: Nope
			// this.arr = arr.map!((e) => test(e)).array;
		}
	}


	void main()
	{
		auto ss = SS(S([1,2,3]));
		auto t = new const Test!SS(ss);
		auto ta = new const TestA!(Test!SS[])([t]);
	}