Normalize void

[Yuxuan Shui]

Suppose I want to create a type to contain either a return value 
or an error, I could probably do something like this:

     struct Result(T, E) {
         bool is_err;
         union {
             T result;
             E error;
         }
     }

This will probably work fine, unless I don't need an error for 
some of the use cases (i.e. I want it to behave more like a 
Nullable). I can't just pass 'void' to 'E', because I can't 
define variable with type void. So I will have to:

     struct Result(T, E) {
         bool is_err;
         union {
             T result;
             static if (!is(E == void))
                 E error;
         }
     }

I hope you can see what I mean here: 'void' is a special case I 
need to explicitly handle in templates. And special cases are bad.

What I want is for 'void' to behave like a normal type. This is 
not a crazy idea. 'void' can be considered as a unit type[0] in 
type theory. Basically, it is a type that can hold exactly 1 
value (so you don't need any storage space to store it). And it 
exists in many programming languages.

D actually already partially have 'void' as a unit type. For 
example:

void a() { return a(); } // returning void in a void function

Why don't we make it consistent across the whole language?

Here is how 'void' would behave if we made it a unit type:

     void a; // fine
     pragma(msg, a.sizeof); // 0
     void b = a; // fine
     writeln(a); // prints something intelligent about void

     struct A {
         void placeholder; // fine
     }
     pragma(msg, A.sizeof); // 1, same as empty struct

[0]: https://en.wikipedia.org/wiki/Unit_type