Rebind template(bug?)

Sun Aug 21 15:06:17 PDT 2016

On Sunday, 21 August 2016 at 21:11:37 UTC, ag0aep6g wrote:
> On 08/21/2016 09:29 PM, Engine Machine wrote:
>> I know you like to play the right or wrong game, but did you 
>> ever learn
>> that a single example does not prove the truth of something?
>
> But you can show in a single example that something doesn't 
> work. You tried to do that, and you did it with a simple 
> example, which is always appreciated. But apparently, you were 
> wrong. Happens to the best. And when the compiler prints 
> "tmpl!a" that's indeed a little misleading.
>
> You being wrong there doesn't mean that the Rebind template as 
> I posted it works correctly, of course. But Jack didn't claim 
> that. He just said that your example for how it doesn't work is 
> wrong. And as far as I see, Rebind does work as expected. But I 
> wouldn't be surprised if there is some edge case where things 
> fall apart.
>
> Also, if you're looking for help or civil discussion, I suggest 
> you try a less antagonistic approach. Things like "I know you 
> like to [play games]" and "did you ever learn [whatever]" do 
> not set the tone for that.
>
>> How about something more complex?
>>
>> import std.stdio;
>> import std.meta, std.traits;
>>
>> class base { }
>
> Style nitpick: Class names in PascalCase, please.
>
>> template Rebind(alias instance, newArgs...)
>> {
>>     import std.traits: TemplateOf;
>>     alias tmpl = TemplateOf!instance;
>>     static if (newArgs.length > 0)
>>         alias Rebind = tmpl!newArgs;
>>     else
>>         alias Rebind = base;
>> }
>>
>> template EraseLast(A...)
>> {
>>     static if (A.length > 0)
>>         alias EraseLast = Erase!(A[$-1], A);
>
> This line can be simplified: alias EraseLast = A[0 .. $ - 1];
>
>>     else
>>         alias EraseLast = base;
>
> This is quite surprising for a template that's called 
> "EraseLast". I renamed it to "EraseLastOrBase" for myself when 
> looking at this.
>
>> }
>>
>>
>>
>> class T(A...) : Rebind!(T!A, EraseLast!A)
>
> The core idea of Rebind isn't needed here, is it? You've got T, 
> so you can just pass it directly. No need to extract it from 
> T!A.
>
> So, instead of using some form of Rebind, you can use a simpler 
> template:
>
> ----
> /* Instantiates tmpl with args, or if no args given, returns 
> base. */
> template InstantiateOrBase(alias tmpl, args ...)
> {
>     static if (args.length == 0) alias InstantiateOrBase = base;
>     else alias InstantiateOrBase = tmpl!args;
> }
>
> class T(A...) : InstantiateOrBase!(T, EraseLast!A)
> ----
>
>> {
>>     int x;
>
> Note that this means that every instantiation of T brings its 
> own x. That is, T!foo declares an x, and T!(foo, bar) which 
> inherits from T!foo adds another x. The same happens with y, z, 
> and s, of course.
>
>>     static if (A.length > 0 && A[0] == "Animal")
>>     {
>>         int y;
>>         static if (A.length > 1 && A[1] == "Dog")
>>         {
>>             int z;
>>             static if (A.length > 2 && A[2] == "Pug")
>>                 int s;
>>         }
>>
>>     }
>> }
>>
>>
>> pragma(msg, is(T!("Animal", "Dog", "Pug") : T!("Animal", 
>> "Dog")));
>> pragma(msg, is(T!("Animal", "Dog", "Pug") : T!("Animal")));
>> pragma(msg, is(T!("Animal", "Dog", "Pug") : base));
>> pragma(msg, is(T!("Animal", "Dog") : T!("Animal")));
>> pragma(msg, is(T!("Animal", "Dog") : base));
>> pragma(msg, is(T!("Animal") : base));
>
> Asserts are great to show that something holds. When someone 
> like me makes changes to your code in order to understand it, 
> the complier throws a nice loud error in their face when they 
> mess up. So I changed these to static asserts for myself.
>
>> // all true
>>
>>
>>
>> void main()
>> {
>>         auto t = new T!("Animal", "Dog", "Pug")();
>>     T!("Animal", "Dog") q = t;
>>         //T!("Animal", "Dog", "Pug") q = t; works but then q 
>> is not the
>> super of t
>>     t.x = 3;
>>     t.y = 4;
>>     t.z = 6;
>>     t.s = 123;
>>
>>     q.y = 1;
>>     writeln(t, ", ", typeof(t).stringof);
>>     writeln(q, ", ", typeof(q).stringof);
>>     writeln("---");
>>     writeln(t.x);
>>     writeln(t.y);
>>     writeln(t.z);
>>     writeln(t.s);
>>     writeln("---");
>>     writeln(q.x);
>>     writeln(q.y);
>>     writeln(q.z);
>>     writeln("---");
>>     writeln(t.y);
>>     writeln("---");
>>     writeln(&t);
>>     writeln(&q);
>>
>> }
>>
>> Since the pragma's are true, it is obvious that the 
>> inheritance should
>> work chain works. Yet q is not a reference to t as it should 
>> be, why is
>> this?
>
> It would help a lot if you would point out what parts of the 
> output are surprising to you. If you let the reader figure it 
> out themselves, chances are 1) people are not going to bother, 
> and 2) if they do bother, they might miss your point.
>
> Labeling the output also helps. By that I mean, if you write 
> `writeln("t.x: ", t.x);`, the output can be read much more 
> easily. I also think that you could have made your point with 
> less output, which would again make it easier to follow. That 
> is, just looking t.x/q.x would have been enough, no?
>
> I guess you expect q.x and friends to be the same as t.x and 
> friends. And since you put it there, you may also expect &t to 
> be the same as &q.
>
> About the members being different: That's because every 
> instantiation brings its own x/y/z, as mentioned above. 
> Lodovico has shown what happens here in his Child/Parent 
> example.
>
> About &t and &t: Those are the addresses of the class 
> references themselves. To print the addresses of the objects, 
> cast to void*:
>
> ----
> writeln(cast(void*) t);
> writeln(cast(void*) q); /* prints the same as the line above */
> ----
>
> So, you're wrong again ;)

