C++STL内std::{bind/tuple/function}简单实现

/*
 * Author: SpringHack - springhack@live.cn
 * Last modified: 2020-02-19 10:16:17
 * Filename: main.cpp
 * Description: Created by SpringHack using vim automatically.
 */
#include 

namespace dosk { // begin namespace dosk

// function
template 
class function;

template 
class function {
 private:
  Result (*function_)(Args...);
 public:
  typedef Result return_type;
  function() = default;
  function(Result (*fn)(Args...)) : function_(fn) {};
  Result operator()(Args... a) {
   return function_(a...);
  }
  function& operator=(Result (*fn)(Args...)) {
   function_ = fn;
   return *this;
  }
};

// tuple
template 
class tuple;

template 
class tuple : public tuple {
 public:
  HEAD value;
  tuple(HEAD head, LIST... list) : tuple(list...), value(head) {};
};

template <>
class tuple<> {};

// tuple get
template 
class _tuple_type;

template 
class _tuple_type {
 public:
  typedef typename _tuple_type>::value_type value_type;
  typedef typename _tuple_type>::tuple_type tuple_type;
};

template 
class _tuple_type<0, tuple> {
 public:
  typedef HEAD value_type;
  typedef tuple tuple_type;
};

template 
typename _tuple_type::value_type get(tuple t) {
 typedef typename _tuple_type::value_type value_type;
 typedef typename _tuple_type::tuple_type tuple_type;
 value_type rv = ((tuple_type)t).value;
 return rv;
}

// bind
template 
class _tuple_index {};

template 
class _make_indexs : public _make_indexs {};

template
class _make_indexs<0, indexs...> {
 public:
  typedef _tuple_index index_type;
};

namespace placeholders {

template 
class _placeholders {};

_placeholders<0> _1;
_placeholders<1> _2;
_placeholders<2> _3;
_placeholders<3> _4;
_placeholders<4> _5;
_placeholders<5> _6;
_placeholders<6> _7;
_placeholders<7> _8;
_placeholders<8> _9;
_placeholders<9> _10;

template 
class _unwrap_tuple {
 public:
  tuple r_args; 
  _unwrap_tuple(tuple r_args) : r_args(r_args) {};
  template 
  R operator[](R r) {
   return r;
  }
  template 
  auto operator[](placeholders::_placeholders) {
   return get(r_args);
  }
};

};

template 
class bind_t {
 public:
  typedef typename _make_indexs::index_type _indexs;
  typedef typename Func::return_type return_type;
  Func func;
  tuple args;
  bind_t(Func func, Args... args): func(func), args(args...) {}
  template 
  return_type operator()(RArgs&&... _r_args) {
   tuple r_args = tuple(_r_args...);
   return run(_indexs(), r_args);
  }
  template 
  return_type run(_tuple_index, tuple r_args) {
   return func(unwrap_args(r_args)...);
  }
  template 
  auto unwrap_args(tuple r_args) {
   placeholders::_unwrap_tuple _u_a(r_args);
   auto _m_a = get(args);
   return _u_a[_m_a];
  }
};

template 
bind_t bind(Func& func, Args&&... args) {
 return bind_t(func, args...);
}

}; // end namespace dosk



// Test code
std::string test_func(int a, const char * b) {
 return std::to_string(a) + std::string(b);
}

std::string test_bind_args(int a, int b, int c, int d, int e) {
 return std::to_string(a) + std::to_string(b) + std::to_string(c) + std::to_string(d) + std::to_string(e);
}

int main() {
 // Test tuple
 dosk::tuple t(123, "456");
 std::cout <(t) <(t) < closure_1 = test_func;
 std::cout < closure_2 = test_bind_args;
 auto binder = dosk::bind(closure_2, 1, dosk::placeholders::_2, 3, dosk::placeholders::_1, 5);
 std::cout <