#include <functional>
#include <memory>
#include <iostream>
#include <queue>

    template<class Sig>
    struct recursive;
    template<class R, class... As>
    struct recursive< R(As...) > {
      using base_type = std::function<R(recursive, As...)>;
    private:
      std::shared_ptr< base_type > base;
    public:
      
      template<typename...Ts>
      auto operator()(Ts&&... ts) const
      -> typename std::result_of< base_type( recursive, Ts... ) >::type
      {
        return (*base)(*this, std::forward<Ts>(ts)...);
      }

      recursive(recursive const&)=default;
      recursive(recursive&&)=default;
      recursive& operator=(recursive const&)=default;
      recursive& operator=(recursive &&)=default;
      recursive() = default;
      template<typename L, typename=typename std::result_of< L(recursive, As...) >::type>
      explicit recursive( L&& f ):
        base( std::make_shared<base_type>(std::forward<L>(f)))
      {}
      explicit operator bool() const { return base && *base; }
    };

typedef std::queue<std::function<void (void)>> my_queue;

std::function<void (int)> get_recursive_function(my_queue& queue) {
    // Closure to allow self-reference
    auto f = [&](recursive<void(int)> self, int recurse) {
        std::cout << recurse << std::endl;
    	queue.push( [self,recurse](){ self(recurse-1); } );
    };
    return recursive<void(int)>( f );
}

int main(int, char **) {
	my_queue queue;
    queue.push([&](){ get_recursive_function(queue)(10); } );

    while (!queue.empty()) {
        queue.front()();
        queue.pop();
    }
}