On Mon, 26 Jan 2009 01:14:10 +1300, Denis Koroskin <2korden@gmail.com> wrote:

> On Sun, 25 Jan 2009 15:06:23 +0300, Tim M <a@b.com> wrote:
>
>> On Mon, 26 Jan 2009 00:48:21 +1300, Tim M <a@b.com> wrote:
>>
>>> On Mon, 26 Jan 2009 00:18:28 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>>>
>>>> On Sun, 25 Jan 2009 08:38:18 +0300, Tim M <a@b.com> wrote:
>>>>
>>>>> On Sun, 25 Jan 2009 17:56:03 +1300, John Reimer <terminal.node@gmail.com> wrote:
>>>>>
>>>>>> Hello tim,
>>>>>>
>>>>>>> On Sun, 25 Jan 2009 16:43:55 +1300, John Reimer
>>>>>>> <terminal.node@gmail.com>  wrote:
>>>>>>>
>>>>>>>> With this code:
>>>>>>>>  --------------------------------
>>>>>>>>  module test5;
>>>>>>>>  interface I
>>>>>>>> {
>>>>>>>> void foo();
>>>>>>>> }
>>>>>>>> class A : I {
>>>>>>>> void foo() { }
>>>>>>>> }
>>>>>>>> class B : A, I
>>>>>>>> {
>>>>>>>> alias A.foo foo;
>>>>>>>> }
>>>>>>>> void main()
>>>>>>>> {
>>>>>>>> }
>>>>>>>> --------------------------------
>>>>>>>>  I get this error:
>>>>>>>>  --------------------------------
>>>>>>>>  class test5.B interface function I.foo is not implemented
>>>>>>>>  --------------------------------
>>>>>>>>  Does this make sense?  I mean, shouldn't the explicit reuse of A.foo
>>>>>>>> in  B be sufficient indication to the compiler that B is satisfying
>>>>>>>> the  contract I?   I'm hoping to make use of such subtleties in some
>>>>>>>> code,  but first I have to understand the reasoning behind this. :)
>>>>>>>>  Note that this works if I remove the interface I from B's declaration
>>>>>>>> --  ie "class B: A" -- since, in the D language, B is not required to
>>>>>>>> fulfull A's interface contract even though it inherits from it. -JJR
>>>>>>>>
>>>>>>> It look like the real bug is re-allowing B to implement interface I
>>>>>>> but
>>>>>>> sometimes bug do get reported differently. Why don't you remove I from
>>>>>>> B's
>>>>>>> declaration like you said that works. It actually says here
>>>>>>> http://www.digitalmars.com/d/1.0/interface.html "Classes cannot derive
>>>>>>> from an interface multiple times."
>>>>>>
>>>>>>
>>>>>> Yes, please check the link again (further down the page).    D allows you to reimplement the interface as long as class B provides a new implementation:
>>>>>>
>>>>>> "A reimplemented interface must implement all the interface functions, it does not inherit from a super class"...
>>>>>>
>>>>>> That probably could be stated a little more clearly, but that's what it says.  As for why I'm doing it, I assure you that there's a very specific reason why I'm trying this: it is a possible interfacing mechansim for ported software of a much more complicated nature than this simple reduction; I reduced it to this in order to try to understand potential iteractions between class and interface layers.  The question here was to figure out the reasoning behind the language design,  not necessarily whether I should be doing it or not. ;-)
>>>>>>
>>>>>> -JJR
>>>>>>
>>>>>>
>>>>>
>>>>>
>>>>> This works btw:
>>>>>
>>>>> module test;
>>>>>
>>>>> interface I
>>>>> {
>>>>>     void foo();
>>>>> }
>>>>>
>>>>> class A : I {
>>>>>     void foo() { }
>>>>> }
>>>>>
>>>>> class B : A,I
>>>>> {
>>>>>     void foo() { A.foo(); }
>>>>> }
>>>>>   void main()
>>>>> {
>>>>> }
>>>>>
>>>>
>>>> It is too verbose and makes twice an overhead. I'd like to avoid this solution.
>>>> In fact, I believe that class B : A, I {} should just work.
>>>>
>>>
>>>
>>> why? I think it is perfect how it is. You can either leave A as the class that implements I and B would implement it through inheritance or you can to re implement I define all new implementations and put in return super.foo(); where needed. It is also possible to reimplement one interface function without re implementing the whole interface.
>>
>> If you are really needing to write least code you could also do something like this but not very nice to read:
>>
>> module test;
>>
>>
>> template II(char[] func)
>> {
>>        const char[] II = "typeof(super." ~ func ~ "())" ~ " " ~ func ~ "() {  return super." ~ func ~ "(); }" ;
>> }
>>
>> interface I
>> {
>>        void foo();
>>        int bar();
>> }
>>
>> class A : I
>> {
>>        void foo() { }
>>        int bar() { return 1; }
>> }
>>
>>
>> class B : A,I
>> {
>>        //void foo() { return super.foo(); }
>>        mixin(II!("foo"));
>>        mixin(II!("bar"));
>> }
>>
>> void main()
>> {
>> }
>
> Not only I want to write less, I want my code be cleaner and run faster.
>
>> why? I think it is perfect how it is. You can either leave A as the class that implements I and B would implement it through inheritance or you can to re implement I define all new implementations and put in return super.foo(); where needed. It is also possible to reimplement one interface function without re implementing the whole interface.
>
> That what /my/ solution do.
>
> class B : A, I {}
>
> is *absolutely* same as
>
> class B : A, I
> {
>     override void foo() { super.foo(); }
>     override int bar() { return super.bar(); }
> }
>
> Except that when you call B.foo, there is no damn double virtual function call.
>
> B inherits all the functions from A implicitly. You stil may override any of the I interface functions if need be:
>
> class B : A, I
> {
>      override void foo() { ... }
>      // int bar() is inherited from A
> }
>
> Having B explicitly override all the base class virtual functions and forward them to A implementation just to make compiler happy is unintuitive and plain dumb to me.
>
> C# allows that and I see absolutely no reason why D doesn't.
>

