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() { } }
