rice 1.2.0 → 1.3.0

data/rice/detail/node.hpp

@@ -1,13 +1,13 @@
-#ifndef Rice__detail__node__hpp_
-#define Rice__detail__node__hpp_
-
-/**
- * Helper header for the node.h ruby include file, which does
- * not have extern "C"
- */
-
-extern "C" {
-  #include "node.h"
-}
-
-#endif
+#ifndef Rice__detail__node__hpp_
+#define Rice__detail__node__hpp_
+
+/**
+ * Helper header for the node.h ruby include file, which does
+ * not have extern "C"
+ */
+
+extern "C" {
+  #include "node.h"
+}
+
+#endif

data/rice/detail/ruby.hpp

@@ -65,6 +65,10 @@ extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
 #define RHASH_TBL(hsh) RHASH(hsh)->tbl
 #endif
 
+#ifndef RCLASS_M_TBL
+#define RCLASS_M_TBL(c) RCLASS(c)->m_tbl
+#endif
+
 // ruby.h has a few defines that conflict with Visual Studio's STL
 #if defined(_MSC_VER)
   #undef write

data/rice/detail/rubysig.hpp

@@ -1,19 +1,19 @@
-#ifndef Rice__detail__rubysig__hpp_
-#define Rice__detail__rubysig__hpp_
-
-#include "ruby_version_code.hpp"
-
-/**
- * Helper header for the rubysig.h ruby include file, which does
- * not have extern "C"
- */
-
-#if RICE__RUBY_VERSION_CODE < 190
-
-extern "C" {
-  #include "rubysig.h"
-}
-
-#endif
-
-#endif
+#ifndef Rice__detail__rubysig__hpp_
+#define Rice__detail__rubysig__hpp_
+
+#include "ruby_version_code.hpp"
+
+/**
+ * Helper header for the rubysig.h ruby include file, which does
+ * not have extern "C"
+ */
+
+#if RICE__RUBY_VERSION_CODE < 190
+
+extern "C" {
+  #include "rubysig.h"
+}
+
+#endif
+
+#endif

data/rice/detail/traits.hpp

@@ -0,0 +1,43 @@
+#ifndef Rice__detail__traits__hpp_
+#define Rice__detail__traits__hpp_
+
+namespace Rice
+{
+namespace detail
+{
+
+/**
+ * Remove const from a type
+ */
+template<typename T>
+struct remove_const { typedef T Type; };
+
+template<typename T>
+struct remove_const<const T> { typedef T Type; };
+
+/**
+ * Remove a reference from a type
+ */
+template<typename T>
+struct remove_ref { typedef T Type; };
+
+template<typename T>
+struct remove_ref<T &> { typedef T Type; };
+
+/**
+ * Do both of the above in one easy step
+ */
+template<typename T>
+struct sanitize
+{
+  typedef T Type;
+  //typedef typename remove_const< 
+    //typename remove_ref<T>::Type 
+    //>::Type Type;
+};
+
+}
+}
+
+
+#endif // Rice__detail__traits__hpp_

data/rice/generate_code.rb

