Compile-time LISP interpreter

/**
 * This thing SHOULD be Turing complete.
 */

/**
 * Symbol
 */
template <char val>
struct sym;

/**
 * Numeric value
 */
template <int val_>
struct val {
    static constexpr int value = val_;
    struct get { };
};

/**
 * Variable binding
 */
template <typename Name, typename Value>
struct var {
    typedef Value value;
};

/**
 * List
 */
template <typename... T>
struct list;

/**
 * Empty list
 */
typedef list<> nil;

/**
 * Quoted expr
 */
template <typename Expr>
struct quote;

/**
 * Lambda
 */
template <typename Closure, typename Params, typename Body>
struct lambda;

/**
 * C++ metafunction binding
 */
template <template <typename...> class Fun>
struct builtin;

/**
 * Variable environment
 */
template <typename Outer = void, typename... Vars>
class env {
    template <typename Name, typename... Vars2>
    struct do_get;

    template <typename Name, typename Var, typename... Rest>
    struct do_get<Name, Var, Rest...> {
        typedef typename do_get<Name, Rest...>::result result;
    };

    template <typename Name, typename Value, typename... Rest>
    struct do_get<Name, var<Name, Value>, Rest...> {
        typedef var<Name, Value> result;
    };

    template <typename Name>
    struct do_get<Name> {
        typedef typename Outer::template get<Name>::result result;
    };

  public:
    template <typename Name>
    struct get {
        typedef typename do_get<Name, Vars...>::result result;
    };
};

typedef sym<'i'> s_if;
typedef sym<'q'> s_quote;
typedef sym<'l'> s_lambda;
typedef sym<'d'> s_define;
typedef sym<'b'> s_begin;

template <typename Env, typename List>
struct eval;

/**
 * Evaluate (quote expr)
 */
template <typename Env, typename Expr>
struct eval<Env, list<s_quote, Expr>> {
    typedef Expr result;
};

/**
 * Evaluate (if cond then else)
 */
template <typename Env, typename Cond, typename Then, typename Else>
struct eval_if {
    typedef typename eval<Env, Then>::result result;
};

template <typename Env, typename Then, typename Else>
struct eval_if<Env, nil, Then, Else> {
    typedef typename eval<Env, Else>::result result;
};

template <typename Env, typename Cond, typename Then, typename Else>
struct eval<Env, list<s_if, Cond, Then, Else>> {
    typedef typename eval_if<Env, typename eval<Env, Cond>::result, Then, Else>::result result;
};

/**
 * Evaluate (lambda params body)
 */
template <typename Env, typename Params, typename Body>
struct eval<Env, list<s_lambda, Params, Body>> {
    typedef lambda<Env, Params, Body> result;
};

/**
 * Evaluate (define name value)
 */
template <typename Env, typename Name, typename Value>
struct eval<Env, list<s_define, Name, Value>> {
    typedef var<Name, typename eval<Env, Value>::result> result;
};

/**
 * Evaluate a value
 */
template <typename Env, int value>
struct eval<Env, val<value>> {
    typedef val<value> result;
};

/**
 * Look up symbol in environment
 */
template <typename Env, char name>
struct eval<Env, sym<name>> {
    typedef typename Env::template get<sym<name> >::result::value result;
};

/**
 * Evaluate definitions
 */
template <typename Env, typename Name, typename Value, typename... Rest>
struct eval<Env, list<list<s_define, Name, Value>, Rest...>> {
    typedef typename eval<
        env<Env, typename eval<Env, list<s_define, Name, Value> >::result>,
        list<Rest...>
        >::result result;
};

template <typename Env, typename Name, typename Value, typename Expr>
struct eval<Env, list<list<s_define, Name, Value>, Expr>> {
    typedef typename eval<
        env<Env, typename eval<Env, list<s_define, Name, Value> >::result>,
        Expr
        >::result result;
};

/**
 * Evaluate (function args*)
 */
template <typename Env, typename...>
struct eval_call;

template <typename Env, typename Closure, typename Body, typename... Params, typename... Args>
struct eval_call<Env, lambda<Closure, list<Params...>, Body>, Args...> {
    typedef typename eval<env<Closure, var<Params, Args>...>, Body>::result result;
};