I think you are missing somethinghere. Change the B definition from:

class B : A, I

to just:

class B : A

then interfaces become impicit.

On Sun, 25 Jan 2009 15:20:19 +0300, Tim M <a@b.com> wrote:

> On Mon, 26 Jan 2009 01:14:10 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>
>> On Sun, 25 Jan 2009 15:06:23 +0300, Tim M <a@b.com> wrote:
>>
>>> On Mon, 26 Jan 2009 00:48:21 +1300, Tim M <a@b.com> wrote:
>>>
>>>> On Mon, 26 Jan 2009 00:18:28 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>>>>
>>>>> On Sun, 25 Jan 2009 08:38:18 +0300, Tim M <a@b.com> wrote:
>>>>>
>>>>>> On Sun, 25 Jan 2009 17:56:03 +1300, John Reimer <terminal.node@gmail.com> wrote:
>>>>>>
>>>>>>> Hello tim,
>>>>>>>
>>>>>>>> On Sun, 25 Jan 2009 16:43:55 +1300, John Reimer
>>>>>>>> <terminal.node@gmail.com>  wrote:
>>>>>>>>
>>>>>>>>> With this code:
>>>>>>>>>  --------------------------------
>>>>>>>>>  module test5;
>>>>>>>>>  interface I
>>>>>>>>> {
>>>>>>>>> void foo();
>>>>>>>>> }
>>>>>>>>> class A : I {
>>>>>>>>> void foo() { }
>>>>>>>>> }
>>>>>>>>> class B : A, I
>>>>>>>>> {
>>>>>>>>> alias A.foo foo;
>>>>>>>>> }
>>>>>>>>> void main()
>>>>>>>>> {
>>>>>>>>> }
>>>>>>>>> --------------------------------
>>>>>>>>>  I get this error:
>>>>>>>>>  --------------------------------
>>>>>>>>>  class test5.B interface function I.foo is not implemented
>>>>>>>>>  --------------------------------
>>>>>>>>>  Does this make sense?  I mean, shouldn't the explicit reuse of A.foo
>>>>>>>>> in  B be sufficient indication to the compiler that B is satisfying
>>>>>>>>> the  contract I?   I'm hoping to make use of such subtleties in some
>>>>>>>>> code,  but first I have to understand the reasoning behind this. :)
>>>>>>>>>  Note that this works if I remove the interface I from B's declaration
>>>>>>>>> --  ie "class B: A" -- since, in the D language, B is not required to
>>>>>>>>> fulfull A's interface contract even though it inherits from it. -JJR
>>>>>>>>>
>>>>>>>> It look like the real bug is re-allowing B to implement interface I
>>>>>>>> but
>>>>>>>> sometimes bug do get reported differently. Why don't you remove I from
>>>>>>>> B's
>>>>>>>> declaration like you said that works. It actually says here
>>>>>>>> http://www.digitalmars.com/d/1.0/interface.html "Classes cannot derive
>>>>>>>> from an interface multiple times."
>>>>>>>
>>>>>>>
>>>>>>> Yes, please check the link again (further down the page).    D allows you to reimplement the interface as long as class B provides a new implementation:
>>>>>>>
>>>>>>> "A reimplemented interface must implement all the interface functions, it does not inherit from a super class"...
>>>>>>>
>>>>>>> That probably could be stated a little more clearly, but that's what it says.  As for why I'm doing it, I assure you that there's a very specific reason why I'm trying this: it is a possible interfacing mechansim for ported software of a much more complicated nature than this simple reduction; I reduced it to this in order to try to understand potential iteractions between class and interface layers.  The question here was to figure out the reasoning behind the language design,  not necessarily whether I should be doing it or not. ;-)
>>>>>>>
>>>>>>> -JJR
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> This works btw:
>>>>>>
>>>>>> module test;
>>>>>>
>>>>>> interface I
>>>>>> {
>>>>>>     void foo();
>>>>>> }
>>>>>>
>>>>>> class A : I {
>>>>>>     void foo() { }
>>>>>> }
>>>>>>
>>>>>> class B : A,I
>>>>>> {
>>>>>>     void foo() { A.foo(); }
>>>>>> }
>>>>>>   void main()
>>>>>> {
>>>>>> }
>>>>>>
>>>>>
>>>>> It is too verbose and makes twice an overhead. I'd like to avoid this solution.
>>>>> In fact, I believe that class B : A, I {} should just work.
>>>>>
>>>>
>>>>
>>>> why? I think it is perfect how it is. You can either leave A as the class that implements I and B would implement it through inheritance or you can to re implement I define all new implementations and put in return super.foo(); where needed. It is also possible to reimplement one interface function without re implementing the whole interface.
>>>
>>> If you are really needing to write least code you could also do something like this but not very nice to read:
>>>
>>> module test;
>>>
>>>
>>> template II(char[] func)
>>> {
>>>        const char[] II = "typeof(super." ~ func ~ "())" ~ " " ~ func ~ "() {  return super." ~ func ~ "(); }" ;
>>> }
>>>
>>> interface I
>>> {
>>>        void foo();
>>>        int bar();
>>> }
>>>
>>> class A : I
>>> {
>>>        void foo() { }
>>>        int bar() { return 1; }
>>> }
>>>
>>>
>>> class B : A,I
>>> {
>>>        //void foo() { return super.foo(); }
>>>        mixin(II!("foo"));
>>>        mixin(II!("bar"));
>>> }
>>>
>>> void main()
>>> {
>>> }
>>
>> Not only I want to write less, I want my code be cleaner and run faster.
>>
>>> why? I think it is perfect how it is. You can either leave A as the class that implements I and B would implement it through inheritance or you can to re implement I define all new implementations and put in return super.foo(); where needed. It is also possible to reimplement one interface function without re implementing the whole interface.
>>
>> That what /my/ solution do.
>>
>> class B : A, I {}
>>
>> is *absolutely* same as
>>
>> class B : A, I
>> {
>>     override void foo() { super.foo(); }
>>     override int bar() { return super.bar(); }
>> }
>>
>> Except that when you call B.foo, there is no damn double virtual function call.
>>
>> B inherits all the functions from A implicitly. You stil may override any of the I interface functions if need be:
>>
>> class B : A, I
>> {
>>      override void foo() { ... }
>>      // int bar() is inherited from A
>> }
>>
>> Having B explicitly override all the base class virtual functions and forward them to A implementation just to make compiler happy is unintuitive and plain dumb to me.
>>
>> C# allows that and I see absolutely no reason why D doesn't.
>>
>
> I think you are missing somethinghere. Change the B definition from:
>
> class B : A, I
>
> to just:
>
> class B : A
>
> then interfaces become impicit.

