#include <cstdio>
#include <cstdlib>
#include <string>
#include <vector>
#include <unistd.h>
#include <memory>

#include <boost/variant.hpp>


struct add_func;
struct sub_func;

template <typename T> class binary_op;

typedef boost::variant<double,
                       boost::recursive_wrapper<binary_op<add_func> >,
                       boost::recursive_wrapper<binary_op<sub_func> >
                       > expr_t;


template <typename T>
class binary_op {
public:
	// Constructor
	binary_op(const expr_t &l, const expr_t &r)
		: left(l),
		  right(r) { }
	
	expr_t left;
	expr_t right;
};


class evaluator : public boost::static_visitor<double> {
public:
	double operator()(double val) const {
		return val;
	}
	
	double operator()(const binary_op<add_func> &f) const {
		return boost::apply_visitor(*this, f.left)+
		       boost::apply_visitor(*this, f.right);
	}
	
	double operator()(const binary_op<sub_func> &f) const {
		return boost::apply_visitor(*this, f.left)-
		       boost::apply_visitor(*this, f.right);
	}
};


// Generate a random double
static double frand()
{
	long int lrand=random();
	return ((double)lrand);
}

// Used to recursively form a parse tree.  At each level, the left branch
// continues on, while the right one terminates in a leaf.
static expr_t get_expr(size_t depth, size_t maxdepth)
{
	if (depth>maxdepth) {
		return frand();
	}
	return binary_op<add_func>(get_expr(depth+1, maxdepth), frand());
}


static void dotest()
{
	expr_t result(get_expr(0, 10000));
	
	double val=boost::apply_visitor(evaluator(), result);
	printf("Resulting value: %f\n", val);
}


int main(void)
{
	dotest();
	
	return 0;
}