• Alex (77/77) Oct 07 2017 Ok, what I'm trying to do is the following:

Alex <sascha.orlov gmail.com> writes:

Ok, what I'm trying to do is the following:
take a type and a value of its type; given a known member of the 
type, (re?)create a similar type, without this very known member.

What does work is this:

/// --- code ---
void main()
{
	S s;
	s.i = 42;
	s.d = 73.0;
	s.s.length = 5;
	s.s[] = 1024;
	s.c = 'c';
	
	auto n = exclude!"i"(s);
	static assert(!__traits(compiles, n.i));
	assert(n.d == s.d);
	assert(n.s == s.s);
	assert(n.c == s.c);
	n.s[0] = 55;
	assert(n.s == s.s); // works, even by reference.
}

struct S
{
	int i;
	double d;
	size_t[] s;
	char c;
	
	//auto fun(){} // <-- a function does not work, line 26
}

auto exclude(string without, T)(T t)
{
	immutable b = [ __traits(allMembers, T) ];
		
	struct Result
	{
		static foreach(i, _; b)
		{
			static if(without != b[i])
			{
				mixin(
					typeof(__traits(getMember, T, b[i])).stringof ~
					" " ~
					__traits(getMember, T, b[i]).stringof ~
					";"
				);
				
			}
		}		
	}
	Result res;
	static foreach(i, _; b)
	{
		static if(without != b[i])
		{
			__traits(getMember, res, b[i]) = __traits(getMember, t, b[i]);
		}
	}
	return res;
}
/// --- code ---

And the problem lies in line 26: If there is a method inside the 
type, it won't work this way.

I assume, there should be a way, to copy the original type first 
and to hide a member afterwards. Is there a simple approach for 
this?

I think, the problem with my approach is, that if the member is 
not a "data" member, than there are a plenty of possibilities to 
check, like... function, template, well... there could be very 
much types of indirections, as checking for "isCallable" is not 
enough for recreation(?)
If these checks are the only way to handle this, than the answer 
to my whole question is:
"recreation is restricted to PODs".

Then, I have to consider which checks to implement, and which 
restrictions have to be applied to the input...