Tristate - wanna?

[Andrei Alexandrescu]

While messing with std.allocator I explored the type below. I ended up 
not using it, but was surprised that implementing it was quite 
nontrivial. Should we add it to stdlib?

Theory: http://en.wikipedia.org/wiki/Three-state_logic

struct Tristate
{
     private ubyte value;
     private static Tristate make(ubyte b)
     {
         Tristate r = void;
         r.value = b;
         return r;
     }

     enum no = make(0), yes = make(1), unknown = make(4);

     this(bool b) { value = b; }

     void opAssign(bool b) { value = b; }

     Tristate opUnary(string s)() if (s == "~")
     {
         return this == unknown ? this : make(!value);
     }

     Tristate opBinary(string s)(Tristate rhs) if (s == "|")
     {
         // | yields 0, 1, 4, 5
         auto v = value | rhs.value;
         return v == 4 ? unknown : make(v & 1);
     }

     Tristate opBinary(string s)(Tristate rhs) if (s == "&")
     {
         // & yields 0, 1, 4
         return make(value & rhs.value);
     }

     Tristate opBinary(string s)(Tristate rhs) if (s == "^")
     {
         // + yields 0, 1, 2, 4, 5, 8
         auto v = value + rhs.value;
         return v >= 4 ? unknown : make(!!v);
     }
}

unittest
{
     Tristate a;
     assert(a == Tristate.no);
     static assert(!is(typeof({ if (a) {} })));
     assert(!is(typeof({ auto b = Tristate(3); })));
     a = true;
     assert(a == Tristate.yes);
     a = false;
     assert(a == Tristate.no);
     a = Tristate.unknown;
     Tristate b;
     b = a;
     assert(b == a);
     auto c = a | b;
     assert(c == Tristate.unknown);
     assert((a & b) == Tristate.unknown);
     a = true;
     assert(~a == Tristate.no);
     a = true;
     b = false;
     assert((a ^ b) == Tristate.yes);
}