diff --git a/sol/function.hpp b/sol/function.hpp
index 264fc0e9..6a68d728 100644
--- a/sol/function.hpp
+++ b/sol/function.hpp
@@ -61,6 +61,11 @@ public:
     function(const function&) = default;
     function& operator=(const function&) = default;
 
+    template<typename... Args>
+    void operator()(Args&&... args) {
+	    call<>(std::forward<Args>(args)...);
+    }
+    
     template<typename... Ret, typename... Args>
     auto call(Args&&... args) -> decltype(invoke(types<Ret...>(), sizeof...(Args))) {
         push();
diff --git a/sol/stack.hpp b/sol/stack.hpp
index 43212f9b..5bc59091 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -208,8 +208,8 @@ inline int push_user(lua_State* L, T& item) {
 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{'\0', (sol::stack::push(L, std::get<I>(tuplen)), '\0')... });
+    using swallow = char[ 1 + sizeof...(I) ];
+    swallow {'\0', (sol::stack::push(L, std::get<I>(tuplen)), '\0')... };
 }
 
 template<typename F, typename... Vs>
diff --git a/sol/table.hpp b/sol/table.hpp
index 4a444e52..dcc5a10b 100644
--- a/sol/table.hpp
+++ b/sol/table.hpp
@@ -41,7 +41,7 @@ T* get_ptr(T* val) {
 } // detail
 
 class table : virtual public reference {
-    template<typename T, typename U> struct proxy;
+    template<typename Table, typename T> struct proxy;
 public:
     table() noexcept : reference() {}
     table(lua_State* L, int index = -1) : reference(L, index) {
@@ -82,13 +82,13 @@ public:
     }
 
     template<typename T>
-    auto operator[](T&& key) -> decltype(proxy<decltype(*this), T>(*this, std::forward<T>(key))) {
-        return proxy<decltype(*this), T>(*this, std::forward<T>(key));
+    proxy<table&, T> operator[](T&& key) {
+        return proxy<table&, T>(*this, std::forward<T>(key));
     }
 
     template<typename T>
-    auto operator[](T&& key) const -> decltype(proxy<decltype(*this), T>(*this, std::forward<T>(key))) {
-        return proxy<decltype(*this), T>(*this, std::forward<T>(key));
+    proxy<const table&, T> operator[](T&& key) const {
+        return proxy<const table&, T>(*this, std::forward<T>(key));
     }
 
     size_t size() const {
diff --git a/sol/traits.hpp b/sol/traits.hpp
index 9b998305..26d71634 100644
--- a/sol/traits.hpp
+++ b/sol/traits.hpp
@@ -72,56 +72,56 @@ template<typename TFuncSignature>
 struct function_traits;
 
 template<typename T, typename R, typename... Args>
-struct function_traits<R( T::* )( Args... )> {
-	static const std::size_t arity = sizeof...( Args );
+struct function_traits<R(T::*)(Args...)> {
+	static const std::size_t arity = sizeof...(Args);
 	static const bool is_member_function = true;
 	typedef std::tuple<Args...> arg_tuple_type;
 	typedef types<Args...> args_type;
-	typedef R( T::* function_pointer_type )( Args... );
+	typedef R(T::* function_pointer_type)(Args...);
 	typedef typename std::remove_pointer<function_pointer_type>::type function_type;
-	typedef R( *free_function_pointer_type )( Args... );
+	typedef R(*free_function_pointer_type)(Args...);
 	typedef R return_type;
 	template<std::size_t i>
 	using arg = typename std::tuple_element<i, arg_tuple_type>::type;
 };
 
 template<typename T, typename R, typename... Args>
-struct function_traits<R( T::* )( Args... ) const> {
-	static const std::size_t arity = sizeof...( Args );
+struct function_traits<R(T::*)(Args...) const> {
+	static const std::size_t arity = sizeof...(Args);
 	static const bool is_member_function = true;
 	typedef std::tuple<Args...> arg_tuple_type;
 	typedef types<Args...> args_type;
-	typedef R( T::* function_pointer_type )( Args... );
+	typedef R(T::* function_pointer_type)(Args...);
 	typedef typename std::remove_pointer<function_pointer_type>::type function_type;
-	typedef R( *free_function_pointer_type )( Args... );
+	typedef R(*free_function_pointer_type)(Args...);
 	typedef R return_type;
 	template<std::size_t i>
 	using arg = typename std::tuple_element<i, arg_tuple_type>::type;
 };
 
 template<typename R, typename... Args>
-struct function_traits<R( Args... )> {
-	static const std::size_t arity = sizeof...( Args );
+struct function_traits<R(Args...)> {
+	static const std::size_t arity = sizeof...(Args);
 	static const bool is_member_function = false;
 	typedef std::tuple<Args...> arg_tuple_type;
 	typedef types<Args...> args_type;
-	typedef R( function_type )( Args... );
-	typedef R( *function_pointer_type )( Args... );
-	typedef R( *free_function_pointer_type )( Args... );
+	typedef R(function_type)(Args...);
+	typedef R(*function_pointer_type)(Args...);
+	typedef R(*free_function_pointer_type)(Args...);
 	typedef R return_type;
 	template<std::size_t i>
 	using arg = typename std::tuple_element<i, arg_tuple_type>::type;
 };
 
 template<typename R, typename... Args>
-struct function_traits<R( *)( Args... )> {
-	static const std::size_t arity = sizeof...( Args );
+struct function_traits<R(*)(Args...)> {
+	static const std::size_t arity = sizeof...(Args);
 	static const bool is_member_function = false;
 	typedef std::tuple<Args...> arg_tuple_type;
 	typedef types<Args...> args_type;
-	typedef R( function_type )( Args... );
-	typedef R( *function_pointer_type )( Args... );
-	typedef R( *free_function_pointer_type )( Args... );
+	typedef R(function_type)(Args...);
+	typedef R(*function_pointer_type)(Args...);
+	typedef R(*free_function_pointer_type)(Args...);
 	typedef R return_type;
 	template<std::size_t i>
 	using arg = typename std::tuple_element<i, arg_tuple_type>::type;
diff --git a/tests.cpp b/tests.cpp
index a24e92a4..4f23f6e4 100644
--- a/tests.cpp
+++ b/tests.cpp
@@ -81,7 +81,10 @@ TEST_CASE("simple/callWithParameters", "Lua function is called with a few parame
 
     REQUIRE_NOTHROW(lua.script("function my_add(i, j, k) return i + j + k end"));
     auto f = lua.get<sol::function>("my_add");
+    REQUIRE_NOTHROW(lua.script("function my_nothing(i, j, k) end"));
+    auto fvoid = lua.get<sol::function>("my_nothing");
     int a;
+    REQUIRE_NOTHROW(fvoid(1, 2, 3));
     REQUIRE_NOTHROW(a = f.call<int>(1, 2, 3));
     REQUIRE(a == 6);
     REQUIRE_THROWS(a = f.call<int>(1, 2, "arf"));
@@ -111,15 +114,16 @@ TEST_CASE("simple/callLambda", "A C++ lambda is exposed to lua and called") {
 TEST_CASE("advanced/callLambdaReturns", "Checks for lambdas returning values") {
     sol::state lua;
 
-    lua.set_function("a", [ ] { return 42; });
-    lua.set_function("b", [ ] { return 42u; });
-    lua.set_function("c", [ ] { return 3.14; });
-    lua.set_function("d", [ ] { return 6.28f; });
-    lua.set_function("e", [ ] { return "lol"; });
-    lua.set_function("f", [ ] { return true; });
-    lua.set_function("g", [ ] { return std::string("str"); });
-    lua.set_function("h", [ ] { });
-    lua.set_function("i", [ ] { return sol::nil; });
+    REQUIRE_NOTHROW(lua.set_function("a", [ ] { return 42; }));
+    REQUIRE_NOTHROW(lua.set_function("b", [ ] { return 42u; }));
+    REQUIRE_NOTHROW(lua.set_function("c", [ ] { return 3.14; }));
+    REQUIRE_NOTHROW(lua.set_function("d", [ ] { return 6.28f; }));
+    REQUIRE_NOTHROW(lua.set_function("e", [ ] { return "lol"; }));
+    REQUIRE_NOTHROW(lua.set_function("f", [ ] { return true; }));
+    REQUIRE_NOTHROW(lua.set_function("g", [ ] { return std::string("str"); }));
+    REQUIRE_NOTHROW(lua.set_function("h", [ ] { }));
+    REQUIRE_NOTHROW(lua.set_function("i", [ ] { return sol::nil; }));
+    REQUIRE_NOTHROW(lua.set_function("j", [ ] { return std::make_tuple(1, 6.28f, 3.14, std::string( "heh" )); } ));
 }
 
 TEST_CASE("advanced/callLambda2", "A C++ lambda is exposed to lua and called") {
@@ -165,7 +169,7 @@ TEST_CASE("tables/functions_variables", "Check if tables and function calls work
             std::cout << "stateless lambda()" << std::endl;
             return "test";
         }
-   );
+    );
     REQUIRE_NOTHROW(run_script(lua));
 
     lua.get<sol::table>("os").set_function("fun", &free_function);
@@ -183,7 +187,7 @@ TEST_CASE("tables/functions_variables", "Check if tables and function calls work
         std::cout << "stateless lambda()" << std::endl;
         return "test";
     }
-   );
+    );
     REQUIRE_NOTHROW(run_script(lua));
 
     // r-value, cannot optomize