No, I don't:

class B : private A, public I
{
}

On Sun, 25 Jan 2009 17:06:50 +0300, Denis Koroskin <2korden@gmail.com> wrote:

> On Sun, 25 Jan 2009 15:20:19 +0300, Tim M <a@b.com> wrote:
>
>> On Mon, 26 Jan 2009 01:14:10 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>>
>>> On Sun, 25 Jan 2009 15:06:23 +0300, Tim M <a@b.com> wrote:
>>>
>>>> On Mon, 26 Jan 2009 00:48:21 +1300, Tim M <a@b.com> wrote:
>>>>
>>>>> On Mon, 26 Jan 2009 00:18:28 +1300, Denis Koroskin <2korden@gmail.com> wrote:
>>>>>
>>>>>> On Sun, 25 Jan 2009 08:38:18 +0300, Tim M <a@b.com> wrote:
>>>>>>
>>>>>>> On Sun, 25 Jan 2009 17:56:03 +1300, John Reimer <terminal.node@gmail.com> wrote:
>>>>>>>
>>>>>>>> Hello tim,
>>>>>>>>
>>>>>>>>> On Sun, 25 Jan 2009 16:43:55 +1300, John Reimer
>>>>>>>>> <terminal.node@gmail.com>  wrote:
>>>>>>>>>
>>>>>>>>>> With this code:
>>>>>>>>>>  --------------------------------
>>>>>>>>>>  module test5;
>>>>>>>>>>  interface I
>>>>>>>>>> {
>>>>>>>>>> void foo();
>>>>>>>>>> }
>>>>>>>>>> class A : I {
>>>>>>>>>> void foo() { }
>>>>>>>>>> }
>>>>>>>>>> class B : A, I
>>>>>>>>>> {
>>>>>>>>>> alias A.foo foo;
>>>>>>>>>> }
>>>>>>>>>> void main()
>>>>>>>>>> {
>>>>>>>>>> }
>>>>>>>>>> --------------------------------
>>>>>>>>>>  I get this error:
>>>>>>>>>>  --------------------------------
>>>>>>>>>>  class test5.B interface function I.foo is not implemented
>>>>>>>>>>  --------------------------------
>>>>>>>>>>  Does this make sense?  I mean, shouldn't the explicit reuse of A.foo
>>>>>>>>>> in  B be sufficient indication to the compiler that B is satisfying
>>>>>>>>>> the  contract I?   I'm hoping to make use of such subtleties in some
>>>>>>>>>> code,  but first I have to understand the reasoning behind this. :)
>>>>>>>>>>  Note that this works if I remove the interface I from B's declaration
>>>>>>>>>> --  ie "class B: A" -- since, in the D language, B is not required to
>>>>>>>>>> fulfull A's interface contract even though it inherits from it. -JJR
>>>>>>>>>>
>>>>>>>>> It look like the real bug is re-allowing B to implement interface I
>>>>>>>>> but
>>>>>>>>> sometimes bug do get reported differently. Why don't you remove I from
>>>>>>>>> B's
>>>>>>>>> declaration like you said that works. It actually says here
>>>>>>>>> http://www.digitalmars.com/d/1.0/interface.html "Classes cannot derive
>>>>>>>>> from an interface multiple times."
>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, please check the link again (further down the page).    D allows you to reimplement the interface as long as class B provides a new implementation:
>>>>>>>>
>>>>>>>> "A reimplemented interface must implement all the interface functions, it does not inherit from a super class"...
>>>>>>>>
>>>>>>>> That probably could be stated a little more clearly, but that's what it says.  As for why I'm doing it, I assure you that there's a very specific reason why I'm trying this: it is a possible interfacing mechansim for ported software of a much more complicated nature than this simple reduction; I reduced it to this in order to try to understand potential iteractions between class and interface layers.  The question here was to figure out the reasoning behind the language design,  not necessarily whether I should be doing it or not. ;-)
>>>>>>>>
>>>>>>>> -JJR
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> This works btw:
>>>>>>>
>>>>>>> module test;
>>>>>>>
>>>>>>> interface I
>>>>>>> {
>>>>>>>     void foo();
>>>>>>> }
>>>>>>>
>>>>>>> class A : I {
>>>>>>>     void foo() { }
>>>>>>> }
>>>>>>>
>>>>>>> class B : A,I
>>>>>>> {
>>>>>>>     void foo() { A.foo(); }
>>>>>>> }
>>>>>>>   void main()
>>>>>>> {
>>>>>>> }
>>>>>>>
>>>>>>
>>>>>> It is too verbose and makes twice an overhead. I'd like to avoid this solution.
>>>>>> In fact, I believe that class B : A, I {} should just work.
>>>>>>
>>>>>
>>>>>
>>>>> why? I think it is perfect how it is. You can either leave A as the class that implements I and B would implement it through inheritance or you can to re implement I define all new implementations and put in return super.foo(); where needed. It is also possible to reimplement one interface function without re implementing the whole interface.
>>>>
>>>> If you are really needing to write least code you could also do something like this but not very nice to read:
>>>>
>>>> module test;
>>>>
>>>>
>>>> template II(char[] func)
>>>> {
>>>>        const char[] II = "typeof(super." ~ func ~ "())" ~ " " ~ func ~ "() {  return super." ~ func ~ "(); }" ;
>>>> }
>>>>
>>>> interface I
>>>> {
>>>>        void foo();
>>>>        int bar();
>>>> }
>>>>
>>>> class A : I
>>>> {
>>>>        void foo() { }
>>>>        int bar() { return 1; }
>>>> }
>>>>
>>>>
>>>> class B : A,I
>>>> {
>>>>        //void foo() { return super.foo(); }
>>>>        mixin(II!("foo"));
>>>>        mixin(II!("bar"));
>>>> }
>>>>
>>>> void main()
>>>> {
>>>> }
>>>
>>> Not only I want to write less, I want my code be cleaner and run faster.
>>>
>>>> why? I think it is perfect how it is. You can either leave A as the class that implements I and B would implement it through inheritance or you can to re implement I define all new implementations and put in return super.foo(); where needed. It is also possible to reimplement one interface function without re implementing the whole interface.
>>>
>>> That what /my/ solution do.
>>>
>>> class B : A, I {}
>>>
>>> is *absolutely* same as
>>>
>>> class B : A, I
>>> {
>>>     override void foo() { super.foo(); }
>>>     override int bar() { return super.bar(); }
>>> }
>>>
>>> Except that when you call B.foo, there is no damn double virtual function call.
>>>
>>> B inherits all the functions from A implicitly. You stil may override any of the I interface functions if need be:
>>>
>>> class B : A, I
>>> {
>>>      override void foo() { ... }
>>>      // int bar() is inherited from A
>>> }
>>>
>>> Having B explicitly override all the base class virtual functions and forward them to A implementation just to make compiler happy is unintuitive and plain dumb to me.
>>>
>>> C# allows that and I see absolutely no reason why D doesn't.
>>>
>>
>> I think you are missing somethinghere. Change the B definition from:
>>
>> class B : A, I
>>
>> to just:
>>
>> class B : A
>>
>> then interfaces become impicit.
>
> No, I don't:
>
> class B : private A, public I
> {
> }
>
>