So, the point is, I don't like putting a lot of work in to 
something unless I know it works. D is horrible in showing what 
is actually going on most of the time and I have to figure out 
and try many different things. If it has a bug or error msg that 
isn't informative then I have to try something again, and keep 
trying until the problem is solved. I've never had these problems 
with modern compilers. I assume it is due to D's meta complexity. 
It is amazing on one hand but sucks on the other.

Anyways, This is what I finally have:

import std.meta, std.traits;  	

template Rebind(alias instance, newArgs...)
{
     import std.traits: TemplateOf;
	alias Seq(T...)=T;
     alias tmpl = TemplateOf!instance;
	static if (newArgs.length > 0)
	    alias Rebind = tmpl!newArgs;
	else
		alias Rebind = Seq!();
}

template EraseLast(A...)
{
	alias Seq(T...)=T;
	static if (A.length > 0)
		alias EraseLast = Erase!(A[$-1], A);
	else
		alias EraseLast = Seq!();
}

class T(A...) : Rebind!(T!A, EraseLast!A)
{	
	pragma(msg, A);
	static if (A.length == 0)
	{
		pragma(msg, "BASE!!");
	} else
	static if (A[$-1] == "Animal")
	{
		int x;
		int y;
	} else
	static if (A[$-1] == "Dog")
	{
		int z;
	} else
	static if (A[$-1] == "Pug")
	{
		int s;
	} else pragma(msg, A[$-1], " not a defined class of ", 
this.stringof);
}

This is the problem. Rebind(or even if your modification of 
InstantiateOrBase, which requires a base), does not provide the 
base class.

I want the above code to simply provide itself as a base when it 
is at the "top" of the hierarchy.

The idea is suppose to be simple:

One has a hierarchy a super b super c. (e.g. Animal <= Dog <= Pug)

There is a base to A, which contains all the base stuff, It is 
taken to 0 template parameters: T!() <= T!"Animal" <= 
T!("Animal", "Dog") <= T!("Animal", "Dog", "Pug")

T!()'s "data" is specified in the class just like all the other 
derivations. I don't want to have to specify an external base 
class as in your InstaniateOrBase. Why? Because!!! (There should 
be no need to, and if one goes this route of creating classes, it 
should be all or nothing, else there is no real benefit)

Now, I can do somethign like T!("Base", "Animal", etc) but then 
this requires specifying "Base" in every construction, which is 
unnecessary since it always exists.

So, I basically want to conditionally inherit. If A... has length 
0(in T), i.e., T!() then we get the base class. I've tried using 
Object as a substitute and all that mess but nothing works 
properly. Usually results in a circular definition.

It seems that when one uses `class T(A...) : X`, one can't, for 
some X, not have inheritance. The compiler expects X to be 
something inheritable from no matter what. I could be wrong, but 
this seems to be the case. i.e., there is no such thing as 
conditional inheritance in D, e.g.,

class T(A...) if (A.length > 0) : X // (inherits from X only if 
A.length > 0)
{

}

Or, say, X is "null" or an empty sequence.

Hopefully I am truly wrong and D can do this.

Again, all I want to do is specify the "base class" inside the 
class rather than create a new class outside. I can do this for 
all the derivations now but not for base.