Sealed classes - would you want them in D?

[Piotr Mitana]

Hello,

I've recently thought of sealed classes (sealed as in Scala, not 
as in C#) and am thinking of writing a DIP for it. I decided to 
start this thread first though to gather some opinions on the 
topic.

For those who never coded Scala and don't know sealed classes: a 
sealed class is a class which can be only extended in the same 
source file.

     sealed class MyClass {}

Translating to D, a sealed class would could only be extended in 
the same module. Additionally I would suggest 
"sealed(some.package) MyClass {}" syntax for classes that could 
only be extended in the particular package.

In Scala an important value of sealed classes is that compiler 
knows that and can aid programmer in pattern matching by 
detecting the missed cases. However, there is another value I 
see: limiting the extension of classes.

Some time ago I was working on a simple CQRS library and created 
an Entity class, where I wanted only a few specific subtypes for 
it. The library is built over a few defined entity types and user 
is not able to create their own types (should extend the 
particular subtype instead). Sealing the Entity class could 
enable me to define the closed set of subtypes and prevent new 
direct subtype creation outside the library.

Combining sealed with final library developer can create a 
completely closed type hierarchy.

Any thoughts on that proposal?