The solution technically works, but there's some stack corruption going on somewhere that I can quite track down, even when calling a void function with no parameters. I'll have to look into it...

sol/function.hpp

@@ -1,3 +1,24 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013 Danny Y., Rapptz
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 #ifndef SOL_FUNCTION_HPP
 #define SOL_FUNCTION_HPP
 
@@ -9,33 +30,55 @@ namespace sol {
 class function : virtual public reference {
 private:
     template<typename... Args>
-	void push_args(Args&&... args) {
+    void push_args(Args&&... args) const {
         auto L = state();
-		using swallow = char [];
+        using swallow = char[ ];
-		void( swallow{ (stack::push(L, std::forward<Args>(args)), '\0')... } );
+        void(swallow{ (stack::push(L, std::forward<Args>(args)), '\0')... });
     }
+
+    template<typename... Ret>
+    struct invoker {
+	    template<typename... Args>
+	    static std::tuple<Ret...> call( const function& ref, Args&&... args ) {
+		    ref.push( );
+		    ref.push_args( std::forward<Args>( args )... );
+		    lua_pcall( ref.state( ), sizeof...( Args ), sizeof...( Ret ), 0 );
+		    return std::make_tuple( stack::pop<Ret>( ref.state( ) )... );
+	    }
+    };
+
+    template<>
+    struct invoker<> {
+	    template<typename... Args>
+	    static void call( const function& ref, Args&&... args ) {
+		    ref.push( );
+		    ref.push_args( std::forward<Args>( args )... );
+		    lua_pcall( ref.state( ), sizeof...( Args ), 0, 0 );
+	    }
+    };
+
+    template<typename T>
+    struct invoker<T> {
+	    template<typename... Args>
+	    static T call( const function& ref, Args&&... args ) {
+		    ref.push( );
+		    ref.push_args( std::forward<Args>( args )... );
+		    lua_pcall( ref.state( ), sizeof...( Args ), 1, 0 );
+		    return stack::pop<T>( ref.state( ) );
+	    }
+    };
+
 public:
     function() : reference() {}
     function(lua_State* L, int index = -1) : reference(L, index) {
         type_assert(L, index, type::function);
     }
 
-	template<typename T, typename... Args>
+    template<typename... Ret, typename... Args>
-	T invoke(Args&&... args) {
+    auto invoke( Args&&... args ) {
-		push();
+	    return invoker<Ret...>::call( *this, std::forward<Args>( args )... );
-		push_args(std::forward<Args>(args)...);
-		lua_pcall(state(), sizeof...(Args), 1, 0);
-		return stack::pop<T>(state());
-	}
-
-	template<typename... Args>
-	void invoke(Args&&... args) {
-		push();
-		push_args(std::forward<Args>(args)...);
-		lua_pcall(state(), sizeof...(Args), 0, 0);
     }
 };
 } // sol
 
-
 #endif // SOL_FUNCTION_HPP

sol/functional.hpp

@@ -0,0 +1,102 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013 Danny Y., Rapptz
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#include "tuple.hpp"
+
+#ifndef SOL_FUNCTIONAL_HPP
+#define SOL_FUNCTIONAL_HPP
+
+namespace sol {
+namespace detail {
+
+template<typename TFuncSignature>
+struct function_traits;
+
+template<typename T, typename R, typename... Tn>
+struct function_traits<R( T::* )( Tn... )> {
+	static const std::size_t arity = sizeof...( Tn );
+	static const bool is_member_function = true;
+	typedef std::tuple<Tn...> arg_tuple_t;
+	typedef types<Tn...> args_t;
+	typedef R( T::* func_t )( Tn... );
+	typedef R( T::* func_pointer_t )( Tn... );
+	typedef R return_t;
+	template <std::size_t i>
+	using arg_n = std::tuple_element<i, arg_tuple_t>;
+};
+
+template<typename T, typename R, typename... Tn>
+struct function_traits<R( T::* )( Tn... ) const> {
+	static const std::size_t arity = sizeof...( Tn );
+	static const bool is_member_function = true;
+	typedef std::tuple<Tn...> arg_tuple_t;
+	typedef types<Tn...> args_t;
+	typedef R( T::* func_t )( Tn... );
+	typedef R( T::* func_pointer_t )( Tn... );
+	typedef R return_t;
+	template <std::size_t i>
+	using arg_n = std::tuple_element<i, arg_tuple_t>;
+};
+
+template<typename R, typename... Tn>
+struct function_traits<R( Tn... )> {
+	static const std::size_t arity = sizeof...( Tn );
+	static const bool is_member_function = false;
+	typedef std::tuple<Tn...> arg_tuple_t;
+	typedef types<Tn...> args_t;
+	typedef R( func_t )( Tn... );
+	typedef R( *func_pointer_t )( Tn... );
+	typedef R return_t;
+	template <std::size_t i>
+	using arg_n = std::tuple_element<i, arg_tuple_t>;
+};
+
+template<typename R, typename... Tn>
+struct function_traits<R( *)( Tn... )> {
+	static const std::size_t arity = sizeof...( Tn );
+	static const bool is_member_function = false;
+	typedef std::tuple<Tn...> arg_tuple_t;
+	typedef types<Tn...> args_t;
+	typedef R( func_t )( Tn... );
+	typedef R( *func_pointer_t )( Tn... );
+	typedef R return_t;
+	template <std::size_t i>
+	using arg_n = std::tuple_element<i, arg_tuple_t>;
+};
+
+using std::get;
+
+template<typename Function, typename Tuple, size_t... Indices>
+inline auto call( Function f, const Tuple& t, indices<Indices...> ) -> decltype( f( get<Indices>( t )... ) ) {
+	return f( get<Indices>( t )... );
+}
+
+} // detail
+
+template<typename Function, typename... Args>
+inline auto call( Function f, const std::tuple<Args...>& t ) -> decltype( detail::call( f, t, detail::build_indices<sizeof...( Args )>{} ) ) {
+	return call( f, t, detail::build_indices<sizeof...( Args )>{} );
+}
+
+} // sol
+
+
+#endif // SOL_FUNCTIONAL_HPP

sol/lua_function.hpp

@@ -0,0 +1,138 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013 Danny Y., Rapptz
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SOL_LUA_FUNC_HPP
+#define SOL_LUA_FUNC_HPP
+
+#include "functional.hpp"
+#include "stack.hpp"
+
+namespace sol {
+namespace detail {
+
+	struct lua_func {
+		virtual int operator () ( lua_State* L ) {
+			throw sol_error( "Failure to call specialized wrapped C++ function from lua" );
+		}
+
+		virtual ~lua_func( ) {};
+	};
+
+	template <typename TFx>
+	struct lambda_lua_func : public lua_func {
+		typedef decltype( &TFx::operator() ) fx_t;
+		typedef function_traits<fx_t> fx_traits;
+		TFx fx;
+
+		template <typename... TFxn>
+		lambda_lua_func( TFxn&&... fxn ) : fx( std::forward<TFxn>( fxn )... ) {
+
+		}
+
+		virtual int operator () ( lua_State* L ) override {
+			return ( *this )( tuple_types<fx_traits::return_t>( ), fx_traits::args_t( ), L );
+		}
+
+		template <typename... Tn>
+		int operator()( types<void>, types<Tn...> t, lua_State* L ) {
+			auto r = stack::pop_call( L, fx, t );
+			return 0;
+		}
+
+		template <typename... TRn, typename... Tn>
+		int operator()( types<TRn...>, types<Tn...> t, lua_State* L ) {
+			auto r = stack::pop_call( L, fx, t );
+			stack::push( L, r );
+			return sizeof...( TRn );
+		}
+	};
+
+	template <typename TFx, typename T = TFx, bool is_member_pointer = std::is_member_function_pointer<TFx>::value>
+	struct explicit_lua_func : public lua_func {
+		typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type fx_t;
+		typedef function_traits<fx_t> fx_traits;
+		TFx fx;
+
+		template <typename... TFxn>
+		explicit_lua_func( TFxn&&... fxn ) : fx( std::forward<TFxn>( fxn )... ) {
+
+		}
+
+		virtual int operator () ( lua_State* L ) override {
+			return ( *this )( tuple_types<fx_traits::return_t>( ), fx_traits::args_t( ), L );
+		}
+
+		template <typename... Tn>
+		int operator () ( types<void>, types<Tn...> t, lua_State* L ) {
+			auto r = stack::pop_call( L, fx, t );
+			return 0;
+		}
+
+		template <typename... TRn, typename... Tn>
+		int operator () ( types<TRn...>, types<Tn...> t, lua_State* L ) {
+			auto r = stack::pop_call( L, fx, t );
+			stack::push( L, r );
+			return sizeof...( TRn );
+		}
+	};
+
+	template <typename TFx, typename T>
+	struct explicit_lua_func<TFx, T, true> : public lua_func {
+		typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type fx_t;
+		typedef function_traits<fx_t> fx_traits;
+		T* member;
+		TFx fx;
+		
+		template <typename... TFxn>
+		explicit_lua_func( T* m, TFxn&&... fxn ) : member(m), fx( std::forward<TFxn>( fxn )... ) {
+
+		}
+
+		virtual int operator () ( lua_State* L ) override {
+			return ( *this )( tuple_types<fx_traits::return_t>( ), fx_traits::args_t( ), L );
+		}
+
+		template <typename... Tn>
+		int operator () ( types<void>, types<Tn...>, lua_State* L ) {
+			auto r = stack::pop_call( L, fx, t );
+			return 0;
+		}
+
+		template <typename... TRn, typename... Tn>
+		int operator () ( types<TRn...>, types<Tn...> t, lua_State* L ) {
+			auto r = stack::pop_call( L, fx, t );
+			stack::push( L, r );
+			return sizeof...( TRn );
+		}
+	};
+
+
+	int lua_cfun( lua_State* L ) {
+		void* bridgedata = lua_touserdata( L, lua_upvalueindex( 1 ) );
+		auto* fx = static_cast<lua_func*>( bridgedata );
+		int r = fx->operator()( L );
+		return r;
+	}
+
+} // detail
+} // sol
+
+#endif // SOL_LUA_FUNC_HPP

sol/stack.hpp

@@ -23,6 +23,7 @@
 #define SOL_STACK_HPP
 
 #include "reference.hpp"
+#include "tuple.hpp"
 #include <utility>
 #include <type_traits>
 
@@ -35,6 +36,19 @@ using DisableIf = typename std::enable_if<!T::value, R>::type;
 
 namespace stack {
 namespace detail {
+template<class T, class F, class... Vs>
+auto ltr_pop( T&& extra, F f, types<>, Vs&&... vs )
+	-> decltype( f( std::forward<Vs>( vs )... ) ) {
+	return f( std::forward<Vs>( vs )... );
+}
+
+// take head, produce value from it, pass after other values
+template<class F, class Head, class... Tail, class... Vs>
+auto ltr_pop( lua_State* L, F f, types<Head, Tail...>, Vs&&... vs )
+-> decltype( ltr_pop( L, f, types<Tail...>{}, std::forward<Vs>( vs )..., stack::pop<Head>( L ) ) ) {
+	return ltr_pop( L, f, types<Tail...>{}, std::forward<Vs>( vs )..., stack::pop<Head>( L ) );
+}
+
 template<typename T>
 inline T get_unsigned(lua_State* L, std::true_type, int index = -1) {
     return lua_tounsigned(L, index);
@@ -150,6 +164,25 @@ inline void push(lua_State* L, const char (&str)[N]) {
 inline void push(lua_State* L, const std::string& str) {
     lua_pushlstring(L, str.c_str(), str.size());
 }
+
+namespace detail {
+template<typename T, std::size_t... I>
+inline void push( lua_State* L, indices<I...>, const T& tuplen ) {
+	using swallow = char [];
+	void( swallow{ ( push( L, std::get<I>( tuplen ) ), '\0' )... } );
+}
+} // detail
+
+template<typename... Args>
+inline void push(lua_State* L, const std::tuple<Args...>& tuplen) {
+    detail::push(L, sol::detail::build_indices<sizeof...( Args )>(), tuplen);
+}
+
+template<typename... Args, typename TFx>
+inline auto pop_call( lua_State* L, TFx&& fx, types<Args...> t )->decltype( detail::ltr_pop( L, fx, t ) ) {
+	return detail::ltr_pop( L, fx, t );
+}
+
 } // stack
 } // sol
 

sol/state.hpp

@@ -58,6 +58,8 @@ private:
     std::unique_ptr<lua_State, void(*)(lua_State*)> L;
     table reg;
     table global;
+    std::unordered_map<std::string, std::unique_ptr<detail::lua_func>> funcs;
+
 public:
     state(): 
     L(luaL_newstate(), lua_close),  
@@ -145,6 +147,12 @@ public:
         return *this;
     }
 
+    template<typename T, typename TFx>
+    state& set_function( T&& key, TFx&& fx ) {
+	    global.set_function( std::forward<T>( key ), std::forward<TFx>( fx ) );
+	    return *this;
+    }
+
     template<typename T>
     table create_table(T&& key, int narr = 0, int nrec = 0) {
         if(narr == 0 && nrec == 0) {

sol/table.hpp

@@ -23,9 +23,14 @@
 #define SOL_TABLE_HPP
 
 #include "stack.hpp"
+#include "lua_function.hpp"
+#include <unordered_map>
+#include <memory>
 
 namespace sol {
 class table : virtual public reference {
+private:
+     std::unordered_map<std::string, std::shared_ptr<detail::lua_func>> funcs;
 public:
     table() noexcept: reference{} {}
     table(lua_State* L, int index = -1): reference(L, index) {
@@ -53,10 +58,55 @@ public:
         return *this;
     }
 
+    template<typename T, typename TFx>
+    table& set_function( T&& key, TFx&& fx ) {
+	    typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
+	    const static bool isfunction = std::is_function<clean_fx>::value;
+	    return set_function( std::integral_constant<bool, !isfunction>( ),
+		    std::forward<T>( key ), std::forward<TFx>( fx ) );
+    }
+
+    template<typename T, typename TFx>
+    table& set_function( std::true_type, T&& key, TFx&& fx ) {
+	    typedef typename std::decay<TFx>::type clean_fx;
+	    std::string fkey( key );
+	    lua_CFunction freefunc = &detail::lua_cfun;
+	    auto hint = funcs.find( fkey );
+	    detail::lua_func* target = nullptr;
+	    if ( hint == funcs.end( ) ) {
+		    std::shared_ptr<detail::lua_func> sptr( new detail::lambda_lua_func<clean_fx>( std::forward<TFx>( fx ) ) );
+		    hint = funcs.emplace_hint( hint, fkey, std::move( sptr ) );
+	    }
+	    target = hint->second.get( );
+	    lua_pushlightuserdata( state( ), static_cast<void*>( target ) );
+	    lua_pushcclosure( state( ), freefunc, 1 );
+	    lua_setglobal( state( ), fkey.c_str( ) );
+	    return *this;
+    }
+
+    template <typename T, typename TFx>
+    table& set_function( std::false_type, T&& key, TFx&& fx ) {
+	    typedef typename std::decay<TFx>::type clean_fx;
+	    std::string fkey( key );
+	    lua_CFunction freefunc = &detail::lua_cfun;
+	    auto hint = funcs.find( fkey );
+	    detail::lua_func* target = nullptr;
+	    if ( hint == funcs.end( ) ) {
+		    std::shared_ptr<detail::lua_func> sptr( new detail::explicit_lua_func<TFx>( std::forward<TFx>( fx ) ) );
+		    hint = funcs.emplace_hint( hint, fkey, std::move( sptr ) );
+	    }
+	    target = hint->second.get( );
+	    lua_pushlightuserdata( state( ), static_cast<void*>( target ) );
+	    lua_pushcclosure( state( ), freefunc, 1 );
+	    lua_setglobal( state( ), fkey.c_str( ) );
+	    return *this;
+    }
+
     size_t size() const {
         push();
         return lua_rawlen(state(), -1);
     }
+	
 };
 } // sol
 

sol/tuple.hpp

@@ -26,28 +26,25 @@
 #include <cstddef>
 
 namespace sol {
-namespace detail {
+
 template<size_t... Ns>
-struct indices {};
+struct indices { };
 
 template<size_t N, size_t... Ns>
-struct build_indices : build_indices<N-1, N-1, Ns...> {};
+struct build_indices : build_indices<N - 1, N - 1, Ns...> { };
 
 template<size_t... Ns>
-struct build_indices<0, Ns...> : indices<Ns...> {};
+struct build_indices<0, Ns...> : indices<Ns...>{ };
 
-using std::get;
+template<typename... Args>
+struct types : build_indices<sizeof...( Args )> { };
 
-template<typename Function, typename Tuple, size_t... Indices>
+template<typename... Args>
-inline auto call(Function f, const Tuple& t, indices<Indices...>) -> decltype(f(get<Indices>(t)...)) {
+struct tuple_types : types<Args...>, std::false_type { };
-    return f(get<Indices>(t)...);
+
-}
+template <typename... Args>
-} // detail
+struct tuple_types<std::tuple<Args...>> : types<Args...>, std::true_type{ };
 
-template<typename Function, typename... Args>
-inline auto call(Function f, const std::tuple<Args...>& t) -> decltype(detail::call(f, t, detail::build_indices<sizeof...(Args)>{})) {
-    return call(f, t, detail::build_indices<sizeof...(Args)>{});
-}
 } // sol
 
 #endif // SOL_TUPLE_HPP

sol/types.hpp

@@ -28,7 +28,9 @@
 
 namespace sol {
 struct nil_t {};
-const nil_t nil{};
+const nil_t nil{ };
+struct Void_t { };
+const Void_t Void{};
 
 enum class type : int {
     none = LUA_TNONE,