Inheritance of purity

kenji hara at
Sat Feb 18 06:49:50 PST 2012

After some thoughts, I agree that inheritance of pure @safe, and
nothrow is good feature.
But I disagree to const inference, because const attribute interacts
with overloadings.

Kenji Hara

2012/2/17 Walter Bright <newshound2 at>:
> Given:
>    class A { void foo() { } }
>    class B : A { override pure void foo() { } }
> This works great, because is covariant with, meaning it can
> "tighten", or place more restrictions, on foo. But:
>    class A { pure void foo() { } }
>    class B : A { override void foo() { } }
> fails, because 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?

More information about the Digitalmars-d mailing list