Re: Algebra With Types

[Meta via Digitalmars-d-learn]

On Friday, 21 April 2017 at 18:54:38 UTC, David Sanders wrote:
Thank-you for your input. With your help, I was able to figure 
out number whether a type is an instantiation of 
std.variant.Algebraic.

Now, I need help on concatenating Template Sequence Parameters. 
See the block comments below.

Thanks,
Dave

import std.stdio;
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 (is(T _ == VariantN!V, V...)) {
                static if(is(U _ == VariantN!W, W...)) {
                        alias type = Algebraic!/* Concatenate V[1..$] with 
U[1..$] */
                } else {
                        alias type = Algebraic!/* Concatenate V[1..$] with U */
                }
        } else static if(is(U _ == VariantN!V, V...)) {
                alias type = Algebraic!/* Concatenate T with V[1..$] */
        } 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));
}

As an aside, there's a less convoluted way to do type-level 
arithmetic which is IMO also more concise and looks nicer. You 
don't have to mess around with Algebraic at all:

struct Zero;

struct Succ(N);

alias One = Succ!Zero;

alias Pred(N: Zero)        = Zero;
alias Pred(N: Succ!Np, Np) = Np;

alias Add(N1: Zero, N2: Zero) = Zero;
alias Add(N1,       N2: Zero) = N1;
alias Add(N1: Zero, N2)       = N2;
alias Add(N1,       N2)       = Add!(Succ!N1, Pred!N2);

void main()
{
    static assert(is(Pred!One == Zero));
    static assert(is(Succ!One == Succ!(Succ!Zero)));

    static assert(is(Add!(Zero, Zero) == Zero));
    static assert(is(Add!(Zero, One) == One));
    static assert(is(Add!(One, Zero) == One));
    static assert(is(Add!(One, One) == Succ!(Succ!(Zero))));

    alias Two = Succ!One;
    static assert(is(Add!(One, One) == Two));
    static assert(is(Add!(One, Two) == Succ!(Succ!(Succ!Zero))));

    static assert(is(Sub!(Zero, Zero) == Zero));
    static assert(is(Sub!(One, Zero) == One));
    static assert(is(Sub!(Zero, One) == Zero));
    static assert(is(Sub!(Two, One) == One));
    static assert(is(Sub!(One, Two) == Zero));
}

Implementing Mul, Div and the integer set is an exercise left to 
the reader.