www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Implementing interface in the class hierarchy

reply Arek <arychlinski gmail.com> writes:
According to language reference (part 'Interfaces') this code 
will not compile:

interface D
{
     int foo();
}

class A : D
{
     int foo() { return 1; }
}

class B : A, D <- Error: class B interface function 'foo' is not 
implemented
{
}

Because: 'A reimplemented interface must implement all the 
interface functions, it does not inherit them from a super class'.

Why?

Each B object 'is an' A object (and each cat 'is an' animal) so 
if A implements D, then B implements D too. Implementing D second 
time doesn't change the nature of A and B.

More over, another example (more practical because here, the D 
interface is going to be implemented only once):

interface D
{
     int foo();
}

class A
{
     int foo() { return 1; }
}

class B : A, D <- Error: class B interface function 'foo' is not 
implemented
{
}

Class A doesn't implement D, but it has the method satisfied the 
D interface.

Why I have to provide the explicit implementation of 'foo' in B 
class?

I cannot logically explain this property of Dlang's OOP. Anyone 
could?

Thanks in advance.
Arek
Jul 14 2017
parent reply Steven Schveighoffer <schveiguy yahoo.com> writes:
On 7/14/17 7:04 AM, Arek wrote:

 According to language reference (part 'Interfaces') this code will not 
 compile:
 
 interface D
 {
      int foo();
 }
 
 class A : D
 {
      int foo() { return 1; }
 }
 
 class B : A, D <- Error: class B interface function 'foo' is not 
 implemented
 {
 }
 
 Because: 'A reimplemented interface must implement all the interface 
 functions, it does not inherit them from a super class'.
 
 Why?


Not sure what the use case is. Effectively, this is the same:

class B : A {}

D d = new B; // works


 Each B object 'is an' A object (and each cat 'is an' animal) so if A 
 implements D, then B implements D too. Implementing D second time 
 doesn't change the nature of A and B.
 
 More over, another example (more practical because here, the D interface 
 is going to be implemented only once):
 
 interface D
 {
      int foo();
 }
 
 class A
 {
      int foo() { return 1; }
 }
 
 class B : A, D <- Error: class B interface function 'foo' is not 
 implemented
 {
 }


This is a different story. I think it is technically possible for the 
compiler to make this connection (it needs to populate the I vtable with 
the right call w/ thunk), but I don't think there's a way to do it.

This doesn't work:

class B : A, D
{
    alias A.foo foo;
}

Relevant enhancement request:
https://issues.dlang.org/show_bug.cgi?id=2565

-Steve
Jul 14 2017
parent Arek <arychlinski gmail.com> writes:
On Friday, 14 July 2017 at 12:31:49 UTC, Steven Schveighoffer 
wrote:
<cut>

 Relevant enhancement request:
 https://issues.dlang.org/show_bug.cgi?id=2565

 -Steve


So it looks like there are no rational arguments for such a 
language specification, and this behavior is derived from some 
aspect of the compiler implementation.

Thanks

Arek
Jul 15 2017