'strong types' a la boost

[Charles Cooper via Digitalmars-d-learn]

Interesting. I think in the second example there are pathological 
cases where one has similar declarations in two modules at the 
same line.

moduleA.d:100
alias dollars_t TypeDef!int;
moduleB.d:100
alias cents_t TypeDef!int;

main.d:
import moduleA;
import moduleB;
void write_dollars_to_database(dollars_t x) {
   /* code */
}
void main() {
   cents_t cents;
   write_dollars_to_database(cents); // compilation succeeds, bank 
fails
}

However, I see your point, I think it can be gotten around by 
using a combination of the __LINE__, __FILE__ and __MODULE__ 
directives!

Charles

On Saturday, 14 March 2015 at 16:01:15 UTC, Namespace wrote:
> You can do it this way:
> ----
> struct dollars_t {
>     uint _dollar;
>
>     this(uint d) {
>         _dollar = d;
>     }
>
>     alias _dollar this;
> }
>
> struct cents_t {
>     uint _cent;
>
>     this(uint c) {
>         _cent = c;
>     }
>
>     alias _cent this;
> }
>
> void do_something_with_dollars(dollars_t d) {
>     writeln(d);
> }
>
> void main() {
>     dollars_t d = 1;
>
>     do_something_with_dollars(d);
>
>     cents_t c = 2;
>
>     //do_something_with_dollars(c);
>     //do_something_with_dollars(2);
> }
> ----
>
> Or you can create your own small TypeDef:
>
> ----
> struct TypeDef(T, size_t l = __LINE__) {
>     T _val;
>
>     this(T v) {
>         _val = v;
>     }
>
>     alias _val this;
> }
>
> alias dollars_t = TypeDef!(uint);
> alias cents_t = TypeDef!(uint);
> ----
>
> Thanks to the second template parameter 'l' the template 
> instances of dollars_t and cents_t aren't equal.