• Gor Gyolchanyan (5/5) Jul 27 2012 I have a small question: why aren't interfaces implicitly convertible to
• =?UTF-8?B?QWxleCBSw7hubmUgUGV0ZXJzZW4=?= (9/14) Jul 27 2012 I don't know if there's any particular reason, but for what it's worth:
• David Nadlinger (5/8) Jul 27 2012 Not all interfaces »originate« from D objects, they can also be
• Steven Schveighoffer (11/17) Aug 24 2012 to
• Chris Nicholson-Sauls (5/24) Aug 24 2012 Technically true, however COM is not the only example of foreign
• Steven Schveighoffer (14/40) Aug 27 2012 at>

Gor Gyolchanyan <gor.f.gyolchanyan gmail.com> writes:

I have a small question: why aren't interfaces implicitly convertible to
Object?

-- 
Bye,
Gor Gyolchanyan.

=?UTF-8?B?QWxleCBSw7hubmUgUGV0ZXJzZW4=?= <alex lycus.org> writes:

On 27-07-2012 16:56, Gor Gyolchanyan wrote:
 I have a small question: why aren't interfaces implicitly convertible to
 Object?

 --
 Bye,
 Gor Gyolchanyan.

I don't know if there's any particular reason, but for what it's worth: 
Casting an interface to Object means going through its vtable back to 
the original object location. In other words, it's not "free" (though 
the cost is extremely minimal).

-- 
Alex Rønne Petersen
alex lycus.org
http://lycus.org

"David Nadlinger" <see klickverbot.at> writes:

On Friday, 27 July 2012 at 14:56:18 UTC, Gor Gyolchanyan wrote:
 I have a small question: why aren't interfaces implicitly 
 convertible to
 Object?

Not all interfaces »originate« from D objects, they can also be 
COM interfaces. Using (cast(Object)foo) should work if foo is 
really an Object.

David

"Steven Schveighoffer" <schveiguy yahoo.com> writes:

On Fri, 27 Jul 2012 12:48:59 -0400, David Nadlinger <see klickverbot.at>=

wrote:

 On Friday, 27 July 2012 at 14:56:18 UTC, Gor Gyolchanyan wrote:
 I have a small question: why aren't interfaces implicitly convertible=


 to
 Object?

 Not all interfaces =C2=BBoriginate=C2=AB from D objects, they can also=

 be COM  =

 interfaces. Using (cast(Object)foo) should work if foo is really an  =

 Object.

All Com interfaces inherit from IUnknown.  This is statically known.

The idea that we cannot tell which interfaces are COM and which are norm=
al
is a myth.

There is no reason why interfaces (that aren't COM) shouldn't be
implicitly castable to Object.

-Steve

"Chris Nicholson-Sauls" <ibisbasenji gmail.com> writes:

On Friday, 24 August 2012 at 14:15:28 UTC, Steven Schveighoffer 
wrote:
 On Fri, 27 Jul 2012 12:48:59 -0400, David Nadlinger 
 <see klickverbot.at>
 wrote:

 On Friday, 27 July 2012 at 14:56:18 UTC, Gor Gyolchanyan wrote:
 I have a small question: why aren't interfaces implicitly 
 convertible to
 Object?

 Not all interfaces »originate« from D objects, they can also 
 be COM interfaces. Using (cast(Object)foo) should work if foo 
 is really an Object.

 All Com interfaces inherit from IUnknown.  This is statically 
 known.

 The idea that we cannot tell which interfaces are COM and which 
 are normal
 is a myth.

 There is no reason why interfaces (that aren't COM) shouldn't be
 implicitly castable to Object.

 -Steve

Technically true, however COM is not the only example of foreign 
objects used via interfaces.  The (limited) C++ compatibility, 
for example, works this way.

"Steven Schveighoffer" <schveiguy yahoo.com> writes:

On Fri, 24 Aug 2012 22:01:51 -0400, Chris Nicholson-Sauls  =

<ibisbasenji gmail.com> wrote:

 On Friday, 24 August 2012 at 14:15:28 UTC, Steven Schveighoffer wrote:=

 On Fri, 27 Jul 2012 12:48:59 -0400, David Nadlinger <see klickverbot.=


at>
 wrote:

 On Friday, 27 July 2012 at 14:56:18 UTC, Gor Gyolchanyan wrote:
 I have a small question: why aren't interfaces implicitly convertib=




le  =

 to
 Object?

 Not all interfaces =C2=BBoriginate=C2=AB from D objects, they can al=



so be COM  =

 interfaces. Using (cast(Object)foo) should work if foo is really an =



 =

 Object.

 All Com interfaces inherit from IUnknown.  This is statically known.

 The idea that we cannot tell which interfaces are COM and which are  =


 normal
 is a myth.

 There is no reason why interfaces (that aren't COM) shouldn't be
 implicitly castable to Object.

 -Steve

 Technically true, however COM is not the only example of foreign objec=

ts  =

 used via interfaces.  The (limited) C++ compatibility, for example,  =

 works this way.

Those are extern(C++), also statically known.

In fact, the very nature of how interfaces work makes it very difficult =
 =

for us to *not* statically know that an interface is a D interface -- D'=
s  =

implementation of interfaces is not like any others.

-Steve