From 8ef3ceb8a00c3c7d538414948867a362e4204dec Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 16:27:20 -0500
Subject: [PATCH 1/8] New test cases for the order of returns. Apparently, its
 screwing up between both lua and C++. Have to test thoroughly. Changes
 currently are half-working.

---
 sol/function.hpp     |  2 +-
 sol/lua_function.hpp | 69 +++++++++++++++++++++++++++++---------------
 sol/stack.hpp        | 35 +++++++++++++++++++++-
 sol/tuple.hpp        | 11 ++++++-
 tests.cpp            | 15 ++++++++++
 5 files changed, 105 insertions(+), 27 deletions(-)

diff --git a/sol/function.hpp b/sol/function.hpp
index 1f60a257..aac52037 100644
--- a/sol/function.hpp
+++ b/sol/function.hpp
@@ -36,7 +36,7 @@ private:
     template<typename... Ret>
     std::tuple<Ret...> invoke(types<Ret...>, std::size_t n) {
         luacall(n, sizeof...(Ret));
-        return stack::pop_call(state(), std::make_tuple<Ret...>, types<Ret...>());
+        return stack::pop_reverse_call(state(), std::make_tuple<Ret...>, types<Ret...>());
     }
 
     template<typename Ret>
diff --git a/sol/lua_function.hpp b/sol/lua_function.hpp
index 89c56614..0d278f7b 100644
--- a/sol/lua_function.hpp
+++ b/sol/lua_function.hpp
@@ -62,6 +62,11 @@ template<typename TFx>
 struct static_lua_func {
     typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type fx_t;
     typedef function_traits<fx_t> fx_traits;
+    
+    template<typename... Args>
+    static int typed_call(types<>, types<Args...> t, fx_t* fx, lua_State* L) {
+        return (*this)(types<void>(), t, fx, L);
+    }
 
     template<typename... Args>
     static int typed_call(types<void>, types<Args...> t, fx_t* fx, lua_State* L) {
@@ -69,11 +74,11 @@ struct static_lua_func {
         return 0;
     }
 
-    template<typename... TRn, typename... Args>
-    static int typed_call(types<TRn...>, types<Args...> t, fx_t* fx, lua_State* L) {
+    template<typename... Ret, typename... Args>
+    static int typed_call(types<Ret...>, types<Args...> t, fx_t* fx, lua_State* L) {
         auto r = stack::pop_call(L, fx, t);
-        stack::push(L, std::move(r));
-        return sizeof...(TRn);
+        stack::push_reverse(L, std::move(r));
+        return sizeof...(Ret);
     }
 
     static int call(lua_State* L) {
@@ -101,9 +106,9 @@ struct static_object_lua_func {
         return 0;
     }
 
-    template<typename TR, typename... Args>
-    static int typed_call(types<TR>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
-        auto fx = [&item, &ifx](Args&&... args) -> TR { 
+    template<typename Ret, typename... Args>
+    static int typed_call(types<Ret>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
+        auto fx = [&item, &ifx](Args&&... args) -> Ret { 
            return (item.*ifx)(std::forward<Args>(args)...); 
         };
         auto r = stack::pop_call(L, fx, types<Args...>());
@@ -111,12 +116,12 @@ struct static_object_lua_func {
         return 1;
     }
 
-    template<typename... TRn, typename... Args>
-    static int typed_call(types<TRn...>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
-        auto fx = [&item, &ifx](Args&&... args) -> std::tuple<TRn...> { return (item.*ifx)(std::forward<Args>(args)...); };
+    template<typename... Ret, typename... Args>
+    static int typed_call(types<Ret...>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
+        auto fx = [&item, &ifx](Args&&... args) -> std::tuple<Ret...> { return (item.*ifx)(std::forward<Args>(args)...); };
         auto r = stack::pop_call(L, fx, types<Args...>());
-        stack::push(L, std::move(r));
-        return sizeof...(TRn);
+        stack::push_reverse(L, std::move(r));
+        return sizeof...(Ret);
     }
 
     static int call(lua_State* L) {
@@ -182,17 +187,23 @@ struct lambda_lua_func : public lua_func {
         return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
     }
 
+    template<typename... Args>
+    int operator()(types<>, types<Args...> t, lua_State* L) {
+        stack::pop_call(L, fx, t);
+        return 0;
+    }
+
     template<typename... Args>
     int operator()(types<void>, types<Args...> t, lua_State* L) {
         stack::pop_call(L, fx, t);
         return 0;
     }
 
-    template<typename... TRn, typename... Args>
-    int operator()(types<TRn...>, types<Args...> t, lua_State* L) {
+    template<typename... Ret, typename... Args>
+    int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
         auto r = stack::pop_call(L, fx, t);
-        stack::push(L, r);
-        return sizeof...(TRn);
+        stack::push_reverse(L, r);
+        return sizeof...(Ret);
     }
 };
 
@@ -209,17 +220,22 @@ struct explicit_lua_func : public lua_func {
         return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
     }
 
+    template<typename... Args>
+    int operator()(types<>, types<Args...> t, lua_State* L) {
+        return (*this)(types<void>(), t, L);
+    }
+
     template<typename... Args>
     int operator()(types<void>, types<Args...> t, lua_State* L) {
         stack::pop_call(L, fx, t);
         return 0;
     }
 
-    template<typename... TRn, typename... Args>
-    int operator()(types<TRn...>, types<Args...> t, lua_State* L) {
+    template<typename... Ret, typename... Args>
+    int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
         auto r = stack::pop_call(L, fx, t);
-        stack::push(L, std::move(r));
-        return sizeof...(TRn);
+        stack::push_reverse(L, std::move(r));
+        return sizeof...(Ret);
     }
 };
 
@@ -247,17 +263,22 @@ struct explicit_lua_func<TFx, T, true> : public lua_func {
         return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
     }
 
+    template<typename... Args>
+    int operator()(types<>, types<Args...> t, lua_State* L) {
+        return (*this)(types<void>(), t, L);
+    }
+
     template<typename... Args>
     int operator()(types<void>, types<Args...> t, lua_State* L) {
         stack::pop_call(L, fx, t);
         return 0;
     }
 
-    template<typename... TRn, typename... Args>
-    int operator()(types<TRn...>, types<Args...> t, lua_State* L) {
+    template<typename... Ret, typename... Args>
+    int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
         auto r = stack::pop_call(L, fx, t);
-        stack::push(L, r);
-        return sizeof...(TRn);
+        stack::push_reverse(L, r);
+        return sizeof...(Ret);
     }
 };
 
diff --git a/sol/stack.hpp b/sol/stack.hpp
index 782bd98d..a0c5c230 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -224,15 +224,43 @@ template<typename F, typename Head, typename... Tail, typename... Vs>
 auto ltr_pop(lua_State* L, F&& f, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)..., std::declval<Head>(), std::declval<Tail>()...)) {
     return ltr_pop(L, std::forward<F>(f), types<Tail...>(), std::forward<Vs>(vs)..., pop<Head>(L));
 }
+
+template<typename F, typename... Vs>
+auto rtl_pop(lua_State*, F&& f, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
+    return f(std::forward<Vs>(vs)...);
+}
+template<typename F, typename Head, typename... Vs>
+auto rtl_pop(lua_State* L, F&& f, types<Head>, Vs&&... vs) -> decltype(rtl_pop(L, std::forward<F>(f), types<>(), pop<Head>(L), std::forward<Vs>(vs)...)) {
+    return rtl_pop(L, std::forward<F>(f), types<>(), pop<Head>(L), std::forward<Vs>(vs)...);
+}
+template<typename F, typename Head, typename... Tail, typename... Vs>
+auto rtl_pop(lua_State* L, F&& f, types<Head, Tail...>, Vs&&... vs) -> decltype(rtl_pop(L, std::forward<F>(f), types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...)) {
+	return rtl_pop(L, std::forward<F>(f), types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
+}
 } // detail
 
 template<typename... Args>
 inline void push(lua_State* L, const std::tuple<Args...>& tuplen) {
-    detail::push_tuple(L, build_reverse_indices<sizeof...(Args)>(), tuplen);
+    detail::push_tuple(L, build_indices<sizeof...(Args)>(), tuplen);
 }
 
 template<typename... Args>
 inline void push(lua_State* L, std::tuple<Args...>&& tuplen) {
+    detail::push_tuple(L, build_indices<sizeof...(Args)>(), std::move(tuplen));
+}
+
+template<typename T>
+inline void push_reverse(lua_State* L, T&& item) {
+    push(L, std::forward<T>(item));
+}
+
+template<typename... Args>
+inline void push_reverse(lua_State* L, const std::tuple<Args...>& tuplen) {
+    detail::push_tuple(L, build_reverse_indices<sizeof...(Args)>(), tuplen);
+}
+
+template<typename... Args>
+inline void push_reverse(lua_State* L, std::tuple<Args...>&& tuplen) {
     detail::push_tuple(L, build_reverse_indices<sizeof...(Args)>(), std::move(tuplen));
 }
 
@@ -241,6 +269,11 @@ inline auto pop_call(lua_State* L, TFx&& fx, types<Args...>) -> decltype(detail:
     return detail::ltr_pop(L, std::forward<TFx>(fx), types<Args...>());
 }
 
+template<typename... Args, typename TFx>
+inline auto pop_reverse_call(lua_State* L, TFx&& fx, types<Args...>) -> decltype(detail::rtl_pop(L, std::forward<TFx>(fx), types<Args...>())) {
+    return detail::rtl_pop(L, std::forward<TFx>(fx), reversed<Args...>());
+}
+
 void push_args(lua_State*) {
 
 }
diff --git a/sol/tuple.hpp b/sol/tuple.hpp
index 31285b04..cecaa3e8 100644
--- a/sol/tuple.hpp
+++ b/sol/tuple.hpp
@@ -57,7 +57,16 @@ template<size_t... Ns>
 struct build_reverse_indices<0, Ns...> : indices<Ns...> {};
 
 template<typename... Args>
-struct types : build_indices<sizeof...(Args)> {};
+struct types : build_indices<sizeof...(Args)> { typedef types type; };
+
+template<class Acc, class... Args>
+struct reversed_ : Acc{};
+ 
+template<typename... RArgs, typename Arg, typename... Args>
+struct reversed_<types<RArgs...>, Arg, Args...> : reversed_<types<Arg, RArgs...>, Args...>{};
+ 
+template<typename... Args>
+struct reversed : reversed_<types<>, Args...>{};
 
 template<typename... Args>
 struct tuple_types : types<Args...>, std::false_type {};
diff --git a/tests.cpp b/tests.cpp
index 5b020278..d9749f9b 100644
--- a/tests.cpp
+++ b/tests.cpp
@@ -220,6 +220,21 @@ TEST_CASE("tables/functions_variables", "Check if tables and function calls work
     REQUIRE_NOTHROW(run_script(lua));
 }
 
+TEST_CASE("functions/return _order", "Check if return order is in the same reading order specified in Lua" ) {
+    const static std::tuple<int, int, int> triple = std::make_tuple(10, 11, 12);
+    sol::state lua;
+    lua.set_function( "f", [ ] { 
+	    return std::make_tuple( 10, 11, 12 ); 
+    } );
+    lua.script( "function g() return 10, 11, 12 end" );
+    auto tcpp = lua.get<sol::function>( "f" ).call<int, int, int>( );
+    auto tlua = lua.get<sol::function>( "g" ).call<int, int, int>( );
+    std::cout << std::get<0>( tcpp ) << ',' << std::get<1>( tcpp ) << ',' << std::get<2>( tcpp ) << std::endl;
+    std::cout << std::get<0>( tlua ) << ',' << std::get<1>( tlua ) << ',' << std::get<2>( tlua ) << std::endl;
+    REQUIRE( tcpp == triple );
+    REQUIRE( tlua == triple );
+}
+
 TEST_CASE("tables/operator[]", "Check if operator[] retrieval and setting works properly") {
     sol::state lua;
     lua.open_libraries(sol::lib::base);

From 94405d0346f8043ffa24e3aac0a91bdb1beeb4a3 Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 16:45:40 -0500
Subject: [PATCH 2/8] Fixing lua function, attempting another fix for rtl_pop

---
 sol/lua_function.hpp | 16 +++++++++++-----
 sol/stack.hpp        |  8 ++++----
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/sol/lua_function.hpp b/sol/lua_function.hpp
index 0d278f7b..b4fe39c4 100644
--- a/sol/lua_function.hpp
+++ b/sol/lua_function.hpp
@@ -63,11 +63,6 @@ struct static_lua_func {
     typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type fx_t;
     typedef function_traits<fx_t> fx_traits;
     
-    template<typename... Args>
-    static int typed_call(types<>, types<Args...> t, fx_t* fx, lua_State* L) {
-        return (*this)(types<void>(), t, fx, L);
-    }
-
     template<typename... Args>
     static int typed_call(types<void>, types<Args...> t, fx_t* fx, lua_State* L) {
         stack::pop_call(L, fx, t);
@@ -81,6 +76,11 @@ struct static_lua_func {
         return sizeof...(Ret);
     }
 
+    template<typename... Args>
+    static int typed_call(types<>, types<Args...> t, fx_t* fx, lua_State* L) {
+	    return typed_call(types<void>(), t, fx, L);
+    }
+
     static int call(lua_State* L) {
         int upvalue = 1;
         fx_t* fx;
@@ -99,6 +99,7 @@ struct static_object_lua_func {
     typedef typename std::decay<TFx>::type fx_t;
     typedef function_traits<fx_t> fx_traits;
 
+    
     template<typename... Args>
     static int typed_call(types<void>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
         auto fx = [&item, &ifx](Args&&... args) { (item.*ifx)(std::forward<Args>(args)...); };
@@ -124,6 +125,11 @@ struct static_object_lua_func {
         return sizeof...(Ret);
     }
 
+    template<typename... Args>
+    static int typed_call(types<>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
+        return typed_call(types<void>(), item, ifx, L);
+    }
+
     static int call(lua_State* L) {
         const static std::size_t data_t_count = (sizeof(fx_t)+(sizeof(void*)-1)) / sizeof(void*);
         typedef std::array<void*, data_t_count> data_t;
diff --git a/sol/stack.hpp b/sol/stack.hpp
index a0c5c230..769f38b3 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -233,8 +233,8 @@ template<typename F, typename Head, typename... Vs>
 auto rtl_pop(lua_State* L, F&& f, types<Head>, Vs&&... vs) -> decltype(rtl_pop(L, std::forward<F>(f), types<>(), pop<Head>(L), std::forward<Vs>(vs)...)) {
     return rtl_pop(L, std::forward<F>(f), types<>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
-template<typename F, typename Head, typename... Tail, typename... Vs>
-auto rtl_pop(lua_State* L, F&& f, types<Head, Tail...>, Vs&&... vs) -> decltype(rtl_pop(L, std::forward<F>(f), types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...)) {
+template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
+auto rtl_pop(lua_State* L, F&& f, types<Args...>, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Args>(declval<Args>())...)) {
 	return rtl_pop(L, std::forward<F>(f), types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 } // detail
@@ -270,8 +270,8 @@ inline auto pop_call(lua_State* L, TFx&& fx, types<Args...>) -> decltype(detail:
 }
 
 template<typename... Args, typename TFx>
-inline auto pop_reverse_call(lua_State* L, TFx&& fx, types<Args...>) -> decltype(detail::rtl_pop(L, std::forward<TFx>(fx), types<Args...>())) {
-    return detail::rtl_pop(L, std::forward<TFx>(fx), reversed<Args...>());
+inline auto pop_reverse_call(lua_State* L, TFx&& fx, types<Args...>) -> decltype(detail::rtl_pop(L, std::forward<TFx>(fx), types<Args...>(), reversed<Args...>())) {
+    return detail::rtl_pop(L, std::forward<TFx>(fx), types<Args...>(), reversed<Args...>());
 }
 
 void push_args(lua_State*) {

From b9b32baf1a8214813ab9dce05133406c3850ec19 Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 16:46:57 -0500
Subject: [PATCH 3/8] declval is in the std namespace, derp.

---
 sol/stack.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sol/stack.hpp b/sol/stack.hpp
index 769f38b3..8d07774d 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -234,7 +234,7 @@ auto rtl_pop(lua_State* L, F&& f, types<Head>, Vs&&... vs) -> decltype(rtl_pop(L
     return rtl_pop(L, std::forward<F>(f), types<>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
-auto rtl_pop(lua_State* L, F&& f, types<Args...>, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Args>(declval<Args>())...)) {
+auto rtl_pop(lua_State* L, F&& f, types<Args...>, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Args>(std::declval<Args>())...)) {
 	return rtl_pop(L, std::forward<F>(f), types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 } // detail

From 63536dd8d00e40234ae4bf4613f0125dbe54b7d8 Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 16:52:01 -0500
Subject: [PATCH 4/8] Why not cheat with an extra `types` ? Who needs type
 deduction when you can just pass the right types directly?

---
 sol/stack.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/sol/stack.hpp b/sol/stack.hpp
index 8d07774d..4f7d1afd 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -225,17 +225,17 @@ auto ltr_pop(lua_State* L, F&& f, types<Head, Tail...>, Vs&&... vs) -> decltype(
     return ltr_pop(L, std::forward<F>(f), types<Tail...>(), std::forward<Vs>(vs)..., pop<Head>(L));
 }
 
-template<typename F, typename... Vs>
-auto rtl_pop(lua_State*, F&& f, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
+template<typename F, typename... Vs, typename... Args>
+auto rtl_pop(lua_State*, F&& f, types<Args...>, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
     return f(std::forward<Vs>(vs)...);
 }
-template<typename F, typename Head, typename... Vs>
-auto rtl_pop(lua_State* L, F&& f, types<Head>, Vs&&... vs) -> decltype(rtl_pop(L, std::forward<F>(f), types<>(), pop<Head>(L), std::forward<Vs>(vs)...)) {
-    return rtl_pop(L, std::forward<F>(f), types<>(), pop<Head>(L), std::forward<Vs>(vs)...);
+template<typename F, typename Head, typename... Vs, typename... Args>
+auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head>, Vs&&... vs) -> decltype(f(std::forward<Args>(std::declval<Args>())...)) {
+    return rtl_pop(L, std::forward<F>(f), t, types<>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
-auto rtl_pop(lua_State* L, F&& f, types<Args...>, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Args>(std::declval<Args>())...)) {
-	return rtl_pop(L, std::forward<F>(f), types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
+auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Args>(std::declval<Args>())...)) {
+	return rtl_pop(L, std::forward<F>(f), t, types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 } // detail
 

From c8417d65ded074955390e5d14a5b966d32e08957 Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 16:56:01 -0500
Subject: [PATCH 5/8] `decltype` with `types`. It seems unfair.

---
 sol/stack.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sol/stack.hpp b/sol/stack.hpp
index 4f7d1afd..18339656 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -230,11 +230,11 @@ auto rtl_pop(lua_State*, F&& f, types<Args...>, types<>, Vs&&... vs) -> decltype
     return f(std::forward<Vs>(vs)...);
 }
 template<typename F, typename Head, typename... Vs, typename... Args>
-auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head>, Vs&&... vs) -> decltype(f(std::forward<Args>(std::declval<Args>())...)) {
+auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head>, Vs&&... vs) -> decltype(f(std::declval<Args>()...)) {
     return rtl_pop(L, std::forward<F>(f), t, types<>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
-auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Args>(std::declval<Args>())...)) {
+auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::declval<Args>()...)) {
 	return rtl_pop(L, std::forward<F>(f), t, types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 } // detail

From e0bcf5a11e59a0af9a730808dde109a3e5900e46 Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 17:09:23 -0500
Subject: [PATCH 6/8] Ordering things more nicely for GCC and fixing calls to
 always used extra `types` parameters when they can for early-out decltype
 deduction, rather than recursive template reliance (compiles better for VC++
 and resolves earlier for g++).

---
 sol/lua_function.hpp | 26 +++++++++++++-------------
 sol/stack.hpp        | 26 +++++++++-----------------
 2 files changed, 22 insertions(+), 30 deletions(-)

diff --git a/sol/lua_function.hpp b/sol/lua_function.hpp
index b4fe39c4..6a120d62 100644
--- a/sol/lua_function.hpp
+++ b/sol/lua_function.hpp
@@ -222,10 +222,6 @@ struct explicit_lua_func : public lua_func {
     template<typename... FxArgs>
     explicit_lua_func(FxArgs&&... fxargs): fx(std::forward<FxArgs>(fxargs)...) {}
 
-    virtual int operator()(lua_State* L) override {
-        return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
-    }
-
     template<typename... Args>
     int operator()(types<>, types<Args...> t, lua_State* L) {
         return (*this)(types<void>(), t, L);
@@ -243,6 +239,10 @@ struct explicit_lua_func : public lua_func {
         stack::push_reverse(L, std::move(r));
         return sizeof...(Ret);
     }
+
+    virtual int operator()(lua_State* L) override {
+        return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
+    }
 };
 
 template<typename TFx, typename T>
@@ -265,8 +265,10 @@ struct explicit_lua_func<TFx, T, true> : public lua_func {
     template<typename... FxArgs>
     explicit_lua_func(T m, FxArgs&&... fxargs): fx(std::move(m), std::forward<FxArgs>(fxargs)...) {}
 
-    virtual int operator()(lua_State* L) override {
-        return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
+    template<typename... Args>
+    int operator()(types<void>, types<Args...> t, lua_State* L) {
+        stack::pop_call(L, fx, t);
+        return 0;
     }
 
     template<typename... Args>
@@ -274,18 +276,16 @@ struct explicit_lua_func<TFx, T, true> : public lua_func {
         return (*this)(types<void>(), t, L);
     }
 
-    template<typename... Args>
-    int operator()(types<void>, types<Args...> t, lua_State* L) {
-        stack::pop_call(L, fx, t);
-        return 0;
-    }
-
     template<typename... Ret, typename... Args>
     int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
         auto r = stack::pop_call(L, fx, t);
-        stack::push_reverse(L, r);
+        stack::push_reverse(L, std::move(r));
         return sizeof...(Ret);
     }
+
+    virtual int operator()(lua_State* L) override {
+        return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
+    }
 };
 
 } // sol
diff --git a/sol/stack.hpp b/sol/stack.hpp
index 18339656..5866d6f5 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -212,27 +212,19 @@ inline void push_tuple(lua_State* L, indices<I...>, T&& tuplen) {
     swallow {'\0', (sol::stack::push(L, std::get<I>(tuplen)), '\0')... };
 }
 
-template<typename F, typename... Vs>
-auto ltr_pop(lua_State*, F&& f, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
+template<typename F, typename... Vs, typename... Args>
+auto ltr_pop(lua_State*, F&& f, types<Args...> t, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
     return f(std::forward<Vs>(vs)...);
 }
-template<typename F, typename Head, typename... Vs>
-auto ltr_pop(lua_State* L, F&& f, types<Head>, Vs&&... vs) -> decltype(ltr_pop(L, std::forward<F>(f), types<>(), std::forward<Vs>(vs)..., pop<Head>(L))) {
-    return ltr_pop(L, std::forward<F>(f), types<>(), std::forward<Vs>(vs)..., pop<Head>(L));
-}
-template<typename F, typename Head, typename... Tail, typename... Vs>
-auto ltr_pop(lua_State* L, F&& f, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)..., std::declval<Head>(), std::declval<Tail>()...)) {
-    return ltr_pop(L, std::forward<F>(f), types<Tail...>(), std::forward<Vs>(vs)..., pop<Head>(L));
+template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
+auto ltr_pop(lua_State* L, F&& f, types<Args...> t, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::declval<Args>()...)) {
+    return ltr_pop(L, std::forward<F>(f), t, types<Tail...>(), std::forward<Vs>(vs)..., pop<Head>(L));
 }
 
 template<typename F, typename... Vs, typename... Args>
 auto rtl_pop(lua_State*, F&& f, types<Args...>, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
     return f(std::forward<Vs>(vs)...);
 }
-template<typename F, typename Head, typename... Vs, typename... Args>
-auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head>, Vs&&... vs) -> decltype(f(std::declval<Args>()...)) {
-    return rtl_pop(L, std::forward<F>(f), t, types<>(), pop<Head>(L), std::forward<Vs>(vs)...);
-}
 template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
 auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::declval<Args>()...)) {
 	return rtl_pop(L, std::forward<F>(f), t, types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
@@ -265,13 +257,13 @@ inline void push_reverse(lua_State* L, std::tuple<Args...>&& tuplen) {
 }
 
 template<typename... Args, typename TFx>
-inline auto pop_call(lua_State* L, TFx&& fx, types<Args...>) -> decltype(detail::ltr_pop(L, std::forward<TFx>(fx), types<Args...>())) {
-    return detail::ltr_pop(L, std::forward<TFx>(fx), types<Args...>());
+inline auto pop_call(lua_State* L, TFx&& fx, types<Args...> t) -> decltype(detail::ltr_pop(L, std::forward<TFx>(fx), t, t)) {
+    return detail::ltr_pop(L, std::forward<TFx>(fx), t, t);
 }
 
 template<typename... Args, typename TFx>
-inline auto pop_reverse_call(lua_State* L, TFx&& fx, types<Args...>) -> decltype(detail::rtl_pop(L, std::forward<TFx>(fx), types<Args...>(), reversed<Args...>())) {
-    return detail::rtl_pop(L, std::forward<TFx>(fx), types<Args...>(), reversed<Args...>());
+inline auto pop_reverse_call(lua_State* L, TFx&& fx, types<Args...> t) -> decltype(detail::rtl_pop(L, std::forward<TFx>(fx), t, reversed<Args...>())) {
+    return detail::rtl_pop(L, std::forward<TFx>(fx), t, reversed<Args...>());
 }
 
 void push_args(lua_State*) {

From f8cfb80a451004bf26670179564e9794371bfc42 Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 22:09:06 -0500
Subject: [PATCH 7/8] Fixed a bug with the return order and added tests to make
 sure it works. Added the ability to get mutiple values when doing `table.get`
 or `state.get`. Lua is hard. :c

---
 sol/function.hpp     |  2 +-
 sol/lua_function.hpp | 77 ++++++++++++++++++++------------------------
 sol/stack.hpp        |  2 +-
 sol/state.hpp        |  6 ++--
 sol/table.hpp        | 47 +++++++++++++++++++++++----
 tests.cpp            | 19 ++++++-----
 6 files changed, 92 insertions(+), 61 deletions(-)

diff --git a/sol/function.hpp b/sol/function.hpp
index aac52037..91da5d18 100644
--- a/sol/function.hpp
+++ b/sol/function.hpp
@@ -35,7 +35,7 @@ private:
 
     template<typename... Ret>
     std::tuple<Ret...> invoke(types<Ret...>, std::size_t n) {
-        luacall(n, sizeof...(Ret));
+        luacall(n, sizeof...(Ret));                                                                                                                                                                                                                                                                                                                                                                                                                     
         return stack::pop_reverse_call(state(), std::make_tuple<Ret...>, types<Ret...>());
     }
 
diff --git a/sol/lua_function.hpp b/sol/lua_function.hpp
index 6a120d62..ba3df646 100644
--- a/sol/lua_function.hpp
+++ b/sol/lua_function.hpp
@@ -69,16 +69,17 @@ struct static_lua_func {
         return 0;
     }
 
-    template<typename... Ret, typename... Args>
-    static int typed_call(types<Ret...>, types<Args...> t, fx_t* fx, lua_State* L) {
-        auto r = stack::pop_call(L, fx, t);
-        stack::push_reverse(L, std::move(r));
-        return sizeof...(Ret);
-    }
-
     template<typename... Args>
     static int typed_call(types<>, types<Args...> t, fx_t* fx, lua_State* L) {
-	    return typed_call(types<void>(), t, fx, L);
+        return typed_call(types<void>(), t, fx, L);
+    }
+
+    template<typename... Ret, typename... Args>
+    static int typed_call(types<Ret...>, types<Args...> t, fx_t* fx, lua_State* L) {
+        typedef typename multi_return<Ret...>::type return_type;
+        return_type r = stack::pop_call(L, fx, t);
+        stack::push(L, std::move(r));
+        return sizeof...(Ret);
     }
 
     static int call(lua_State* L) {
@@ -99,7 +100,6 @@ struct static_object_lua_func {
     typedef typename std::decay<TFx>::type fx_t;
     typedef function_traits<fx_t> fx_traits;
 
-    
     template<typename... Args>
     static int typed_call(types<void>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
         auto fx = [&item, &ifx](Args&&... args) { (item.*ifx)(std::forward<Args>(args)...); };
@@ -107,29 +107,20 @@ struct static_object_lua_func {
         return 0;
     }
 
-    template<typename Ret, typename... Args>
-    static int typed_call(types<Ret>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
-        auto fx = [&item, &ifx](Args&&... args) -> Ret { 
-           return (item.*ifx)(std::forward<Args>(args)...); 
-        };
-        auto r = stack::pop_call(L, fx, types<Args...>());
-        stack::push(L, std::move(r));
-        return 1;
+    template<typename... Args>
+    static int typed_call(types<>, types<Args...> t, T& item, fx_t& ifx, lua_State* L) {
+        return typed_call(types<void>(), t, item, ifx, L);
     }
 
     template<typename... Ret, typename... Args>
     static int typed_call(types<Ret...>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
-        auto fx = [&item, &ifx](Args&&... args) -> std::tuple<Ret...> { return (item.*ifx)(std::forward<Args>(args)...); };
-        auto r = stack::pop_call(L, fx, types<Args...>());
-        stack::push_reverse(L, std::move(r));
+        typedef typename multi_return<Ret...>::type return_type;
+        auto fx = [&item, &ifx](Args&&... args) -> return_type { return (item.*ifx)(std::forward<Args>(args)...); };
+        return_type r = stack::pop_call(L, fx, types<Args...>());
+        stack::push(L, std::move(r));
         return sizeof...(Ret);
     }
 
-    template<typename... Args>
-    static int typed_call(types<>, types<Args...>, T& item, fx_t& ifx, lua_State* L) {
-        return typed_call(types<void>(), item, ifx, L);
-    }
-
     static int call(lua_State* L) {
         const static std::size_t data_t_count = (sizeof(fx_t)+(sizeof(void*)-1)) / sizeof(void*);
         typedef std::array<void*, data_t_count> data_t;
@@ -193,22 +184,22 @@ struct lambda_lua_func : public lua_func {
         return (*this)(tuple_types<typename fx_traits::return_type>(), typename fx_traits::args_type(), L);
     }
 
-    template<typename... Args>
-    int operator()(types<>, types<Args...> t, lua_State* L) {
-        stack::pop_call(L, fx, t);
-        return 0;
-    }
-
     template<typename... Args>
     int operator()(types<void>, types<Args...> t, lua_State* L) {
         stack::pop_call(L, fx, t);
         return 0;
     }
 
+    template<typename... Args>
+    int operator()(types<>, types<Args...> t, lua_State* L) {
+        return (*this)(types<void>(), t, L);
+    }
+
     template<typename... Ret, typename... Args>
     int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
-        auto r = stack::pop_call(L, fx, t);
-        stack::push_reverse(L, r);
+        typedef typename multi_return<Ret...>::type return_type;
+        return_type r = stack::pop_call(L, fx, t);
+        stack::push(L, r);
         return sizeof...(Ret);
     }
 };
@@ -222,21 +213,22 @@ struct explicit_lua_func : public lua_func {
     template<typename... FxArgs>
     explicit_lua_func(FxArgs&&... fxargs): fx(std::forward<FxArgs>(fxargs)...) {}
 
-    template<typename... Args>
-    int operator()(types<>, types<Args...> t, lua_State* L) {
-        return (*this)(types<void>(), t, L);
-    }
-
     template<typename... Args>
     int operator()(types<void>, types<Args...> t, lua_State* L) {
         stack::pop_call(L, fx, t);
         return 0;
     }
 
+    template<typename... Args>
+    int operator()(types<>, types<Args...> t, lua_State* L) {
+        return (*this)(types<void>(), t, L);
+    }
+
     template<typename... Ret, typename... Args>
     int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
-        auto r = stack::pop_call(L, fx, t);
-        stack::push_reverse(L, std::move(r));
+        typedef typename multi_return<Ret...>::type return_type;
+        return_type r = stack::pop_call(L, fx, t);
+        stack::push(L, std::move(r));
         return sizeof...(Ret);
     }
 
@@ -278,8 +270,9 @@ struct explicit_lua_func<TFx, T, true> : public lua_func {
 
     template<typename... Ret, typename... Args>
     int operator()(types<Ret...>, types<Args...> t, lua_State* L) {
-        auto r = stack::pop_call(L, fx, t);
-        stack::push_reverse(L, std::move(r));
+        typedef typename multi_return<Ret...>::type return_type;
+        return_type r = stack::pop_call(L, fx, t);
+        stack::push(L, std::move(r));
         return sizeof...(Ret);
     }
 
diff --git a/sol/stack.hpp b/sol/stack.hpp
index 5866d6f5..06381641 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -227,7 +227,7 @@ auto rtl_pop(lua_State*, F&& f, types<Args...>, types<>, Vs&&... vs) -> decltype
 }
 template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
 auto rtl_pop(lua_State* L, F&& f, types<Args...> t, types<Head, Tail...>, Vs&&... vs) -> decltype(f(std::declval<Args>()...)) {
-	return rtl_pop(L, std::forward<F>(f), t, types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
+    return rtl_pop(L, std::forward<F>(f), t, types<Tail...>(), pop<Head>(L), std::forward<Vs>(vs)...);
 }
 } // detail
 
diff --git a/sol/state.hpp b/sol/state.hpp
index 9cac52e4..aebb136b 100644
--- a/sol/state.hpp
+++ b/sol/state.hpp
@@ -127,9 +127,9 @@ public:
         }
     }
 
-    template<typename T, typename U>
-    T get(U&& key) const {
-        return global.get<T>(std::forward<U>(key));
+    template<typename... Args, typename... Keys>
+    typename multi_return<Args...>::type get(Keys&&... keys) const {
+       return global.get(types<Args...>(), std::forward<Keys>(keys)...);
     }
 
     template<typename T, typename U>
diff --git a/sol/table.hpp b/sol/table.hpp
index b5c44a79..09421897 100644
--- a/sol/table.hpp
+++ b/sol/table.hpp
@@ -41,15 +41,11 @@ T* get_ptr(T* val) {
 } // detail
 
 class table : public reference {
+    friend class state;
     template<typename Table, typename T> struct proxy;
-public:
-    table() noexcept : reference() {}
-    table(lua_State* L, int index = -1) : reference(L, index) {
-        type_assert(L, index, type::table);
-    }
 
     template<typename T, typename U>
-    T get(U&& key) const {
+    T single_get(U&& key) const {
         push();
         stack::push(state(), std::forward<U>(key));
         lua_gettable(state(), -2);
@@ -59,6 +55,45 @@ public:
         return result;
     }
 
+    template<std::size_t I, typename Tup, typename... Ret>
+    typename std::tuple_element<I, std::tuple<Ret...>>::type element_get(types<Ret...>, Tup&& key) const {
+        typedef typename std::tuple_element<I, std::tuple<Ret...>>::type T;
+        typedef typename std::tuple_element<I, Tup>::type U;
+        push();
+        stack::push(state(), std::get<I>(key));
+        lua_gettable(state(), -2);
+        type_assert(state(), -1, type_of<T>());
+        T result = stack::pop<T>(state());
+        lua_pop(state(), 1);
+        return result;
+    }
+
+    template<typename Tup, typename... Ret, std::size_t... I>
+    typename multi_return<Ret...>::type tuple_get(types<Ret...> t, indices<I...>, Tup&& tup) const {
+       return std::make_tuple(element_get<I>(t, std::forward<Tup>(tup))...);
+    }
+
+    template<typename Tup, typename Ret>
+    Ret tuple_get(types<Ret> t, indices<0>, Tup&& tup) const {
+        return element_get<0>(t, std::forward<Tup>(tup));
+    }
+
+    template<typename... Ret, typename... Keys>
+    typename multi_return<Ret...>::type get(types<Ret...> t, Keys&&... keys) const {
+        static_assert(sizeof...(Keys) == sizeof...(Ret), "Must have same number of keys as return values");
+        return tuple_get(t, t, std::make_tuple(std::forward<Keys>(keys)...));
+    }
+public:
+    table() noexcept : reference() {}
+    table(lua_State* L, int index = -1) : reference(L, index) {
+        type_assert(L, index, type::table);
+    }
+
+    template<typename... Ret, typename... Keys>
+    typename multi_return<Ret...>::type get(Keys&&... keys) const {
+       return get(types<Ret...>(), std::forward<Keys>(keys)...);
+    }
+
     template<typename T, typename U>
     table& set(T&& key, U&& value) {
         push();
diff --git a/tests.cpp b/tests.cpp
index d9749f9b..940b95fd 100644
--- a/tests.cpp
+++ b/tests.cpp
@@ -224,15 +224,18 @@ TEST_CASE("functions/return _order", "Check if return order is in the same readi
     const static std::tuple<int, int, int> triple = std::make_tuple(10, 11, 12);
     sol::state lua;
     lua.set_function( "f", [ ] { 
-	    return std::make_tuple( 10, 11, 12 ); 
+        return std::make_tuple( 10, 11, 12 ); 
     } );
-    lua.script( "function g() return 10, 11, 12 end" );
-    auto tcpp = lua.get<sol::function>( "f" ).call<int, int, int>( );
-    auto tlua = lua.get<sol::function>( "g" ).call<int, int, int>( );
-    std::cout << std::get<0>( tcpp ) << ',' << std::get<1>( tcpp ) << ',' << std::get<2>( tcpp ) << std::endl;
-    std::cout << std::get<0>( tlua ) << ',' << std::get<1>( tlua ) << ',' << std::get<2>( tlua ) << std::endl;
-    REQUIRE( tcpp == triple );
-    REQUIRE( tlua == triple );
+    lua.script("function g() return 10, 11, 12 end\nx,y,z = g()");
+    auto tcpp = lua.get<sol::function>("f").call<int, int, int>();
+    auto tlua = lua.get<sol::function>("g").call<int, int, int>();
+    auto tluaget = lua.get<int, int, int>("x", "y", "z");
+    std::cout << "cpp: " << std::get<0>(tcpp) << ',' << std::get<1>(tcpp) << ',' << std::get<2>(tcpp) << std::endl;
+    std::cout << "lua: " << std::get<0>(tlua) << ',' << std::get<1>(tlua) << ',' << std::get<2>(tlua) << std::endl;
+    std::cout << "lua.xyz: " << lua.get<int>("x") << ',' << lua.get<int>("y") << ',' << lua.get<int>("z") << std::endl;
+    REQUIRE(tcpp == triple);
+    REQUIRE(tlua == triple);
+    REQUIRE(tluaget == triple);
 }
 
 TEST_CASE("tables/operator[]", "Check if operator[] retrieval and setting works properly") {

From cb492e7c293f9181542f5b89a73991236868d29d Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Sun, 15 Dec 2013 22:14:56 -0500
Subject: [PATCH 8/8] Squashing those GCC warnings.

---
 sol/stack.hpp | 2 +-
 sol/table.hpp | 1 -
 tests.cpp     | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/sol/stack.hpp b/sol/stack.hpp
index 06381641..6bb1608f 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -213,7 +213,7 @@ inline void push_tuple(lua_State* L, indices<I...>, T&& tuplen) {
 }
 
 template<typename F, typename... Vs, typename... Args>
-auto ltr_pop(lua_State*, F&& f, types<Args...> t, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
+auto ltr_pop(lua_State*, F&& f, types<Args...>, types<>, Vs&&... vs) -> decltype(f(std::forward<Vs>(vs)...)) {
     return f(std::forward<Vs>(vs)...);
 }
 template<typename F, typename Head, typename... Tail, typename... Vs, typename... Args>
diff --git a/sol/table.hpp b/sol/table.hpp
index 09421897..5ab57618 100644
--- a/sol/table.hpp
+++ b/sol/table.hpp
@@ -58,7 +58,6 @@ class table : public reference {
     template<std::size_t I, typename Tup, typename... Ret>
     typename std::tuple_element<I, std::tuple<Ret...>>::type element_get(types<Ret...>, Tup&& key) const {
         typedef typename std::tuple_element<I, std::tuple<Ret...>>::type T;
-        typedef typename std::tuple_element<I, Tup>::type U;
         push();
         stack::push(state(), std::get<I>(key));
         lua_gettable(state(), -2);
diff --git a/tests.cpp b/tests.cpp
index 940b95fd..c986f73c 100644
--- a/tests.cpp
+++ b/tests.cpp
@@ -220,7 +220,7 @@ TEST_CASE("tables/functions_variables", "Check if tables and function calls work
     REQUIRE_NOTHROW(run_script(lua));
 }
 
-TEST_CASE("functions/return _order", "Check if return order is in the same reading order specified in Lua" ) {
+TEST_CASE("functions/return_order_and_multi_get", "Check if return order is in the same reading order specified in Lua" ) {
     const static std::tuple<int, int, int> triple = std::make_tuple(10, 11, 12);
     sol::state lua;
     lua.set_function( "f", [ ] {