Aside the fact, that it's highly ambiguous, the programmers would
start forgetting to write that auto :-)
On Fri, Feb 17, 2012 at 4:35 PM, Piotr Szturmaj <bncr...@jadamspam.pl> wrote:
> Jonathan M Davis wrote:
>>
>> On Thursday, February 16, 2012 18:49:40 Walter Bright wrote:
>>>
>>> Given:
>>>
>>> class A { void foo() { } }
>>> class B : A { override pure void foo() { } }
>>>
>>> This works great, because B.foo is covariant with A.foo, meaning it can
>>> "tighten", or place more restrictions, on foo. But:
>>>
>>> class A { pure void foo() { } }
>>> class B : A { override void foo() { } }
>>>
>>> fails, because B.foo tries to loosen the requirements, and so is not
>>> covariant.
>>>
>>> Where this gets annoying is when the qualifiers on the base class
>>> function
>>> have to be repeated on all its overrides. I ran headlong into this when
>>> experimenting with making the member functions of class Object pure.
>>>
>>> So it occurred to me that an overriding function could *inherit* the
>>> qualifiers from the overridden function. The qualifiers of the overriding
>>> function would be the "tightest" of its explicit qualifiers and its
>>> overridden function qualifiers. It turns out that most functions are
>>> naturally pure, so this greatly eases things and eliminates annoying
>>> typing.
>>>
>>> I want do to this for @safe, pure, nothrow, and even const.
>>>
>>> I think it is semantically sound, as well. The overriding function body
>>> will
>>> be semantically checked against this tightest set of qualifiers.
>>>
>>> What do you think?
>>
>>
>> No. Absolutely not. I hate the fact that C++ does this with virtual. It
>> makes
>> it so that you have to constantly look at the base classes to figure out
>> what's
>> virtual and what isn't. It harms maintenance and code understandability.
>> And
>> now you want to do that with @safe, pure, nothrow, and const? Yuck.
>
>
> What about:
>
>
> class A { pure void foo() { } }
> class B : A { auto override void foo() { } }
--
Bye,
Gor Gyolchanyan.