Other example:

interface IOStream : InputStream, OutputStream
{
}

class A : InputStream
{
  // implement InputStream
}

class B : A, IOStream
{
  // implement OutputStream interface *only*
}

You can't define B like this: class B : A, OutputStream { ... } because this way it won't be castable to IOStream.

>>>> [snip]
>>>>
>>>> B inherits all the functions from A implicitly. You stil may override any of the I interface functions if need be:
>>>>
>>>> class B : A, I
>>>> {
>>>>      override void foo() { ... }
>>>>      // int bar() is inherited from A
>>>> }
>>>>
>>>> Having B explicitly override all the base class virtual functions and forward them to A implementation just to make compiler happy is unintuitive and plain dumb to me.
>>>>
>>>> C# allows that and I see absolutely no reason why D doesn't.
>>>>
>>>
>>> I think you are missing somethinghere. Change the B definition from:
>>>
>>> class B : A, I
>>>
>>> to just:
>>>
>>> class B : A
>>>
>>> then interfaces become impicit.
>>
>> No, I don't:
>>
>> class B : private A, public I
>> {
>> }
>>
>>
> 
> Other example:
> 
> interface IOStream : InputStream, OutputStream
> {
> }
> 
> class A : InputStream
> {
>   // implement InputStream
> }
> 
> class B : A, IOStream
> {
>   // implement OutputStream interface *only*
> }
> 
> You can't define B like this: class B : A, OutputStream { ... } because this way it won't be castable to IOStream.
> 

