www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - alias not valid with ~

reply Ignacious <I.D.T ProjectMaya.com> writes:
class Y
{
    int y;
    alias y this;
}

class X
{
    Y[] x;
    alias x this;
}


Yet X ~= 3; fails.

3 should be implicitly convertible to Y and then ~ should assign 
it.

?
Jan 18
parent reply rikki cattermole <rikki cattermole.co.nz> writes:
On 19/01/2017 3:08 PM, Ignacious wrote:
 class Y
 {
    int y;
    alias y this;
 }

 class X
 {
    Y[] x;
    alias x this;
 }


 Yet X ~= 3; fails.

 3 should be implicitly convertible to Y and then ~ should assign it.

 ?
This should not fail: X x = new X; x ~= 3; This should fail as x is a member of an instance of class X: X ~= 3;
Jan 18
parent reply Adam D. Ruppe <destructionator gmail.com> writes:
On Thursday, 19 January 2017 at 02:15:04 UTC, rikki cattermole 
wrote:
 On 19/01/2017 3:08 PM, Ignacious wrote:
 class Y
 {
    int y;
    alias y this;
 }

 class X
 {
    Y[] x;
    alias x this;
 }
 This should not fail:

 X x = new X;
 x ~= 3;
Yes, it should fail. 3 is not implicitly convertible to Y under any circumstance. D does not support implicit constructors. alias this only works if you ALREADY HAVE a Y, then it will implicitly convert Y to int. It will never go the other way around.
Jan 18
next sibling parent rikki cattermole <rikki cattermole.co.nz> writes:
On 19/01/2017 3:25 PM, Adam D. Ruppe wrote:
 On Thursday, 19 January 2017 at 02:15:04 UTC, rikki cattermole wrote:
 On 19/01/2017 3:08 PM, Ignacious wrote:
 class Y
 {
    int y;
    alias y this;
 }

 class X
 {
    Y[] x;
    alias x this;
 }
 This should not fail:

 X x = new X;
 x ~= 3;
Yes, it should fail. 3 is not implicitly convertible to Y under any circumstance. D does not support implicit constructors. alias this only works if you ALREADY HAVE a Y, then it will implicitly convert Y to int. It will never go the other way around.
Oh Y, I read it as int, my bad. Yes should fail.
Jan 18
prev sibling parent reply Ignacious <I.D.T ProjectMaya.com> writes:
On Thursday, 19 January 2017 at 02:25:44 UTC, Adam D. Ruppe wrote:
 On Thursday, 19 January 2017 at 02:15:04 UTC, rikki cattermole 
 wrote:
 On 19/01/2017 3:08 PM, Ignacious wrote:
 class Y
 {
    int y;
    alias y this;
 }

 class X
 {
    Y[] x;
    alias x this;
 }
 This should not fail:

 X x = new X;
 x ~= 3;
Yes, it should fail. 3 is not implicitly convertible to Y under any circumstance. D does not support implicit constructors. alias this only works if you ALREADY HAVE a Y, then it will implicitly convert Y to int. It will never go the other way around.
Huh? But this is alias this, the whole point of alias this is to treat the type as as the alias? You are saying it basically only works one way, seems to make alias this quite useless(50% at least). Is there any real reason why this doesn't work? X x; Y y; y = 3; x ~= y; works fine x ~= 3; fails. Yet, logically, 3 is convertible to Y(3rd line above) and Y is appendable to X. Seems to me that D simply hasn't added the logic to handle the case for implicit construction for alias this, why not add it?
Jan 18
next sibling parent reply rikki cattermole <rikki cattermole.co.nz> writes:
On 19/01/2017 3:35 PM, Ignacious wrote:
 On Thursday, 19 January 2017 at 02:25:44 UTC, Adam D. Ruppe wrote:
 On Thursday, 19 January 2017 at 02:15:04 UTC, rikki cattermole wrote:
 On 19/01/2017 3:08 PM, Ignacious wrote:
 class Y
 {
    int y;
    alias y this;
 }

 class X
 {
    Y[] x;
    alias x this;
 }
 This should not fail:

 X x = new X;
 x ~= 3;
