Build interface from abstract class

[DigitalDesigns]

On Monday, 28 May 2018 at 11:51:20 UTC, Simen Kjærås wrote:
> On Monday, 28 May 2018 at 09:59:50 UTC, DigitalDesigns wrote:
>> Implementing interfaces can be a pain but are necessary.
>>
>> I like to use abstract classes and provide a base 
>> implementation. It would be cool if I could use D's awesome 
>> meta features to extract the interface from the abstract class 
>> then build it. This requires some funky stuff which I'm not 
>> sure D can do
>
> Creating an interface based on a class is no big deal in D:
>
> interface Interface(T)
> {
>     import std.traits;
>     static foreach (fn; __traits(allMembers, T))
>         static foreach (overload; MemberFunctionsTuple!(T, fn))
>             mixin("ReturnType!overload 
> "~fn~"(Parameters!overload);");
> }
>
> class A
> {
>    void fun() {}
> }
>
> alias IA = Interface!A;
>
> However, you run into a problem when A is expected to implement 
> IA: in order to figure out which functions should be in the 
> interface, we need to know which functions are in A. And in 
> order to figure out which functions are in A, we need to know 
> which functions are in IA. It's a loop with no real solution.
>
> In this specific case, one could consider only members of A, 
> ignoring any interfaces or base classes. This isn't currently 
> possible, but it's not an entirely unreasonable enhancement 
> request.
>
> --
>   Simen

I do not think this is a problem in D. Infinite recursion can 
always be terminated with appropriate means.

1. Use attributes. methods in class A should be marked as being 
for the interface. When added to the interface they will not have 
the attribute so will not be picked up again.

2. Your method of function creation does not pick up attributes 
and other factors so it is weak.


Case 1 should be easy to deal with. Case 2, I am not so sure how 
to build the signature exactly as it is expressed. This is, of 
course, just a copy an paste mechanism but it would require D to 
provide us the signature in some way.

Maybe an easy and direct way would be to pass __FILE__ and 
__LINE__ and extract the line? This seems a bit risky and slow.

Case 1 Will not work if UDA's are required to be exactly the same 
between interface and class. I do not know if D enforces that but 
if it does it seems a bit overkill.


Here is my solution that does not solve problem 2:


import std.stdio;



template InterfaceFromClass(alias T, string id)
{
	auto InterfaceFromClass()
	{
		string s;
		import std.traits;
		foreach (member; __traits(allMembers, T))
		{
			static foreach (overload; MemberFunctionsTuple!(T, member))
			{
				enum attr = __traits(getAttributes, overload);
				static if (__traits(getProtection, __traits(getMember, T, 
member)) == "public")
				{
					mixin(`enum attrs = __traits(getAttributes, T.` ~ member ~ 
`);`);
					foreach(a; attrs)
						static if (is(typeof(a) == string) && a.length > 0 && a == 
"InterfaceMembers")
						{					   					
							s ~= (ReturnType!overload).stringof ~" 
"~member~""~(Parameters!overload).stringof~";";
						}
				}
			}
		}

		return "interface "~id~"\n{\n "~s~"\n}";
	}
}



Which you can see it at work here: 
https://dpaste.dzfl.pl/f49be5dd7daa