I believe the rationale behind this is so that you can't implement an interface "by accident."  For example, you might be implementing an interface, miss one method, and not know because the base class implements it.

Alternately, you might be relying on such inheritance.  Then, the base class changes, and you're left with compile errors and wondering why it doesn't work.

Forcing you to specify each method removes this ambiguity from the code.

That said, I could have SWORN that aliasing a method from the superclass worked.  If this isn't a bug, it should be.

Personally, yes it is a bit tedious, but this is why we have templates and mixins...

  -- Daniel

It not a bug though. It's all here http://www.digitalmars.com/d/1.0/interface.html and it works like it says. Is there a problem?

Hello Daniel,

>>>>> [snip]
>>>>> 
>>>>> B inherits all the functions from A implicitly. You stil may
>>>>> override any of the I interface functions if need be:
>>>>> 
>>>>> class B : A, I
>>>>> {
>>>>> override void foo() { ... }
>>>>> // int bar() is inherited from A
>>>>> }
>>>>> Having B explicitly override all the base class virtual functions
>>>>> and forward them to A implementation just to make compiler happy
>>>>> is unintuitive and plain dumb to me.
>>>>> 
>>>>> C# allows that and I see absolutely no reason why D doesn't.
>>>>> 
>>>> I think you are missing somethinghere. Change the B definition
>>>> from:
>>>> 
>>>> class B : A, I
>>>> 
>>>> to just:
>>>> 
>>>> class B : A
>>>> 
>>>> then interfaces become impicit.
>>>> 
>>> No, I don't:
>>> 
>>> class B : private A, public I
>>> {
>>> }
>> Other example:
>> 
>> interface IOStream : InputStream, OutputStream
>> {
>> }
>> class A : InputStream
>> {
>> // implement InputStream
>> }
>> class B : A, IOStream
>> {
>> // implement OutputStream interface *only*
>> }
>> You can't define B like this: class B : A, OutputStream { ... }
>> because this way it won't be castable to IOStream.
>> 
> I believe the rationale behind this is so that you can't implement an
> interface "by accident."  For example, you might be implementing an
> interface, miss one method, and not know because the base class
> implements it.
> 
> Alternately, you might be relying on such inheritance.  Then, the base
> class changes, and you're left with compile errors and wondering why
> it doesn't work.
> 
> Forcing you to specify each method removes this ambiguity from the
> code.
> 
> That said, I could have SWORN that aliasing a method from the
> superclass worked.  If this isn't a bug, it should be.
> 
> Personally, yes it is a bit tedious, but this is why we have templates
> and mixins...
> 
> -- Daniel
> 


Yes, that seems to be the reason.  I actually want it to work the way it does, other than that I can't figure out why the aliasing doesn't work.  The way it works now, I'm not forced to implement A's Interface if I only inherit from A.  Explicit extension of a class with the same  interface is necessary, and I /think/ this is the way it should be... but I'll lay claim to the "I'm not an expert" clause. :)

-JJR
-JJR

Hello tim,