Yes, it should fail. 3 is not implicitly convertible to Y under any circumstance. D does not support implicit constructors. alias this only works if you ALREADY HAVE a Y, then it will implicitly convert Y to int. It will never go the other way around.
Huh? But this is alias this, the whole point of alias this is to treat the type as as the alias? You are saying it basically only works one way, seems to make alias this quite useless(50% at least). Is there any real reason why this doesn't work? X x; Y y; y = 3; x ~= y; works fine x ~= 3; fails. Yet, logically, 3 is convertible to Y(3rd line above) and Y is appendable to X. Seems to me that D simply hasn't added the logic to handle the case for implicit construction for alias this, why not add it?
It is not implicitly convertible in any form. An integer is just a value, probably stored in a register or directly encoded into an instruction. A class instance is always allocated into memory, in pretty much all cases the heap (stack is explicit in D). So what you're suggesting would require an allocation + calling of a constructor to make it equal. Now, lets say Y was a struct, then yeah it can work. Because a struct is nothing more than a set of values that go together. Which are commonly allocated on the stack and for smaller ones, be passed around by only registers.
Jan 18
next sibling parent Ignacious <I.D.T ProjectMaya.com> writes:
On Thursday, 19 January 2017 at 02:51:03 UTC, rikki cattermole 
wrote:
 On 19/01/2017 3:35 PM, Ignacious wrote:
 On Thursday, 19 January 2017 at 02:25:44 UTC, Adam D. Ruppe 
 wrote:
 On Thursday, 19 January 2017 at 02:15:04 UTC, rikki 
 cattermole wrote:
 On 19/01/2017 3:08 PM, Ignacious wrote:
 class Y
 {
    int y;
    alias y this;
 }

 class X
 {
    Y[] x;
    alias x this;
 }
 This should not fail:

 X x = new X;
 x ~= 3;
Yes, it should fail. 3 is not implicitly convertible to Y under any circumstance. D does not support implicit constructors. alias this only works if you ALREADY HAVE a Y, then it will implicitly convert Y to int. It will never go the other way around.
Huh? But this is alias this, the whole point of alias this is to treat the type as as the alias? You are saying it basically only works one way, seems to make alias this quite useless(50% at least). Is there any real reason why this doesn't work? X x; Y y; y = 3; x ~= y; works fine x ~= 3; fails. Yet, logically, 3 is convertible to Y(3rd line above) and Y is appendable to X. Seems to me that D simply hasn't added the logic to handle the case for implicit construction for alias this, why not add it?
It is not implicitly convertible in any form. An integer is just a value, probably stored in a register or directly encoded into an instruction.
so? An integer is just a type. Where it is stored or how is irrelevant.
 A class instance is always allocated into memory, in pretty 
 much all cases the heap (stack is explicit in D). So what 
 you're suggesting would require an allocation + calling of a 
 constructor to make it equal.
So.
 Now, lets say Y was a struct, then yeah it can work. Because a 
 struct is nothing more than a set of values that go together. 
 Which are commonly allocated on the stack and for smaller ones, 
 be passed around by only registers.
So. If it worked for a struct as you suggest it should for for any type. What you are suggesting is that the compiler(or maybe the compiler programmer) is not able to create a rewrite rule. It obviously can. So your reasons are flawed. The reason question you should ask yourself is is there any reason not to do it, instead of trying to find reasons it can't be done(sounds more like you are grasping at straws/guessing). You should realize any time one can program something explicit the compiler can be made to do it implicit. The question is the consequences of such actions. In this case, regardless if we use 3 and convert explicitly or not ~ requires an allocation, so allocations alone are not enough to prevent it.
Jan 18
prev sibling parent Adam D. Ruppe <destructionator gmail.com> writes:
On Thursday, 19 January 2017 at 02:51:03 UTC, rikki cattermole 
wrote:
 Now, lets say Y was a struct, then yeah it can work.
In theory, it can work with either (the compiler could just insert the function call to alloc+construct), but it won't in D since we don't have implicit construction.
Jan 18
prev sibling parent Adam D. Ruppe <destructionator gmail.com> writes:
On Thursday, 19 January 2017 at 02:35:08 UTC, Ignacious wrote:
 But this is alias this, the whole point of alias this is to 
 treat the type as as the alias?
No, alias this is for subtyping. Similar to a child class, a subtype can be used as its parent type, but must be constructed. class A {} class B : A {} A a = new B(); // legal, B will convert to A B a = new A(); // illegal, A is not B alias this is the same concept, just outside of class inheritance. https://en.wikipedia.org/wiki/Subtyping
 Yet, logically, 3 is convertible to Y(3rd line above) and Y is 
 appendable to X.
Wrong. Implicit construction and implicit conversion are different concepts in theory and in practice in every language I know. You often want them separately as construction may need additional state, may just not be logical, and may have a different runtime cost than substitution. D does not support implicit construction under any circumstance except the typesafe variadic syntax in function calls that take a single class. (I'd like to add it, but Walter doesn't agree..)
Jan 18