c++ imperative templates 2.0

#pragma once
#include <cstdlib>

template<typename...> struct Prog;

template<size_t> struct Var;

template<typename, typename> struct Sum;
template<typename, typename> struct Mul;
template<typename, typename> struct Mod;
template<typename, typename> struct Less;
template<int N> struct Int {
    const static int value = N;
};

template<typename, typename> struct Assign;
template<typename> struct Return;
template<size_t> struct Label;
template<typename> struct Goto;
template<typename> struct If;
struct EndIf;
struct Else;

template<typename...> struct List;

template<typename H, typename... T> struct List<H, T...> {
    typedef H Head;
    typedef List<T...> Tail;
};

template<typename N, typename... P> struct PushFront;
template<typename N, typename... P> struct PushFront<N, List<P...>> {
    typedef List<N, P...> type;
};

template<typename Op, typename Next, typename Prog, typename Log> struct Calculation;

template<typename... Args> struct Prog {
    const static int value = Calculation<typename List<Args...>::Head, typename List<Args...>::Tail, List<Args...>, List<>>::value;
};

template<typename T, int v> struct _Assign;
template<typename Expression, typename Log> struct Eval;
template<typename A, typename B, typename Next, typename Prog, typename Log> struct Calculation<Assign<A, B>, Next, Prog, Log> {
    const static int value = Calculation<typename Next::Head, typename Next::Tail, Prog, typename PushFront<_Assign<A, Eval<B, Log>::value>, Log>::type>::value;
};

template<typename Expression, typename Next, typename Prog, typename Log> struct Calculation<Return<Expression>, Next, Prog, Log> {
    const static int value = Eval<Expression, Log>::value;
};

template<size_t N, typename Next, typename Prog, typename Log> struct Calculation<Label<N>, Next, Prog, Log> {
    const static int value = Calculation<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};

template<typename T, typename View, typename Prog, typename Log> struct CalculationGoto;
template<typename T, typename Next, typename Prog, typename Log> struct Calculation<Goto<T>, Next, Prog, Log> {
    const static int value = CalculationGoto<T, Prog, Prog, Log>::value;
};

template<int val, typename Next, typename Prog, typename Log> struct CalculationIf;
template<typename T, typename Next, typename Prog, typename Log> struct Calculation<If<T>, Next, Prog, Log> {
    const static int value = CalculationIf<Eval<T, Log>::value, Next, Prog, Log>::value;
};

template<typename Next, typename Prog, typename Log> struct Calculation<EndIf, Next, Prog, Log> {
    const static int value = Calculation<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};

template<typename Op, typename Next, typename Prog, typename Log> struct CalculationNoIf;
template<typename Next, typename Prog, typename Log> struct Calculation<Else, Next, Prog, Log> {
    const static int value = CalculationNoIf<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};


template<typename T, int v> struct _Assign {
    typedef T type;
    static const int value = v;
};

template<typename Var, typename Log> struct ValueOf {
    const static int value = ValueOf<Var, typename Log::Tail>::value;
};
template<typename Var, int val, typename... Args> struct ValueOf<Var, List<_Assign<Var, val>, Args...>> {
    const static int value = val;
};
template<typename Var> struct ValueOf<Var, List<>> {
    const static int value = 0;
};

template<typename First, typename Second, typename Log> struct Eval<Sum<First, Second>, Log> {
    const static int value = Eval<First, Log>::value + Eval<Second, Log>::value;
};
template<typename First, typename Second, typename Log> struct Eval<Mul<First, Second>, Log> {
    const static int value = Eval<First, Log>::value * Eval<Second, Log>::value;
};
template<typename First, typename Second, typename Log> struct Eval<Mod<First, Second>, Log> {
    const static int value = Eval<First, Log>::value % Eval<Second, Log>::value;
};
template<typename First, typename Second, typename Log> struct Eval<Less<First, Second>, Log> {
    const static int value = Eval<First, Log>::value < Eval<Second, Log>::value;
};
template<int N, typename Log> struct Eval<Int<N>, Log> {
    const static int value = N;
};
template<typename Var, typename Log> struct Eval {
    const static int value = ValueOf<Var, Log>::value;
};

template<typename T, typename View, typename Prog, typename Log> struct CalculationGoto {
    const static int value = CalculationGoto<T, typename View::Tail, Prog, Log>::value;
};
template<typename T, typename... ViewTail, typename Prog, typename Log> struct CalculationGoto<T, List<T, ViewTail...>, Prog, Log> {
    const static int value = Calculation<typename List<ViewTail...>::Head, typename List<ViewTail...>::Tail, Prog, Log>::value;
};

template<typename Op, typename Next, typename Prog, typename Log> struct CalculationNoIf {
    const static int value = CalculationNoIf<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};
template<typename Next, typename Prog, typename Log> struct CalculationNoIf<EndIf, Next, Prog, Log> {
    const static int value = Calculation<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};
template<typename Next, typename Prog, typename Log> struct CalculationNoIf<Else, Next, Prog, Log> {
    const static int value = Calculation<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};

template<int val, typename Next, typename Prog, typename Log> struct CalculationIf {
    const static int value = Calculation<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};
template<typename Next, typename Prog, typename Log> struct CalculationIf<0, Next, Prog, Log> {
    const static int value = CalculationNoIf<typename Next::Head, typename Next::Tail, Prog, Log>::value;
};








template<int N, int M> struct GCD {
    const static int value = Prog<
        Assign<Var<0>, Int<N>>,
        Assign<Var<1>, Int<M>>,
        Label<0>,
        If<Var<1>>,
            Assign<Var<3>, Var<1>>,
            Assign<Var<1>, Mod<Var<0>, Var<1>>>,
            Assign<Var<0>, Var<3>>,
            Goto<Label<0>>,
        EndIf,
        Return<Var<0>>
    >::value;
};

template<int N, int M> struct Max {
    const static int value = Prog<
        If<Less<Int<N>, Int<M>>>,
            Return<Int<M>>,
        Else,
            Return<Int<N>>,
        EndIf
    >::value;
};

template<int N> struct Factorial {
    const static int value = Prog<
        Assign<Var<0>, Int<N>>,
        Assign<Var<1>, Int<1>>,
        Label<0>,
        If<Var<0>>,
            Assign<Var<1>, Mul<Var<0>, Var<1>>>,
            Assign<Var<0>, Sum<Var<0>, Int<-1>>>,
            Goto<Label<0>>,
        EndIf,
        Return<Var<1>>
    >::value;
};
static_assert(GCD<2, 3>::value == 1, "gcd test");
static_assert(GCD<120, 18>::value == 6, "gcd test");
static_assert(Max<5, 10>::value == 10, "max second");
static_assert(Max<10, 5>::value == 10, "max first");
static_assert(Factorial<5>::value == 120, "factorial 5");