> On Mon, 26 Jan 2009 01:14:10 +1300, Denis Koroskin <2korden@gmail.com>
> wrote:
> 
>> On Sun, 25 Jan 2009 15:06:23 +0300, Tim M <a@b.com> wrote:
>> 
>>> On Mon, 26 Jan 2009 00:48:21 +1300, Tim M <a@b.com> wrote:
>>> 
>>>> On Mon, 26 Jan 2009 00:18:28 +1300, Denis Koroskin
>>>> <2korden@gmail.com>  wrote:
>>>> 
>>>>> On Sun, 25 Jan 2009 08:38:18 +0300, Tim M <a@b.com> wrote:
>>>>> 
>>>>>> On Sun, 25 Jan 2009 17:56:03 +1300, John Reimer
>>>>>> <terminal.node@gmail.com> wrote:
>>>>>> 
>>>>>>> Hello tim,
>>>>>>> 
>>>>>>>> On Sun, 25 Jan 2009 16:43:55 +1300, John Reimer
>>>>>>>> <terminal.node@gmail.com>  wrote:
>>>>>>>>> With this code:
>>>>>>>>> --------------------------------
>>>>>>>>> module test5;
>>>>>>>>> interface I
>>>>>>>>> {
>>>>>>>>> void foo();
>>>>>>>>> }
>>>>>>>>> class A : I {
>>>>>>>>> void foo() { }
>>>>>>>>> }
>>>>>>>>> class B : A, I
>>>>>>>>> {
>>>>>>>>> alias A.foo foo;
>>>>>>>>> }
>>>>>>>>> void main()
>>>>>>>>> {
>>>>>>>>> }
>>>>>>>>> --------------------------------
>>>>>>>>> I get this error:
>>>>>>>>> --------------------------------
>>>>>>>>> class test5.B interface function I.foo is not implemented
>>>>>>>>> --------------------------------
>>>>>>>>> Does this make sense?  I mean, shouldn't the explicit reuse of
>>>>>>>>> A.foo
>>>>>>>>> in  B be sufficient indication to the compiler that B is
>>>>>>>>> satisfying
>>>>>>>>> the  contract I?   I'm hoping to make use of such subtleties
>>>>>>>>> in
>>>>>>>>> some
>>>>>>>>> code,  but first I have to understand the reasoning behind
>>>>>>>>> this.
>>>>>>>>> :)
>>>>>>>>> Note that this works if I remove the interface I from B's
>>>>>>>>> declaration
>>>>>>>>> --  ie "class B: A" -- since, in the D language, B is not
>>>>>>>>> required to
>>>>>>>>> fulfull A's interface contract even though it inherits from
>>>>>>>>> it.
>>>>>>>>> -JJR
>>>>>>>> It look like the real bug is re-allowing B to implement
>>>>>>>> interface I
>>>>>>>> but
>>>>>>>> sometimes bug do get reported differently. Why don't you remove
>>>>>>>> I
>>>>>>>> from
>>>>>>>> B's
>>>>>>>> declaration like you said that works. It actually says here
>>>>>>>> http://www.digitalmars.com/d/1.0/interface.html "Classes cannot
>>>>>>>> derive
>>>>>>>> from an interface multiple times."
>>>>>>> Yes, please check the link again (further down the page).    D
>>>>>>> allows you to reimplement the interface as long as class B
>>>>>>> provides  a new implementation:
>>>>>>> 
>>>>>>> "A reimplemented interface must implement all the interface
>>>>>>> functions, it does not inherit from a super class"...
>>>>>>> 
>>>>>>> That probably could be stated a little more clearly, but that's
>>>>>>> what it says.  As for why I'm doing it, I assure you that
>>>>>>> there's a  very specific reason why I'm trying this: it is a
>>>>>>> possible  interfacing mechansim for ported software of a much
>>>>>>> more  complicated nature than this simple reduction; I reduced
>>>>>>> it to this  in order to try to understand potential iteractions
>>>>>>> between class  and interface layers.  The question here was to
>>>>>>> figure out the  reasoning behind the language design,  not
>>>>>>> necessarily whether I  should be doing it or not. ;-)
>>>>>>> 
>>>>>>> -JJR
>>>>>>> 
>>>>>> This works btw:
>>>>>> 
>>>>>> module test;
>>>>>> 
>>>>>> interface I
>>>>>> {
>>>>>> void foo();
>>>>>> }
>>>>>> class A : I {
>>>>>> void foo() { }
>>>>>> }
>>>>>> class B : A,I
>>>>>> {
>>>>>> void foo() { A.foo(); }
>>>>>> }
>>>>>> void main()
>>>>>> {
>>>>>> }
>>>>> It is too verbose and makes twice an overhead. I'd like to avoid
>>>>> this
>>>>> solution.
>>>>> In fact, I believe that class B : A, I {} should just work.
>>>> why? I think it is perfect how it is. You can either leave A as the
>>>> class that implements I and B would implement it through
>>>> inheritance  or you can to re implement I define all new
>>>> implementations and put in  return super.foo(); where needed. It is
>>>> also possible to reimplement  one interface function without re
>>>> implementing the whole interface.
>>>> 
>>> If you are really needing to write least code you could also do
>>> something like this but not very nice to read:
>>> 
>>> module test;
>>> 
>>> template II(char[] func)
>>> {
>>> const char[] II = "typeof(super." ~ func ~ "())" ~ " " ~ func ~
>>> "() {  return super." ~ func ~ "(); }" ;
>>> }
>>> interface I
>>> {
>>> void foo();
>>> int bar();
>>> }
>>> class A : I
>>> {
>>> void foo() { }
>>> int bar() { return 1; }
>>> }
>>> class B : A,I
>>> {
>>> //void foo() { return super.foo(); }
>>> mixin(II!("foo"));
>>> mixin(II!("bar"));
>>> }
>>> void main()
>>> {
>>> }
>> Not only I want to write less, I want my code be cleaner and run
>> faster.
>> 
>>> why? I think it is perfect how it is. You can either leave A as the
>>> class that implements I and B would implement it through inheritance
>>> or  you can to re implement I define all new implementations and put
>>> in  return super.foo(); where needed. It is also possible to
>>> reimplement  one interface function without re implementing the
>>> whole interface.
>>> 
>> That what /my/ solution do.
>> 
>> class B : A, I {}
>> 
>> is *absolutely* same as
>> 
>> class B : A, I
>> {
>> override void foo() { super.foo(); }
>> override int bar() { return super.bar(); }
>> }
>> Except that when you call B.foo, there is no damn double virtual
>> function call.
>> 
>> B inherits all the functions from A implicitly. You stil may override
>> any of the I interface functions if need be:
>> 
>> class B : A, I
>> {
>> override void foo() { ... }
>> // int bar() is inherited from A
>> }
>> Having B explicitly override all the base class virtual functions and
>> forward them to A implementation just to make compiler happy is
>> unintuitive and plain dumb to me.
>> 
>> C# allows that and I see absolutely no reason why D doesn't.
>> 
> I think you are missing somethinghere. Change the B definition from:
> 
> class B : A, I
> 
> to just:
> 
> class B : A
> 
> then interfaces become impicit.
> 


