class A
{
   void func(){ writefln("hello"); }
}

class B
{
   void func(){ A.func(cast(A)cast(void*)this); }  // sometimes people need this.
}

partial class is good, but it's likely to introduce a lot compiler bugs, and it's likely to increase the compile time.

multiple inheritance is also nice, also likely to introduce compiler bugs, and multiple inheritance
make the thing more obscure sometimes, while it needs to be clear.

the solution I proposed is simple and compact. It can solve all what partial class & MI can solve.
It won't much bring bad taste in syntax.



-- 
使用 Opera 革命性的电子邮件客户程序: http://www.opera.com/mail/

davidl wrote:
> class A
> {
>    void func(){ writefln("hello"); }
> }
> 
> class B
> {
>    void func(){ A.func(cast(A)cast(void*)this); }  // sometimes people need this.
> }
> 
> partial class is good, but it's likely to introduce a lot compiler bugs, and it's likely to increase the compile time.
> 
> multiple inheritance is also nice, also likely to introduce compiler bugs, and multiple inheritance
> make the thing more obscure sometimes, while it needs to be clear.
> 
> the solution I proposed is simple and compact. It can solve all what partial class & MI can solve.
> It won't much bring bad taste in syntax.

What about a static function in a class? Isn't that basically "treating class as name space only"?

L.

在 Thu, 07 Aug 2008 21:35:41 +0800，Lionello Lunesu <lio@lunesu.remove.com> 写道:

> davidl wrote:
>> class A
>> {
>>    void func(){ writefln("hello"); }
>> }
>>  class B
>> {
>>    void func(){ A.func(cast(A)cast(void*)this); }  // sometimes people need this.
>> }
>>  partial class is good, but it's likely to introduce a lot compiler bugs, and it's likely to increase the compile time.
>>  multiple inheritance is also nice, also likely to introduce compiler bugs, and multiple inheritance
>> make the thing more obscure sometimes, while it needs to be clear.
>>  the solution I proposed is simple and compact. It can solve all what partial class & MI can solve.
>> It won't much bring bad taste in syntax.
>
> What about a static function in a class? Isn't that basically "treating class as name space only"?
>
> L.

That can't do what MI do.

While the way I proposed can. Because you send the `this` pointer in



-- 
使用 Opera 革命性的电子邮件客户程序: http://www.opera.com/mail/

davidl a écrit :
> 在 Thu, 07 Aug 2008 21:35:41 +0800，Lionello Lunesu <lio@lunesu.remove.com> 写道:
> 
>> davidl wrote:
>>> class A
>>> {
>>>    void func(){ writefln("hello"); }
>>> }
>>>  class B
>>> {
>>>    void func(){ A.func(cast(A)cast(void*)this); }  // sometimes people need this.
>>> }
>>>  partial class is good, but it's likely to introduce a lot compiler bugs, and it's likely to increase the compile time.
>>>  multiple inheritance is also nice, also likely to introduce compiler bugs, and multiple inheritance
>>> make the thing more obscure sometimes, while it needs to be clear.
>>>  the solution I proposed is simple and compact. It can solve all what partial class & MI can solve.
>>> It won't much bring bad taste in syntax.
>>
>> What about a static function in a class? Isn't that basically "treating class as name space only"?
>>
>> L.
> 
> That can't do what MI do.
> 
> While the way I proposed can. Because you send the `this` pointer in

Can you give a good example where the thing you want to do is useful? I see it as a hack into the OO system.