diff --git a/sol/function.hpp b/sol/function.hpp
index 9da99ede..65ed135f 100644
--- a/sol/function.hpp
+++ b/sol/function.hpp
@@ -31,27 +31,27 @@
 namespace sol {
 class function : public reference {
 private:
-    void luacall (std::size_t argcount, std::size_t resultcount) {
+    void luacall (std::size_t argcount, std::size_t resultcount) const {
         lua_call(state(), static_cast<uint32_t>(argcount), static_cast<uint32_t>(resultcount));
     }
 
     template<typename... Ret>
-    std::tuple<Ret...> invoke(types<Ret...>, std::size_t n) {
+    std::tuple<Ret...> invoke(types<Ret...>, std::size_t n) const {
         luacall(n, sizeof...(Ret));
         return stack::pop_reverse_call(state(), std::make_tuple<Ret...>, types<Ret...>());
     }
 
     template<typename Ret>
-    Ret invoke(types<Ret>, std::size_t n) {
+    Ret invoke(types<Ret>, std::size_t n) const {
         luacall(n, 1);
         return stack::pop<Ret>(state());
     }
 
-    void invoke(types<void>, std::size_t n) {
+    void invoke(types<void>, std::size_t n) const {
         luacall(n, 0);
     }
 
-    void invoke(types<>, std::size_t n) {
+    void invoke(types<>, std::size_t n) const {
         luacall(n, 0);
     }
 
@@ -64,17 +64,17 @@ public:
     function& operator=(const function&) = default;
 
     template<typename... Args>
-    void operator()(Args&&... args) {
+    void operator()(Args&&... args) const {
         call<>(std::forward<Args>(args)...);
     }
 
     template<typename... Ret, typename... Args>
-    typename return_type<Ret...>::type operator()(types<Ret...>, Args&&... args) {
+    typename return_type<Ret...>::type operator()(types<Ret...>, Args&&... args) const {
         return call<Ret...>(std::forward<Args>(args)...);
     }
 
     template<typename... Ret, typename... Args>
-    typename return_type<Ret...>::type call(Args&&... args) {
+    typename return_type<Ret...>::type call(Args&&... args) const {
         push();
         stack::push_args(state(), std::forward<Args>(args)...);
         return invoke(types<Ret...>(), sizeof...(Args));
@@ -83,10 +83,37 @@ public:
 
 namespace stack {
 namespace detail {
-    template <typename Signature>
-    inline std::function<Signature> get(types<std::function<Signature>>, lua_State* L, int index = -1) {
-        return std::function<Signature>(sol::function(L, index));
-    }
+template <typename Signature, typename... FxArgs, typename... Ret>
+inline std::function<Signature> get_std_func(types<FxArgs...>, types<Ret...>, lua_State* L, int index = -1) {
+    typedef typename function_traits<Signature>::return_type return_t;
+    sol::function f(L, index);
+    auto fx = [ f, L, index ] (FxArgs&&... args) -> return_t {
+        return f(types<Ret...>(), std::forward<FxArgs>(args)...);
+    };
+    return std::move(fx);
+}
+
+template <typename Signature, typename... FxArgs>
+inline std::function<Signature> get_std_func(types<FxArgs...>, types<void>, lua_State* L, int index = -1) {
+    sol::function f(L, index);
+    auto fx = [ f, L, index ] (FxArgs&&... args) -> void {
+        f(std::forward<FxArgs>(args)...);
+    };
+    return std::move(fx);
+}
+
+template <typename Signature, typename... FxArgs>
+inline std::function<Signature> get_std_func(types<FxArgs...> t, types<>, lua_State* L, int index = -1) {
+    return get_std_func<Signature>(std::move(t), types<void>(), L, index);
+}
+
+template <typename Signature>
+inline std::function<Signature> get(types<std::function<Signature>>, lua_State* L, int index = -1) {
+    typedef typename function_traits<Signature> fx_t;
+    typedef typename fx_t::args_type args_t;
+    typedef typename tuple_types<typename fx_t::return_type>::types_type ret_t;
+    return get_std_func<Signature>(args_t(), ret_t(), L, index);
+}
 } // detail
 } // stack
 } // sol