What do you mean?  In your example above, B does not have to implement the interface I of A.  What do you mean by "interfaces become implicit"?

-JJR

Hello tim,

> It not a bug though. It's all here
> http://www.digitalmars.com/d/1.0/interface.html and it works like it
> says.  Is there a problem?
> 


The only thing that might be close to a bug, I think, is the inability of the "alias" to satisfy the interface contract reimplementation.

-JJR

Denis Koroskin wrote:
> On Sun, 25 Jan 2009 08:38:18 +0300, Tim M <a@b.com> wrote:
>> class B : A,I
>> {
>>     void foo() { A.foo(); }
>> }
>>   void main()
>> {
>> }
>>
> 
> It is too verbose and makes twice an overhead. I'd like to avoid this solution.

Any reasonable compiler would inline the call to A.foo.

> In fact, I believe that class B : A, I {} should just work.

I think that's something like checked exceptions: a wonderful idea in small examples, but it can cause problems in larger bodies of code.

I haven't ever encountered this problem, but I've heard about it twice, I think, so maybe my coding is just a bit simpler than other people's.

On Mon, 26 Jan 2009 04:58:57 +1300, John Reimer <terminal.node@gmail.com> wrote:

> Hello tim,
>
>> On Mon, 26 Jan 2009 01:14:10 +1300, Denis Koroskin <2korden@gmail.com>
>> wrote:
>>
>>> On Sun, 25 Jan 2009 15:06:23 +0300, Tim M <a@b.com> wrote:
>>>
>>>> On Mon, 26 Jan 2009 00:48:21 +1300, Tim M <a@b.com> wrote:
>>>>
>>>>> On Mon, 26 Jan 2009 00:18:28 +1300, Denis Koroskin
>>>>> <2korden@gmail.com>  wrote:
>>>>>
>>>>>> On Sun, 25 Jan 2009 08:38:18 +0300, Tim M <a@b.com> wrote:
>>>>>>
>>>>>>> On Sun, 25 Jan 2009 17:56:03 +1300, John Reimer
>>>>>>> <terminal.node@gmail.com> wrote:
>>>>>>>
>>>>>>>> Hello tim,
>>>>>>>>
>>>>>>>>> On Sun, 25 Jan 2009 16:43:55 +1300, John Reimer
>>>>>>>>> <terminal.node@gmail.com>  wrote:
>>>>>>>>>> With this code:
>>>>>>>>>> --------------------------------
>>>>>>>>>> module test5;
>>>>>>>>>> interface I
>>>>>>>>>> {
>>>>>>>>>> void foo();
>>>>>>>>>> }
>>>>>>>>>> class A : I {
>>>>>>>>>> void foo() { }
>>>>>>>>>> }
>>>>>>>>>> class B : A, I
>>>>>>>>>> {
>>>>>>>>>> alias A.foo foo;
>>>>>>>>>> }
>>>>>>>>>> void main()
>>>>>>>>>> {
>>>>>>>>>> }
>>>>>>>>>> --------------------------------
>>>>>>>>>> I get this error:
>>>>>>>>>> --------------------------------
>>>>>>>>>> class test5.B interface function I.foo is not implemented
>>>>>>>>>> --------------------------------
>>>>>>>>>> Does this make sense?  I mean, shouldn't the explicit reuse of
>>>>>>>>>> A.foo
>>>>>>>>>> in  B be sufficient indication to the compiler that B is
>>>>>>>>>> satisfying
>>>>>>>>>> the  contract I?   I'm hoping to make use of such subtleties
>>>>>>>>>> in
>>>>>>>>>> some
>>>>>>>>>> code,  but first I have to understand the reasoning behind
>>>>>>>>>> this.
>>>>>>>>>> :)
>>>>>>>>>> Note that this works if I remove the interface I from B's
>>>>>>>>>> declaration
>>>>>>>>>> --  ie "class B: A" -- since, in the D language, B is not
>>>>>>>>>> required to
>>>>>>>>>> fulfull A's interface contract even though it inherits from
>>>>>>>>>> it.
>>>>>>>>>> -JJR
>>>>>>>>> It look like the real bug is re-allowing B to implement
>>>>>>>>> interface I
>>>>>>>>> but
>>>>>>>>> sometimes bug do get reported differently. Why don't you remove
>>>>>>>>> I
>>>>>>>>> from
>>>>>>>>> B's
>>>>>>>>> declaration like you said that works. It actually says here
>>>>>>>>> http://www.digitalmars.com/d/1.0/interface.html "Classes cannot
>>>>>>>>> derive
>>>>>>>>> from an interface multiple times."
>>>>>>>> Yes, please check the link again (further down the page).    D
>>>>>>>> allows you to reimplement the interface as long as class B
>>>>>>>> provides  a new implementation:
>>>>>>>>  "A reimplemented interface must implement all the interface
>>>>>>>> functions, it does not inherit from a super class"...
>>>>>>>>  That probably could be stated a little more clearly, but that's
>>>>>>>> what it says.  As for why I'm doing it, I assure you that
>>>>>>>> there's a  very specific reason why I'm trying this: it is a
>>>>>>>> possible  interfacing mechansim for ported software of a much
>>>>>>>> more  complicated nature than this simple reduction; I reduced
>>>>>>>> it to this  in order to try to understand potential iteractions
>>>>>>>> between class  and interface layers.  The question here was to
>>>>>>>> figure out the  reasoning behind the language design,  not
>>>>>>>> necessarily whether I  should be doing it or not. ;-)
>>>>>>>>  -JJR
>>>>>>>>
>>>>>>> This works btw:
>>>>>>>  module test;
>>>>>>>  interface I
>>>>>>> {
>>>>>>> void foo();
>>>>>>> }
>>>>>>> class A : I {
>>>>>>> void foo() { }
>>>>>>> }
>>>>>>> class B : A,I
>>>>>>> {
>>>>>>> void foo() { A.foo(); }
>>>>>>> }
>>>>>>> void main()
>>>>>>> {
>>>>>>> }
>>>>>> It is too verbose and makes twice an overhead. I'd like to avoid
>>>>>> this
>>>>>> solution.
>>>>>> In fact, I believe that class B : A, I {} should just work.
>>>>> why? I think it is perfect how it is. You can either leave A as the
>>>>> class that implements I and B would implement it through
>>>>> inheritance  or you can to re implement I define all new
>>>>> implementations and put in  return super.foo(); where needed. It is
>>>>> also possible to reimplement  one interface function without re
>>>>> implementing the whole interface.
>>>>>
>>>> If you are really needing to write least code you could also do
>>>> something like this but not very nice to read:
>>>>  module test;
>>>>  template II(char[] func)
>>>> {
>>>> const char[] II = "typeof(super." ~ func ~ "())" ~ " " ~ func ~
>>>> "() {  return super." ~ func ~ "(); }" ;
>>>> }
>>>> interface I
>>>> {
>>>> void foo();
>>>> int bar();
>>>> }
>>>> class A : I
>>>> {
>>>> void foo() { }
>>>> int bar() { return 1; }
>>>> }
>>>> class B : A,I
>>>> {
>>>> //void foo() { return super.foo(); }
>>>> mixin(II!("foo"));
>>>> mixin(II!("bar"));
>>>> }
>>>> void main()
>>>> {
>>>> }
>>> Not only I want to write less, I want my code be cleaner and run
>>> faster.
>>>
>>>> why? I think it is perfect how it is. You can either leave A as the
>>>> class that implements I and B would implement it through inheritance
>>>> or  you can to re implement I define all new implementations and put
>>>> in  return super.foo(); where needed. It is also possible to
>>>> reimplement  one interface function without re implementing the
>>>> whole interface.
>>>>
>>> That what /my/ solution do.
>>>  class B : A, I {}
>>>  is *absolutely* same as
>>>  class B : A, I
>>> {
>>> override void foo() { super.foo(); }
>>> override int bar() { return super.bar(); }
>>> }
>>> Except that when you call B.foo, there is no damn double virtual
>>> function call.
>>>  B inherits all the functions from A implicitly. You stil may override
>>> any of the I interface functions if need be:
>>>  class B : A, I
>>> {
>>> override void foo() { ... }
>>> // int bar() is inherited from A
>>> }
>>> Having B explicitly override all the base class virtual functions and
>>> forward them to A implementation just to make compiler happy is
>>> unintuitive and plain dumb to me.
>>>  C# allows that and I see absolutely no reason why D doesn't.
>>>
>> I think you are missing somethinghere. Change the B definition from:
>>  class B : A, I
>>  to just:
>>  class B : A
>>  then interfaces become impicit.
>>
>
>
> What do you mean?  In your example above, B does not have to implement the interface I of A.  What do you mean by "interfaces become implicit"?
>
> -JJR
>
>

I mean it will still have the foo function and you dont have to put anything on B to make it work:

module test;



interface I
{
      void foo();
}

class A : I
{
      void foo() { }
}


class B : A
{

}

void main()
{
      B b = new B;
      b.foo(); //this works
}