template <typename Env, template<typename...> class Fun, typename... Args>
struct eval_call<Env, builtin<Fun>, Args...> {
    typedef typename Fun<typename eval<Env, Args>::result...>::result result;
};

template <typename Env, typename Fun, typename... Args>
struct eval<Env, list<Fun, Args...> > {
    typedef typename eval_call<
        Env,
        typename eval<Env, Fun>::result,
        typename eval<Env, Args>::result...>::result result;
};


/**
 * Return Then if cond, else Else
 */
template <bool cond, typename Then, typename Else>
struct if_ {
    typedef Then result;
};

template <typename Then, typename Else>
struct if_<false, Then, Else> {
    typedef Else result;
};

/**
 * Represent a compile-time string
 */
template <char... chars>
struct code;

template <typename code>
struct parse;

/**
 * Parse number or symbol
 */
template <char c, char... r>
struct parse<code<c, r...>> {
    typedef typename if_<'0' <= c && c <= '9', val<c-'0'>, sym<c> >::result result;
    typedef code<r...> rest;
    static std::string str() { return {c}; }
};

/**
 * Parse special forms
 */
template <char... r>
struct parse<code<'i', r...>> {
    typedef s_if result;
    typedef code<r...> rest;
};
template <char... r>
struct parse<code<'q', r...>> {
    typedef s_quote result;
    typedef code<r...> rest;
};
template <char... r>
struct parse<code<'l', r...>> {
    typedef s_lambda result;
    typedef code<r...> rest;
};
template <char... r>
struct parse<code<'d', r...>> {
    typedef s_define result;
    typedef code<r...> rest;
};

/**
 * Parse a list
 */
template <typename list, typename code>
struct parse_list;

template <typename... Elems, char... r>
struct parse_list<list<Elems...>, code<r...>> {
    typedef parse<code<r...> > elem;
    typedef parse_list<list<Elems..., typename elem::result>, typename elem::rest> list_;
    typedef typename list_::result result;
    typedef typename list_::rest rest;
};

template <typename... Elems, char... r>
struct parse_list<list<Elems...>, code<')', r...> > {
    typedef list<Elems...> result;
    typedef code<r...> rest;
};

template <char... r>
struct parse<code<'(', r...> > {
    typedef parse_list<list<>, code<r...> > list_;
    typedef typename list_::result result;
    typedef typename list_::rest rest;
};


/**
 * Builtin functions
 */

template <typename Lhs, typename Rhs>
struct add {
    typedef val<Lhs::value + Rhs::value> result;
};

template <typename Lhs, typename Rhs>
struct sub {
    typedef val<Lhs::value - Rhs::value> result;
};

template <typename Lhs, typename Rhs>
struct mul {
    typedef val<Lhs::value * Rhs::value> result;
};

template <typename Lhs, typename Rhs>
struct div_ {
    typedef val<Lhs::value / Rhs::value> result;
};

template <typename L, typename R>
struct eq {
    typedef nil result;
};

template <typename L>
struct eq<L, L> {
    typedef val<true> result;
};

template <typename List>
struct car;

template <typename H, typename... T>
struct car<list<H, T...>> {
    typedef H result;
};

template <typename List>
struct cdr;

template <typename H, typename... T>
struct cdr<list<H, T...>> {
    typedef list<T...> result;
};

typedef env<
    void,
    var<sym<'+'>, builtin<add> >,
    var<sym<'-'>, builtin<sub> >,
    var<sym<'*'>, builtin<mul> >,
    var<sym<'/'>, builtin<div_> >,
    var<sym<'='>, builtin<eq> >,
    var<sym<'h'>, builtin<car> >,
    var<sym<'t'>, builtin<cdr> >
    > globals;

/**
   ((define y 4)
    (define f (lambda (x) (* x x)))
    (f (* y 2)))
*/
typedef parse<code<
    '(','(','d','y','4',')',
        '(','d','f','(','l','(','x',')','(','*','x','x',')',')',')',
        '(','f','(','*','y','2',')',')',')'>> p;

constexpr int _ = eval<globals, p::result>::result::get::value;

/*
   g++ -std=c++0x eval2.cpp -c -Wall -pedantic && ./eval
   eval2.cpp:322:19: error: ‘value’ is not a member of ‘val<64>::get’
*/