peano fib template

fib.cpp

struct Z { 
  enum { ToInt = 0 };
};

template<typename T>
struct S { 
  enum { ToInt = sizeof(T) };
  T t;
  char c;
};

//Sum definition
//1. P(a,0) = a
//2. P(a,S(b)) = S(P(a,b))

template<typename A, typename B>
struct Sum { 
};

template<>
template<typename A>
struct Sum<A, Z> {
  typedef A value;
};

template<>
template<typename A, typename B>
struct Sum<A, S<B> > {
  typedef S<typename Sum<A, B>::value> value;
};

//Sub definition
//1. N(a,0) = a
//2. N(S(a),S(b)) = N(a, b)

template<typename A, typename B>
struct Sub { 
};

template<>
template<typename A>
struct Sub<A, Z> {
  typedef A value;
};

template<>
template<typename A, typename B>
struct Sub< S<A>, S<B> > {
  typedef typename Sub<A, B>::value value;
};

//Multiplication definition
//1. M(a,0) = 0
//2. M(a,S(b)) = P(a,M(a,b))
  
template<typename A, typename B>
struct Mult { 
};

template<>
template<typename A>
struct Mult<A, Z> {
  typedef Z value;
};

template<>
template<typename A, typename B>
struct Mult<A, S<B> > {
  typedef typename Sum<A, typename Mult<A, B>::value>::value value;
};

//Decimal representation definition
//There's no fun in doing this if you don't define arithmetic itself

typedef     Z    D0;
typedef S < D0 > D1;
typedef S < D1 > D2;
typedef S < D2 > D3;
typedef S < D3 > D4;
typedef S < D4 > D5;
typedef S < D5 > D6;
typedef S < D6 > D7;
typedef S < D7 > D8;
typedef S < D8 > D9;
typedef S < D9 > DA;

template<typename base, typename power, typename leastsignf, typename... digits>
struct AlKhwarizmi { 
  typedef typename Sum< 
    typename Mult<power, leastsignf>::value, 
    typename AlKhwarizmi<
      base, 
      typename Mult<base, power>::value, 
      digits...
    >::value
  >::value value;
};

template<>
template<typename base, typename power, typename leastsignf>
struct AlKhwarizmi<base, power, leastsignf> {
  typedef typename Mult<power, leastsignf>::value value;
};

//base 10 peano
template<typename... digits>
struct Decimal { 
  typedef typename AlKhwarizmi<DA, D1, digits...>::value value;
};

//Fibonnaci definition
//1. F(0) = 0
//2. F(1) = 1
//3. F(n) = F(n − 1) + F(n − 2)

template<typename X>
struct Fib { 
};

template<>
struct Fib<D0> {
  typedef D0 value;
};

template<>
struct Fib<D1> {
  typedef D1 value;
};

template<>
template<typename X>
struct Fib< S<X> > {
  typedef typename Sum<
    typename Fib<typename Sub<S<X>, D1>::value>::value, 
    typename Fib<typename Sub<S<X>, D2>::value>::value>::value value;
};

// typedef Decimal<D5>::value X;
// typedef Decimal<D3>::value Y;
// typedef Sub<X, Y>::value B;
// Fib(16)  this is little endian
typedef Decimal<D6, D1>::value A;
typedef Fib<A>::value B;
int k = B::ToInt;

#include <iostream>
int main(int argc, char** argv) {
  std::cout << k;
  return k;
}