• Namespace (11/11) Apr 29 2012 Based on my previous thread
• Simen Kjaeraas (3/13) Apr 29 2012 What do you mean restrict it?
• Namespace (22/38) Apr 29 2012 I mean that you can limit it similar as you can with templates.
• Simen Kjaeraas (11/48) Apr 29 2012 But that's not what happens. a1's compile-time type is A, so the compile...
• Namespace (3/63) Apr 29 2012 Yes, I've just noticed that. Are there already workarounds for

"Namespace" <rswhite4 googlemail.com> writes:

Based on my previous thread 
(http://forum.dlang.org/thread/rpcqefmyqigftxsgsqui forum.dlang.org), 
I got the question whether it is possible to restrict "alias 
this"?
Similar to templates function, e.g. "void foo(T)(T value) if 
(isNumeric!(T) ...", but it should be limited here so that it 
does not interact with the cast or something other.
As far as I know, "alias this" is an implicit cast. And just like 
an explicit cast (opCast) it should be possible to restrict it.

Otherwise, I have unfortunately run out of ideas how I can allow 
an implicit conversion.

"Simen Kjaeraas" <simen.kjaras gmail.com> writes:

On Sun, 29 Apr 2012 10:14:09 +0200, Namespace <rswhite4 googlemail.com>  
wrote:

 Based on my previous thread  
 (http://forum.dlang.org/thread/rpcqefmyqigftxsgsqui forum.dlang.org), I  
 got the question whether it is possible to restrict "alias this"?
 Similar to templates function, e.g. "void foo(T)(T value) if  
 (isNumeric!(T) ...", but it should be limited here so that it does not  
 interact with the cast or something other.
 As far as I know, "alias this" is an implicit cast. And just like an  
 explicit cast (opCast) it should be possible to restrict it.

 Otherwise, I have unfortunately run out of ideas how I can allow an  
 implicit conversion.

What do you mean restrict it?

"Namespace" <rswhite4 googlemail.com> writes:

On Sunday, 29 April 2012 at 11:24:00 UTC, Simen Kjaeraas wrote:
 On Sun, 29 Apr 2012 10:14:09 +0200, Namespace 
 <rswhite4 googlemail.com> wrote:

 Based on my previous thread 
 (http://forum.dlang.org/thread/rpcqefmyqigftxsgsqui forum.dlang.org), 
 I got the question whether it is possible to restrict "alias 
 this"?
 Similar to templates function, e.g. "void foo(T)(T value) if 
 (isNumeric!(T) ...", but it should be limited here so that it 
 does not interact with the cast or something other.
 As far as I know, "alias this" is an implicit cast. And just 
 like an explicit cast (opCast) it should be possible to 
 restrict it.

 Otherwise, I have unfortunately run out of ideas how I can 
 allow an implicit conversion.

 What do you mean restrict it?

I mean that you can limit it similar as you can with templates. 
In my code i'm using "alias this" to enable an implicit 
conversion from any class, e.g. Foo, to Ref!Foo. Ref is an struct 
which checks if the value of Foo is null. If it's null a error 
message will let you know, that you have a problem with one of 
your objects (i hate the access violation message, that's the 
original reason for that).

But if i cast with a class, that implements the implicit 
conversion, as in the following:

[code]
class A {
	mixin TRef!(A);
}

class B : A { }

A a1 = new B();

B b1 = cast(B) a1.access; // <- problem
[/code]

the cast will implicit convert with "alias this" to Ref!B. And 
that isn't what i want and neither what should happen. In this 
case a limit to "alias this" would be great. A limitation, that 
"alias this" must not convert the cast to Ref!B.

"Simen Kjaeraas" <simen.kjaras gmail.com> writes:

On Sun, 29 Apr 2012 14:28:05 +0200, Namespace <rswhite4 googlemail.com>  
wrote:

 On Sunday, 29 April 2012 at 11:24:00 UTC, Simen Kjaeraas wrote:
 On Sun, 29 Apr 2012 10:14:09 +0200, Namespace <rswhite4 googlemail.com>  
 wrote:

 Based on my previous thread  
 (http://forum.dlang.org/thread/rpcqefmyqigftxsgsqui forum.dlang.org),  
 I got the question whether it is possible to restrict "alias this"?
 Similar to templates function, e.g. "void foo(T)(T value) if  
 (isNumeric!(T) ...", but it should be limited here so that it does not  
 interact with the cast or something other.
 As far as I know, "alias this" is an implicit cast. And just like an  
 explicit cast (opCast) it should be possible to restrict it.

 Otherwise, I have unfortunately run out of ideas how I can allow an  
 implicit conversion.

 What do you mean restrict it?

 I mean that you can limit it similar as you can with templates. In my  
 code i'm using "alias this" to enable an implicit conversion from any  
 class, e.g. Foo, to Ref!Foo. Ref is an struct which checks if the value  
 of Foo is null. If it's null a error message will let you know, that you  
 have a problem with one of your objects (i hate the access violation  
 message, that's the original reason for that).

 But if i cast with a class, that implements the implicit conversion, as  
 in the following:

 [code]
 class A {
 	mixin TRef!(A);
 }

 class B : A { }

 A a1 = new B();

 B b1 = cast(B) a1.access; // <- problem
 [/code]

 the cast will implicit convert with "alias this" to Ref!B. And that  
 isn't what i want and neither what should happen. In this case a limit  
 to "alias this" would be great. A limitation, that "alias this" must not  
 convert the cast to Ref!B.

But that's not what happens. a1's compile-time type is A, so the compiler  
looks
up 'access' in A, but finds nothing. So it tries the alias this, gets a  
Ref!A,
and calls access on that. At this point, T is A, so access returns an A.

Then, the compiler tries to convert that A to a B, and gets confused. This  
is
absolutely a bug. In fact, it is the bug Jesse Phillips reported[1].


[1]: http://d.puremagic.com/issues/show_bug.cgi?id=8001

"Namespace" <rswhite4 googlemail.com> writes:

On Sunday, 29 April 2012 at 17:29:03 UTC, Simen Kjaeraas wrote:
 On Sun, 29 Apr 2012 14:28:05 +0200, Namespace 
 <rswhite4 googlemail.com> wrote:

 On Sunday, 29 April 2012 at 11:24:00 UTC, Simen Kjaeraas wrote:
 On Sun, 29 Apr 2012 10:14:09 +0200, Namespace 
 <rswhite4 googlemail.com> wrote:

 Based on my previous thread 
 (http://forum.dlang.org/thread/rpcqefmyqigftxsgsqui forum.dlang.org), 
 I got the question whether it is possible to restrict "alias 
 this"?
 Similar to templates function, e.g. "void foo(T)(T value) if 
 (isNumeric!(T) ...", but it should be limited here so that 
 it does not interact with the cast or something other.
 As far as I know, "alias this" is an implicit cast. And just 
 like an explicit cast (opCast) it should be possible to 
 restrict it.

 Otherwise, I have unfortunately run out of ideas how I can 
 allow an implicit conversion.

 What do you mean restrict it?

 I mean that you can limit it similar as you can with 
 templates. In my code i'm using "alias this" to enable an 
 implicit conversion from any class, e.g. Foo, to Ref!Foo. Ref 
 is an struct which checks if the value of Foo is null. If it's 
 null a error message will let you know, that you have a 
 problem with one of your objects (i hate the access violation 
 message, that's the original reason for that).

 But if i cast with a class, that implements the implicit 
 conversion, as in the following:

 [code]
 class A {
 	mixin TRef!(A);
 }

 class B : A { }

 A a1 = new B();

 B b1 = cast(B) a1.access; // <- problem
 [/code]

 the cast will implicit convert with "alias this" to Ref!B. And 
 that isn't what i want and neither what should happen. In this 
 case a limit to "alias this" would be great. A limitation, 
 that "alias this" must not convert the cast to Ref!B.

 But that's not what happens. a1's compile-time type is A, so 
 the compiler looks
 up 'access' in A, but finds nothing. So it tries the alias 
 this, gets a Ref!A,
 and calls access on that. At this point, T is A, so access 
 returns an A.

 Then, the compiler tries to convert that A to a B, and gets 
 confused. This is
 absolutely a bug. In fact, it is the bug Jesse Phillips 
 reported[1].


 [1]: http://d.puremagic.com/issues/show_bug.cgi?id=8001

Yes, I've just noticed that. Are there already workarounds for 
that problem?