#include <cstdio>
#include <boost/lambda/lambda.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <iostream>
	
using namespace std;
using namespace boost;
using namespace boost::lambda;

template <typename T, typename D>
class closure
{
    D d;
    T t;
public:
    closure(const T &t, const D &d) : d(d), t(t) {}
    T &get() { return t; }
};

template <typename T>
closure< boost::function<T(T)>,
boost::shared_ptr<T> > foo( T n_ ) {
    typedef boost::function<T(T)> fn;
    typedef boost::shared_ptr<T>  ptr;
    ptr n( new T(n_) );
    return closure<fn, ptr>(var(*n) += _1, n); }

typedef closure< boost::function<short(short)>,
boost::shared_ptr<short> > functor_short; typedef
closure< boost::function<char(char)>,
boost::shared_ptr<char> > functor_char;

int main()
{
    // start with one
    {
        functor_short accum = foo((short)1);
        cout << accum.get()(2) << " should be 3"
<< endl;
        cout << accum.get()(10) << " should be 13"
<< endl;
        functor_short accum2 = foo((short)101);
        cout << accum2.get()(2) << " should be
103" << endl;
        cout << accum2.get()(10) << " should be
113" << endl;
    }
    functor_char accum = foo((char)3);
    cout << (int)accum.get()(3) << " should be 6"
<< endl;
    cout << (int)accum.get()(13) << " should be
19" << endl;
}

I don’t have to remind you about what society thinks of guys who lisp do I?

accum = foo(1)
puts “#{accum[2]}”
puts “#{accum[10]}”