Supertypes, subtypes, and more

[bearophile via Digitalmars-d]

In Phobos we have Typedef (that needs some improvements), that 
allows to define a not compatible type.

In D we have "alias this" that inside a struct allows to create a 
new type (with instance object of size equal or larger than the 
original type) with similar semantics of a given type. This 
allows to define a type that acts "like" another.

In Ada there is a standard way to restrict a type. In a Reddit 
thread I have found this simple example of modern Ada code, a 
sufficiently common need:


> My go-to example is social-security numbers, because it's simple
> enough that people can see what's going on as well as provides a
> good way to illustrate how subtypes can allow one to 'ignore'1
> the implementation.
>
> -- SSN format: ###-##-####
> Subtype Social_Security_Number is String(1..11)
>   with Dynamic_Predicate =>
>     (for all Index in Social_Security_Number'Range =>
>       (case Index is
>        when 4|7 => Social_Security_Number(Index) = '-',
>        when others => Social_Security_Number(Index) in '0'..'9'
>       )
>      );
>
> -- The above declaration can allows me to skip the validity
> -- checks of parameters within the body of a subprogram as
> -- the constraints are checked on subprogram-call.
> -- I do not need to check the validity of the return value,
> -- an attempt to return a non-conformant string will raise
> -- and exception.
> Function Get_SSN( Record : ID ) return Social_Security_Number;
>
> -- Likewise, passing a non-conformant value to SSN will raise
> -- an exception.
> Procedure Save_SSN( Record : ID; SSN : Social_Security_Number );


I think where you expect a String you can send a 
Social_Security_Number, but where it expects a 
Social_Security_Number it doesn't accept a String. (The 
Dynamic_Predicate and Static_Predicate of modern Ada allow to 
perform such restrictions.) So I think there are some analogies 
with OOP.

I'd like to do something like this in D, with structs/values.

Bye,
bearophile