Member pointers in D!

[Mehrdad]

Would this be a useful addition for Phobos?

They're type-checked member function/variable pointers for D.

I haven't tested them with opDispatch or 'alias this' yet, but 
they should work correctly for regular members.


The usage is pretty simple... it even works at compile time:

struct Foo { int x; }
const a = MemberPtr!(Foo, q{x});   // shorthand
pragma(msg, a.get(Foo(1)));  // 1

MemberPtr!(Foo, int) b = MemberPtr!(Foo, q{x});  // longhand
auto f = Foo(2);
b.deref(f) = 3;   // by reference, unlike 'get'
assert(f.x == 3);

and it should also work for member functions.



//----------------------------------------

template MemberPtr(T, string memberName) if (isInstanceMember!(T, 
memberName))
{
	enum MemberPtr =
		MemberPtr!(T, typeof(__traits(getMember, T, memberName)))(
			staticIndexOf!(memberName, __traits(allMembers, T)));
}

struct MemberPtr(T, TMember)
{
	size_t index = -1;

	auto address(ref inout(T) o) inout
	{
		foreach (i, m; __traits(allMembers, T))
		{
			static if (isInstanceMember!(T, m, TMember))
			{
				// 'switch' might be faster
				// but the optimizer can worry about that instead :)
				if (this.index == i)
				{
					return &__traits(getMember, o, m);
				}
			}
		}
		static if (is(typeof(return)) /*has the return type been 
inferred yet?*/)
		{
			assert(0, "Invalid member pointer!");
		}
		else { return (inout(TMember)*).init; }
	}

	ref auto deref(ref inout(T) o) inout
	{
		static if (isSomeFunction!(ReturnType!(typeof(&this.address))))
		{
			return this.address(o);
		}
		else
		{
			return *this.address(o);
		}
	}

	ref auto get(inout(T) o) inout
	{
		return this.deref(o);
	}
}

private template isStaticFunction(T, string m)
{
	static if (
		__traits(compiles,
			__traits(isStaticFunction, __traits(getMember, T, m))))
	{
		 enum isStaticFunction =
		 	 __traits(isStaticFunction, __traits(getMember, T, m));
	}
	else { enum isStaticFunction = false; }
}

private template isInstanceMember(T, string m, TMember = void)
	if (hasMember!(T, m))
{
	enum isInstanceMember =
		!isStaticFunction!(T, m) &&
		(__traits(compiles, __traits(getMember, T, m).offsetof) ||
			isSomeFunction!(__traits(getMember, T, m))) &&
		(is(TMember == void) ||  /* optional */
			is(typeof(__traits(getMember, T.init, m)) : TMember));

}
unittest
{
	struct S
	{
		int m1;
		void m2() { }
		static __gshared int s1;
		static void s2() { }
	}
	static assert(isInstanceMember!(S, q{m1}));
	static assert(isInstanceMember!(S, q{m2}));
	static assert(!isInstanceMember!(S, q{s1}));
	static assert(!isInstanceMember!(S, q{s2}));
}