@@ -124,7 +124,7 @@ docstring = <<END
 /*! E.g.:
  *  \\code
  *    VALUE x = protect(rb_ary_new);
- *    protect(rb_ary_push(x, INT2NUM(42));
+ *    protect(rb_ary_push, x, INT2NUM(42));
  *  \\endcode
  *
  *  Note that this function makes copies of all of its arguments; it
@@ -139,48 +139,64 @@ ipp_template = <<END
 namespace detail
 {
 
-template<typename Fun%(typenames)>
+template<typename Ret_T, typename Fun%(typenames)>
 class Ruby_Function_%(j)
 {
 public:
   Ruby_Function_%(j)(Fun f%(member_args));
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_%(j) * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   %(member_decls)
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun%(typenames)>
-inline Ruby_Function_%(j)<Fun%(types)>::
+template<typename Ret_T, typename Fun%(typenames)>
+inline Ruby_Function_%(j)<Ret_T, Fun%(types)>::
 Ruby_Function_%(j)(Fun f%(member_args))
   : f_(f)%(initializers)
 { }
 
-template<typename Fun%(typenames)>
-inline VALUE Ruby_Function_%(j)<Fun%(types)>::
+template<typename Ret_T, typename Fun%(typenames)>
+inline void Ruby_Function_%(j)<Ret_T, Fun%(types)>::
 operator()()
 {
-  return f_(%(member_params));
+  result_ = f_(%(member_params));
 }
 
-template<typename Fun%(typenames)>
-inline VALUE Ruby_Function_%(j)<Fun%(types)>::
+template<typename Ret_T, typename Fun%(typenames)>
+inline VALUE Ruby_Function_%(j)<Ret_T, Fun%(types)>::
 call(Ruby_Function_%(j) * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun%(typenames)>
+inline Ret_T protect(Fun fun%(args))
+{
+  typedef detail::Ruby_Function_%(j)<Ret_T, Fun%(types)> RF;
+  RF f(fun%(params));
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun%(typenames)>
 inline VALUE protect(Fun fun%(args))
 {
-  typedef detail::Ruby_Function_%(j)<Fun%(types)> RF;
+  typedef detail::Ruby_Function_%(j)<VALUE, Fun%(types)> RF;
   RF f(fun%(params));
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -521,6 +537,7 @@ ipp_head = <<END
 #include "method_data.hpp"
 #include "../ruby_try_catch.hpp"
 #include "../to_from_ruby.hpp"
+#include "traits.hpp"
 END
 ipp_tail = <<END
 template<typename Func_T, typename Ret_T>
@@ -669,11 +686,13 @@ wrap_header(hpp_filename, 'Rice::detail', docstring, true, hpp_head) do |hpp|
       scan_args_list = t_array.map { |x| ", &varg#{x}"}
       typenames     = t_array.map { |x| "Arg#{x}_T" }.join(', ')
       arg_convert_list  = t_array.map do |x|
-        "Arg#{x}_T arg#{x} = args->getArgumentOrDefault<Arg#{x}_T>(#{x}, varg#{x});"
+        "typedef typename sanitize< Arg#{x}_T >::Type Arg#{x}_Type;\n\t\t" +
+        "Arg#{x}_Type arg#{x} = args->getArgumentOrDefault<Arg#{x}_Type>(#{x}, varg#{x});"
       end.join("\n\t\t\t")
       self_arg_convert_list = (0...j).to_a.map do |x|
         n = x + 1
-        "Arg#{n}_T arg#{n} = args->getArgumentOrDefault<Arg#{n}_T>(#{x}, varg#{x});"
+        "typedef typename sanitize< Arg#{n}_T >::Type Arg#{n}_Type;\n\t\t" +
+        "Arg#{n}_Type arg#{n} = args->getArgumentOrDefault<Arg#{n}_Type>(#{x}, varg#{x});"
       end.join("\n\t\t\t")
       if j == MAX_ARGS then
         typename_list = t_array.map { |x| "typename Arg#{x}_T" }.join(', ')
@@ -1045,6 +1064,7 @@ ipp_head = <<END
 #include "method_data.hpp"
 #include "../ruby_try_catch.hpp"
 #include "../to_from_ruby.hpp"
+#include "traits.hpp"
 #include <typeinfo>
 END
 ipp_filename = 'detail/Auto_Member_Function_Wrapper.ipp'
@@ -1059,7 +1079,8 @@ wrap_header(hpp_filename, 'Rice::detail', docstring, true) do |hpp|
       typenames     = t_array.map { |x| ", Arg#{x}_T" }
       typenames_n   = t_array.map { |x| "Arg#{x}_T" }.join(', ')
       arg_convert_list  = t_array.map do |x|
-        "Arg#{x}_T arg#{x} = args->getArgumentOrDefault<Arg#{x}_T>(#{x}, varg#{x});"
+        "typedef typename sanitize< Arg#{x}_T >::Type Arg#{x}_Type;\n\t\t" +
+        "Arg#{x}_Type arg#{x} = args->getArgumentOrDefault<Arg#{x}_Type>(#{x}, varg#{x});"
       end.join("\n\t\t")
       if j == MAX_ARGS then
         typename_list = t_array.map { |x| ", typename Arg#{x}_T" }.join

data/rice/protect.hpp

@@ -21,7 +21,7 @@ namespace Rice
 /*! E.g.:
  *  \code
  *    VALUE x = protect(rb_ary_new);
- *    protect(rb_ary_push(x, INT2NUM(42));
+ *    protect(rb_ary_push, x, INT2NUM(42));
  *  \endcode
  *
  *  Note that this function makes copies of all of its arguments; it

data/rice/protect.ipp

@@ -14,48 +14,64 @@ namespace Rice
 namespace detail
 {
 
-template<typename Fun>
+template<typename Ret_T, typename Fun>
 class Ruby_Function_0
 {
 public:
   Ruby_Function_0(Fun f);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_0 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun>
-inline Ruby_Function_0<Fun>::
+template<typename Ret_T, typename Fun>
+inline Ruby_Function_0<Ret_T, Fun>::
 Ruby_Function_0(Fun f)
   : f_(f)
 { }
 
-template<typename Fun>
-inline VALUE Ruby_Function_0<Fun>::
+template<typename Ret_T, typename Fun>
+inline void Ruby_Function_0<Ret_T, Fun>::
 operator()()
 {
-  return f_();
+  result_ = f_();
 }
 
-template<typename Fun>
-inline VALUE Ruby_Function_0<Fun>::
+template<typename Ret_T, typename Fun>
+inline VALUE Ruby_Function_0<Ret_T, Fun>::
 call(Ruby_Function_0 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun>
+inline Ret_T protect(Fun fun)
+{
+  typedef detail::Ruby_Function_0<Ret_T, Fun> RF;
+  RF f(fun);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun>
 inline VALUE protect(Fun fun)
 {
-  typedef detail::Ruby_Function_0<Fun> RF;
+  typedef detail::Ruby_Function_0<VALUE, Fun> RF;
   RF f(fun);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -63,48 +79,64 @@ inline VALUE protect(Fun fun)
 namespace detail
 {
 
-template<typename Fun, typename T1>
+template<typename Ret_T, typename Fun, typename T1>
 class Ruby_Function_1
 {
 public:
   Ruby_Function_1(Fun f, T1 const & t1);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_1 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1>
-inline Ruby_Function_1<Fun, T1>::
+template<typename Ret_T, typename Fun, typename T1>
+inline Ruby_Function_1<Ret_T, Fun, T1>::
 Ruby_Function_1(Fun f, T1 const & t1)
   : f_(f), t1_(t1)
 { }
 
-template<typename Fun, typename T1>
-inline VALUE Ruby_Function_1<Fun, T1>::
+template<typename Ret_T, typename Fun, typename T1>
+inline void Ruby_Function_1<Ret_T, Fun, T1>::
 operator()()
 {
-  return f_(t1_);
+  result_ = f_(t1_);
 }
 
-template<typename Fun, typename T1>
-inline VALUE Ruby_Function_1<Fun, T1>::
+template<typename Ret_T, typename Fun, typename T1>
+inline VALUE Ruby_Function_1<Ret_T, Fun, T1>::
 call(Ruby_Function_1 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1>
+inline Ret_T protect(Fun fun, T1 const & t1)
+{
+  typedef detail::Ruby_Function_1<Ret_T, Fun, T1> RF;
+  RF f(fun, t1);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1>
 inline VALUE protect(Fun fun, T1 const & t1)
 {
-  typedef detail::Ruby_Function_1<Fun, T1> RF;
+  typedef detail::Ruby_Function_1<VALUE, Fun, T1> RF;
   RF f(fun, t1);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -112,48 +144,64 @@ inline VALUE protect(Fun fun, T1 const & t1)
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2>
+template<typename Ret_T, typename Fun, typename T1, typename T2>
 class Ruby_Function_2
 {
 public:
   Ruby_Function_2(Fun f, T1 const & t1, T2 const & t2);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_2 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2>
-inline Ruby_Function_2<Fun, T1, T2>::
+template<typename Ret_T, typename Fun, typename T1, typename T2>
+inline Ruby_Function_2<Ret_T, Fun, T1, T2>::
 Ruby_Function_2(Fun f, T1 const & t1, T2 const & t2)
   : f_(f), t1_(t1), t2_(t2)
 { }
 
-template<typename Fun, typename T1, typename T2>
-inline VALUE Ruby_Function_2<Fun, T1, T2>::
+template<typename Ret_T, typename Fun, typename T1, typename T2>
+inline void Ruby_Function_2<Ret_T, Fun, T1, T2>::
 operator()()
 {
-  return f_(t1_, t2_);
+  result_ = f_(t1_, t2_);
 }
 
-template<typename Fun, typename T1, typename T2>
-inline VALUE Ruby_Function_2<Fun, T1, T2>::
+template<typename Ret_T, typename Fun, typename T1, typename T2>
+inline VALUE Ruby_Function_2<Ret_T, Fun, T1, T2>::
 call(Ruby_Function_2 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2)
+{
+  typedef detail::Ruby_Function_2<Ret_T, Fun, T1, T2> RF;
+  RF f(fun, t1, t2);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2)
 {
-  typedef detail::Ruby_Function_2<Fun, T1, T2> RF;
+  typedef detail::Ruby_Function_2<VALUE, Fun, T1, T2> RF;
   RF f(fun, t1, t2);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -161,48 +209,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2)
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3>
 class Ruby_Function_3
 {
 public:
   Ruby_Function_3(Fun f, T1 const & t1, T2 const & t2, T3 const & t3);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_3 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3>
-inline Ruby_Function_3<Fun, T1, T2, T3>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3>
+inline Ruby_Function_3<Ret_T, Fun, T1, T2, T3>::
 Ruby_Function_3(Fun f, T1 const & t1, T2 const & t2, T3 const & t3)
   : f_(f), t1_(t1), t2_(t2), t3_(t3)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3>
-inline VALUE Ruby_Function_3<Fun, T1, T2, T3>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3>
+inline void Ruby_Function_3<Ret_T, Fun, T1, T2, T3>::
 operator()()
 {
-  return f_(t1_, t2_, t3_);
+  result_ = f_(t1_, t2_, t3_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3>
-inline VALUE Ruby_Function_3<Fun, T1, T2, T3>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3>
+inline VALUE Ruby_Function_3<Ret_T, Fun, T1, T2, T3>::
 call(Ruby_Function_3 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3)
+{
+  typedef detail::Ruby_Function_3<Ret_T, Fun, T1, T2, T3> RF;
+  RF f(fun, t1, t2, t3);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3)
 {
-  typedef detail::Ruby_Function_3<Fun, T1, T2, T3> RF;
+  typedef detail::Ruby_Function_3<VALUE, Fun, T1, T2, T3> RF;
   RF f(fun, t1, t2, t3);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -210,48 +274,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3)
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4>
 class Ruby_Function_4
 {
 public:
   Ruby_Function_4(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_4 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4>
-inline Ruby_Function_4<Fun, T1, T2, T3, T4>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4>
+inline Ruby_Function_4<Ret_T, Fun, T1, T2, T3, T4>::
 Ruby_Function_4(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4>
-inline VALUE Ruby_Function_4<Fun, T1, T2, T3, T4>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4>
+inline void Ruby_Function_4<Ret_T, Fun, T1, T2, T3, T4>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_);
+  result_ = f_(t1_, t2_, t3_, t4_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4>
-inline VALUE Ruby_Function_4<Fun, T1, T2, T3, T4>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4>
+inline VALUE Ruby_Function_4<Ret_T, Fun, T1, T2, T3, T4>::
 call(Ruby_Function_4 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4)
+{
+  typedef detail::Ruby_Function_4<Ret_T, Fun, T1, T2, T3, T4> RF;
+  RF f(fun, t1, t2, t3, t4);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4)
 {
-  typedef detail::Ruby_Function_4<Fun, T1, T2, T3, T4> RF;
+  typedef detail::Ruby_Function_4<VALUE, Fun, T1, T2, T3, T4> RF;
   RF f(fun, t1, t2, t3, t4);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -259,48 +339,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
 class Ruby_Function_5
 {
 public:
   Ruby_Function_5(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_5 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
-inline Ruby_Function_5<Fun, T1, T2, T3, T4, T5>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
+inline Ruby_Function_5<Ret_T, Fun, T1, T2, T3, T4, T5>::
 Ruby_Function_5(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
-inline VALUE Ruby_Function_5<Fun, T1, T2, T3, T4, T5>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
+inline void Ruby_Function_5<Ret_T, Fun, T1, T2, T3, T4, T5>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
-inline VALUE Ruby_Function_5<Fun, T1, T2, T3, T4, T5>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
+inline VALUE Ruby_Function_5<Ret_T, Fun, T1, T2, T3, T4, T5>::
 call(Ruby_Function_5 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5)
+{
+  typedef detail::Ruby_Function_5<Ret_T, Fun, T1, T2, T3, T4, T5> RF;
+  RF f(fun, t1, t2, t3, t4, t5);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5)
 {
-  typedef detail::Ruby_Function_5<Fun, T1, T2, T3, T4, T5> RF;
+  typedef detail::Ruby_Function_5<VALUE, Fun, T1, T2, T3, T4, T5> RF;
   RF f(fun, t1, t2, t3, t4, t5);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -308,48 +404,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 class Ruby_Function_6
 {
 public:
   Ruby_Function_6(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_6 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-inline Ruby_Function_6<Fun, T1, T2, T3, T4, T5, T6>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline Ruby_Function_6<Ret_T, Fun, T1, T2, T3, T4, T5, T6>::
 Ruby_Function_6(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-inline VALUE Ruby_Function_6<Fun, T1, T2, T3, T4, T5, T6>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline void Ruby_Function_6<Ret_T, Fun, T1, T2, T3, T4, T5, T6>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-inline VALUE Ruby_Function_6<Fun, T1, T2, T3, T4, T5, T6>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline VALUE Ruby_Function_6<Ret_T, Fun, T1, T2, T3, T4, T5, T6>::
 call(Ruby_Function_6 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6)
+{
+  typedef detail::Ruby_Function_6<Ret_T, Fun, T1, T2, T3, T4, T5, T6> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6)
 {
-  typedef detail::Ruby_Function_6<Fun, T1, T2, T3, T4, T5, T6> RF;
+  typedef detail::Ruby_Function_6<VALUE, Fun, T1, T2, T3, T4, T5, T6> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -357,48 +469,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 class Ruby_Function_7
 {
 public:
   Ruby_Function_7(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_7 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-inline Ruby_Function_7<Fun, T1, T2, T3, T4, T5, T6, T7>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+inline Ruby_Function_7<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7>::
 Ruby_Function_7(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-inline VALUE Ruby_Function_7<Fun, T1, T2, T3, T4, T5, T6, T7>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+inline void Ruby_Function_7<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-inline VALUE Ruby_Function_7<Fun, T1, T2, T3, T4, T5, T6, T7>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+inline VALUE Ruby_Function_7<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7>::
 call(Ruby_Function_7 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7)
+{
+  typedef detail::Ruby_Function_7<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7)
 {
-  typedef detail::Ruby_Function_7<Fun, T1, T2, T3, T4, T5, T6, T7> RF;
+  typedef detail::Ruby_Function_7<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -406,48 +534,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 class Ruby_Function_8
 {
 public:
   Ruby_Function_8(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_8 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-inline Ruby_Function_8<Fun, T1, T2, T3, T4, T5, T6, T7, T8>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+inline Ruby_Function_8<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8>::
 Ruby_Function_8(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-inline VALUE Ruby_Function_8<Fun, T1, T2, T3, T4, T5, T6, T7, T8>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+inline void Ruby_Function_8<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-inline VALUE Ruby_Function_8<Fun, T1, T2, T3, T4, T5, T6, T7, T8>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+inline VALUE Ruby_Function_8<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8>::
 call(Ruby_Function_8 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8)
+{
+  typedef detail::Ruby_Function_8<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8)
 {
-  typedef detail::Ruby_Function_8<Fun, T1, T2, T3, T4, T5, T6, T7, T8> RF;
+  typedef detail::Ruby_Function_8<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -455,48 +599,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 class Ruby_Function_9
 {
 public:
   Ruby_Function_9(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_9 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; T9 const & t9_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-inline Ruby_Function_9<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+inline Ruby_Function_9<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9>::
 Ruby_Function_9(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-inline VALUE Ruby_Function_9<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+inline void Ruby_Function_9<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-inline VALUE Ruby_Function_9<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+inline VALUE Ruby_Function_9<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9>::
 call(Ruby_Function_9 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9)
+{
+  typedef detail::Ruby_Function_9<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9)
 {
-  typedef detail::Ruby_Function_9<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9> RF;
+  typedef detail::Ruby_Function_9<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -504,48 +664,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
 class Ruby_Function_10
 {
 public:
   Ruby_Function_10(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_10 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; T9 const & t9_; T10 const & t10_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-inline Ruby_Function_10<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+inline Ruby_Function_10<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::
 Ruby_Function_10(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9), t10_(t10)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-inline VALUE Ruby_Function_10<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+inline void Ruby_Function_10<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-inline VALUE Ruby_Function_10<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+inline VALUE Ruby_Function_10<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::
 call(Ruby_Function_10 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10)
+{
+  typedef detail::Ruby_Function_10<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10)
 {
-  typedef detail::Ruby_Function_10<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> RF;
+  typedef detail::Ruby_Function_10<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -553,48 +729,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
 class Ruby_Function_11
 {
 public:
   Ruby_Function_11(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_11 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; T9 const & t9_; T10 const & t10_; T11 const & t11_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-inline Ruby_Function_11<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+inline Ruby_Function_11<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::
 Ruby_Function_11(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9), t10_(t10), t11_(t11)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-inline VALUE Ruby_Function_11<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+inline void Ruby_Function_11<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-inline VALUE Ruby_Function_11<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+inline VALUE Ruby_Function_11<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>::
 call(Ruby_Function_11 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11)
+{
+  typedef detail::Ruby_Function_11<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11)
 {
-  typedef detail::Ruby_Function_11<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> RF;
+  typedef detail::Ruby_Function_11<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -602,48 +794,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
 class Ruby_Function_12
 {
 public:
   Ruby_Function_12(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_12 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; T9 const & t9_; T10 const & t10_; T11 const & t11_; T12 const & t12_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-inline Ruby_Function_12<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+inline Ruby_Function_12<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::
 Ruby_Function_12(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9), t10_(t10), t11_(t11), t12_(t12)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-inline VALUE Ruby_Function_12<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+inline void Ruby_Function_12<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-inline VALUE Ruby_Function_12<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+inline VALUE Ruby_Function_12<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>::
 call(Ruby_Function_12 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12)
+{
+  typedef detail::Ruby_Function_12<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12)
 {
-  typedef detail::Ruby_Function_12<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> RF;
+  typedef detail::Ruby_Function_12<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -651,48 +859,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
 class Ruby_Function_13
 {
 public:
   Ruby_Function_13(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_13 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; T9 const & t9_; T10 const & t10_; T11 const & t11_; T12 const & t12_; T13 const & t13_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-inline Ruby_Function_13<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+inline Ruby_Function_13<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::
 Ruby_Function_13(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9), t10_(t10), t11_(t11), t12_(t12), t13_(t13)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-inline VALUE Ruby_Function_13<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+inline void Ruby_Function_13<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_, t13_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_, t13_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-inline VALUE Ruby_Function_13<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+inline VALUE Ruby_Function_13<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>::
 call(Ruby_Function_13 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13)
+{
+  typedef detail::Ruby_Function_13<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13)
 {
-  typedef detail::Ruby_Function_13<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> RF;
+  typedef detail::Ruby_Function_13<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -700,48 +924,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
 class Ruby_Function_14
 {
 public:
   Ruby_Function_14(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_14 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; T9 const & t9_; T10 const & t10_; T11 const & t11_; T12 const & t12_; T13 const & t13_; T14 const & t14_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-inline Ruby_Function_14<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+inline Ruby_Function_14<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::
 Ruby_Function_14(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9), t10_(t10), t11_(t11), t12_(t12), t13_(t13), t14_(t14)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-inline VALUE Ruby_Function_14<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+inline void Ruby_Function_14<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_, t13_, t14_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_, t13_, t14_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-inline VALUE Ruby_Function_14<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+inline VALUE Ruby_Function_14<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>::
 call(Ruby_Function_14 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14)
+{
+  typedef detail::Ruby_Function_14<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14)
 {
-  typedef detail::Ruby_Function_14<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> RF;
+  typedef detail::Ruby_Function_14<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------
@@ -749,48 +989,64 @@ inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 co
 namespace detail
 {
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
 class Ruby_Function_15
 {
 public:
   Ruby_Function_15(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14, T15 const & t15);
-  inline VALUE operator()();
+  inline void operator()();
   static inline VALUE call(Ruby_Function_15 * f);
+  Ret_T const & result() const { return result_; }
+
 private:
   Fun f_;
   T1 const & t1_; T2 const & t2_; T3 const & t3_; T4 const & t4_; T5 const & t5_; T6 const & t6_; T7 const & t7_; T8 const & t8_; T9 const & t9_; T10 const & t10_; T11 const & t11_; T12 const & t12_; T13 const & t13_; T14 const & t14_; T15 const & t15_; 
+  Ret_T result_; // TODO: use placement new
 };
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-inline Ruby_Function_15<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+inline Ruby_Function_15<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::
 Ruby_Function_15(Fun f, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14, T15 const & t15)
   : f_(f), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9), t10_(t10), t11_(t11), t12_(t12), t13_(t13), t14_(t14), t15_(t15)
 { }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-inline VALUE Ruby_Function_15<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+inline void Ruby_Function_15<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::
 operator()()
 {
-  return f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_, t13_, t14_, t15_);
+  result_ = f_(t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_, t10_, t11_, t12_, t13_, t14_, t15_);
 }
 
-template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-inline VALUE Ruby_Function_15<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+inline VALUE Ruby_Function_15<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>::
 call(Ruby_Function_15 * f)
 {
-  return (*f)();
+  (*f)();
+  return Qnil;
 }
 
 } // namespace detail
 
+template<typename Ret_T, typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+inline Ret_T protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14, T15 const & t15)
+{
+  typedef detail::Ruby_Function_15<Ret_T, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> RF;
+  RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15);
+  detail::protect(
+      RUBY_VALUE_FUNC(RF::call),
+      reinterpret_cast<VALUE>(&f));
+  return f.result();
+}
+
 template<typename Fun, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
 inline VALUE protect(Fun fun, T1 const & t1, T2 const & t2, T3 const & t3, T4 const & t4, T5 const & t5, T6 const & t6, T7 const & t7, T8 const & t8, T9 const & t9, T10 const & t10, T11 const & t11, T12 const & t12, T13 const & t13, T14 const & t14, T15 const & t15)
 {
-  typedef detail::Ruby_Function_15<Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> RF;
+  typedef detail::Ruby_Function_15<VALUE, Fun, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> RF;
   RF f(fun, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15);
-  return detail::protect(
+  detail::protect(
       RUBY_VALUE_FUNC(RF::call),
       reinterpret_cast<VALUE>(&f));
+  return f.result();
 }
 
 // ---------------------------------------------------------------------