Algebra With Types

[David Sanders via Digitalmars-d-learn]

I'm trying to do algebra with types ala 
http://chris-taylor.github.io/blog/2013/02/10/the-algebra-of-algebraic-data-types/

Below you will find my attempts at "adding" types in D. I've 
outlined the parts I'm having trouble with using block comments.

1) How do I figure out whether a type is an instantiation of 
std.variant.Algebraic?
2) If the type is Algebraic, how do I capture its AllowedTypes?

Thanks,
Dave

import std.variant;

alias Zero = void;

struct One{};

struct Sum(T, U) {
    static if (is(T == Zero)) {
        static if (is(U == Zero)) {
            alias type = Zero;
        }
        else {
            alias type = U;
        }
    } else static if (is(U == Zero)) {
        alias type = T;
    } else static if (/* T is Algebraic */) {
        static if (/* U is Algebraic */) {
            alias type = Algebraic!/* Concatenate T.AllowedTypes 
with U.AllowedTypes */
        } else {
            alias type = Algebraic!/* Concatenate T.AllowedTypes 
with U */
        }
    } else static if (/* U is Algebraic */) {
        alias type = Alegebraic!/* Concatenate T with 
U.AllowedTypes */
    } else {
        alias type = Algebraic!(T, U);
    }   
}

void main() {
    static assert (is(Zero == Sum!(Zero, Zero).type));
    static assert (is(One == Sum!(Zero, One).type));
    static assert (is(One == Sum!(One, Zero).type));
    static assert (is(Algebraic!(One, One) == Sum!(One, 
One).type));
    static assert (is(Algebraic!(One, One, One) == Sum!(Sum!(One, 
One).type, One).type));
}