diff --git a/sol/proxy.hpp b/sol/proxy.hpp
new file mode 100644
index 00000000..09097660
--- /dev/null
+++ b/sol/proxy.hpp
@@ -0,0 +1,129 @@
+// 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 "traits.hpp"
+#include "object.hpp"
+#include "function.hpp"
+
+namespace sol {
+template <typename Table, typename Key>
+struct proxy {
+private:
+    Table& tbl;
+    Key& key;
+
+public:
+
+    template <typename T>
+    proxy(Table& table, T&& key) : tbl(table), key(std::forward<T>(key)) {
+
+    }
+
+    template<typename T>
+    T get() const {
+        return tbl.get<T>(key);
+    }
+
+    template<typename T>
+    proxy& set(T&& item) {
+        tbl.set(key, std::forward<T>(item));
+        return *this;
+    }
+
+    template<typename... Args>
+    proxy& set_function(Args&&... args) {
+        tbl.set_function(key, std::forward<Args>(args)...);
+        return *this;
+    }
+
+    template<typename U>
+    EnableIf<Function<Unqualified<U>>> operator=(U&& other) {
+        tbl.set_function(key, std::forward<U>(other));
+    }
+
+    template<typename U>
+    DisableIf<Function<Unqualified<U>>> operator=(U&& other) {
+        tbl.set(key, std::forward<U>(other));
+    }
+
+    operator nil_t () const {
+        return get<nil_t>();
+    }
+
+    operator object() const {
+        return get<object>();
+    }
+
+    operator function() const {
+        return get<function>();
+    }
+
+    operator std::string() const {
+        return get<std::string>();
+    }
+
+    template <typename T = void>
+    operator bool() const {
+        return get<bool>();
+    }
+
+    template <typename T = void>
+    operator double() const {
+        return get<double>();
+    }
+
+    template <typename T = void>
+    operator float() const {
+        return get<float>();
+    }
+
+    template <typename T = void>
+    operator int() const {
+        return get<int>();
+    }
+
+    template<typename... Ret, typename... Args>
+    typename multi_return<Ret...>::type call(Args&&... args) {
+        return tbl.get<function>(key)(types<Ret...>(), std::forward<Args>(args)...);
+    }
+};
+
+template <typename Table, typename Key, typename T>
+inline bool operator== (T&& left, const proxy<Table, Key>& right) {
+    return left == right.template get<Decay<T>>();
+}
+
+template <typename Table, typename Key, typename T>
+inline bool operator== (const proxy<Table, Key>& right, T&& left) {
+    return right.template get<Decay<T>>() == left;
+}
+
+template <typename Table, typename Key, typename T>
+inline bool operator!= (T&& left, const proxy<Table, Key>& right) {
+    return right.template get<Decay<T>>() != left;
+}
+
+template <typename Table, typename Key, typename T>
+inline bool operator!= (const proxy<Table, Key>& right, T&& left) {
+    return right.template get<Decay<T>>() != left;
+}
+
+} // sol
\ No newline at end of file
diff --git a/sol/stack.hpp b/sol/stack.hpp
index 6bb1608f..50ca2540 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -208,7 +208,7 @@ inline int push_user(lua_State* L, T& item) {
 namespace detail {
 template<typename T, std::size_t... I>
 inline void push_tuple(lua_State* L, indices<I...>, T&& tuplen) {
-    using swallow = char[ 1 + sizeof...(I) ];
+    using swallow = char[1 + sizeof...(I)];
     swallow {'\0', (sol::stack::push(L, std::get<I>(tuplen)), '\0')... };
 }
 
diff --git a/sol/state.hpp b/sol/state.hpp
index d9735404..1c933903 100644
--- a/sol/state.hpp
+++ b/sol/state.hpp
@@ -173,6 +173,16 @@ public:
     table registry() const {
         return reg;
     }
+
+    template <typename T>
+    proxy<table, T> operator[](T&& key) {
+        return global[std::forward<T>(key)];
+    }
+
+    template <typename T>
+    proxy<const table, T> operator[](T&& key) const {
+        return global[std::forward<T>(key)];
+    }
 };
 } // sol
 
diff --git a/sol/table.hpp b/sol/table.hpp
index 823a8b4f..39d18914 100644
--- a/sol/table.hpp
+++ b/sol/table.hpp
@@ -22,6 +22,7 @@
 #ifndef SOL_TABLE_HPP
 #define SOL_TABLE_HPP
 
+#include "proxy.hpp"
 #include "stack.hpp"
 #include "lua_function.hpp"
 #include <array>
@@ -117,6 +118,17 @@ public:
         push();
         return lua_rawlen(state(), -1);
     }
+
+    template <typename T>
+    proxy<table, T> operator[](T&& key) {
+        return proxy<table, T>(*this, std::forward<T>(key));
+    }
+
+    template <typename T>
+    proxy<const table, T> operator[](T&& key) const {
+        return proxy<const table, T>(*this, std::forward<T>(key));
+    }
+
 private:
     template<typename T, typename TFx>
     table& set_isfunction_fx(std::true_type, T&& key, TFx&& fx) {
@@ -170,7 +182,7 @@ private:
         void* userobjdata = static_cast<void*>(detail::get_ptr(obj));
         lua_CFunction freefunc = &static_object_lua_func<Decay<TObj>, TFx>::call;
         const char* freefuncname = fkey.c_str();
-        const luaL_Reg funcreg[ 2 ] = {
+        const luaL_Reg funcreg[2] = {
             { freefuncname, freefunc },
             { nullptr, nullptr }
         };
@@ -192,7 +204,7 @@ private:
         Decay<TFx> target(std::forward<TFx>(fx));
         lua_CFunction freefunc = &static_lua_func<TFx>::call;
         const char* freefuncname = fkey.c_str();
-        const luaL_Reg funcreg[ 2 ] = {
+        const luaL_Reg funcreg[2] = {
             { freefuncname, freefunc },
             { nullptr, nullptr }
         };
@@ -217,7 +229,7 @@ private:
         lua_CFunction freefunc = &lua_func::call;
         const char* freefuncname = fkey.c_str();
         const char* metatablename = metakey.c_str();
-        const luaL_Reg funcreg[ 2 ] = {
+        const luaL_Reg funcreg[2] = {
             { freefuncname, freefunc },
             { nullptr, nullptr }
         };
diff --git a/sol/traits.hpp b/sol/traits.hpp
index 91b9ed5c..cb082ca7 100644
--- a/sol/traits.hpp
+++ b/sol/traits.hpp
@@ -56,6 +56,32 @@ struct multi_return<> : types<>{
 template<bool B>
 using Bool = std::integral_constant<bool, B>;
 
+namespace detail {
+template<typename T, bool isclass = std::is_class<Unqualified<T>>::value>
+struct is_function_impl : std::is_function<typename std::remove_pointer<T>::type> { };
+
+template<typename T>
+struct is_function_impl<T, true> {
+    using yes = char;
+    using no = struct { char s[2]; };
+
+    struct F { void operator()(); };
+    struct Derived : T, F { };
+    template<typename U, U> struct Check;
+
+    template<typename V>
+    static no test(Check<void (F::*)(), &V::operator()>*);
+
+    template<typename>
+    static yes test(...);
+
+    static const bool value = sizeof(test<Derived>(0)) == sizeof(yes);
+};
+} // detail
+
+template<typename T>
+struct Function : Bool<detail::is_function_impl<T>::value> { };
+
 template<typename TFuncSignature>
 struct function_traits;
 
diff --git a/tests.cpp b/tests.cpp
index 9c6af2f1..8ec1a907 100644
--- a/tests.cpp
+++ b/tests.cpp
@@ -56,7 +56,7 @@ TEST_CASE("simple/get", "Tests if the get function works properly.") {
     REQUIRE(e == true);
 }
 
-TEST_CASE("simple/addition", "") {
+TEST_CASE("simple/addition", "check if addition works and can be gotten through lua.get and lua.set") {
     sol::state lua;
 
     lua.set("b", 0.2);
@@ -66,7 +66,7 @@ TEST_CASE("simple/addition", "") {
     REQUIRE(c == 9.2);
 }
 
-TEST_CASE("simple/if", "") {
+TEST_CASE("simple/if", "check if if statements work through lua") {
     sol::state lua;
 
     std::string program = "if true then f = 0.1 else f = 'test' end";
@@ -74,9 +74,10 @@ TEST_CASE("simple/if", "") {
     auto f = lua.get<double>("f");
 
     REQUIRE(f == 0.1);
+    REQUIRE((f == lua["f"]));
 }
 
-TEST_CASE("simple/callWithParameters", "Lua function is called with a few parameters from C++") {
+TEST_CASE("simple/call_with_parameters", "Lua function is called with a few parameters from C++") {
     sol::state lua;
 
     REQUIRE_NOTHROW(lua.script("function my_add(i, j, k) return i + j + k end"));
@@ -90,7 +91,7 @@ TEST_CASE("simple/callWithParameters", "Lua function is called with a few parame
     REQUIRE_THROWS(a = f.call<int>(1, 2, "arf"));
 }
 
-TEST_CASE("simple/callCppFunction", "C++ function is called from lua") {
+TEST_CASE("simple/call_c++_function", "C++ function is called from lua") {
     sol::state lua;
 
     lua.set_function("plop_xyz", plop_xyz);
@@ -99,58 +100,93 @@ TEST_CASE("simple/callCppFunction", "C++ function is called from lua") {
     REQUIRE(lua.get<int>("x") == 11);
 }
 
-TEST_CASE("simple/callLambda", "A C++ lambda is exposed to lua and called") {
+TEST_CASE("simple/call_lambda", "A C++ lambda is exposed to lua and called") {
     sol::state lua;
 
     int x = 0;
 
-    lua.set_function("foo", [ &x ] { x = 1; });
+    lua.set_function("foo", [&x] { x = 1; });
 
     lua.script("foo()");
 
     REQUIRE(x == 1);
 }
 
-TEST_CASE("advanced/callLambdaReturns", "Checks for lambdas returning values") {
+TEST_CASE("advanced/get_and_call", "Checks for lambdas returning values after a get operation") {
     const static std::string lol = "lol", str = "str";
     const static std::tuple<int, float, double, std::string> heh_tuple = std::make_tuple(1, 6.28f, 3.14, std::string("heh"));
     sol::state lua;
 
-    REQUIRE_NOTHROW(lua.set_function("a", [ ] { return 42; }));
+    REQUIRE_NOTHROW(lua.set_function("a", [] { return 42; }));
     REQUIRE(lua.get<sol::function>("a").call<int>() == 42);
     
-    REQUIRE_NOTHROW(lua.set_function("b", [ ] { return 42u; }));
+    REQUIRE_NOTHROW(lua.set_function("b", [] { return 42u; }));
     REQUIRE(lua.get<sol::function>("b").call<unsigned int>() == 42u);
 
-    REQUIRE_NOTHROW(lua.set_function("c", [ ] { return 3.14; }));
+    REQUIRE_NOTHROW(lua.set_function("c", [] { return 3.14; }));
     REQUIRE(lua.get<sol::function>("c").call<double>() == 3.14);
 
-    REQUIRE_NOTHROW(lua.set_function("d", [ ] { return 6.28f; }));
+    REQUIRE_NOTHROW(lua.set_function("d", [] { return 6.28f; }));
     REQUIRE(lua.get<sol::function>("d").call<float>() == 6.28f);
 
-    REQUIRE_NOTHROW(lua.set_function("e", [ ] { return "lol"; }));
+    REQUIRE_NOTHROW(lua.set_function("e", [] { return "lol"; }));
     REQUIRE(lua.get<sol::function>("e").call<std::string>() == lol);
 
-    REQUIRE_NOTHROW(lua.set_function("f", [ ] { return true; }));
+    REQUIRE_NOTHROW(lua.set_function("f", [] { return true; }));
     REQUIRE(lua.get<sol::function>("f").call<bool>());
 
-    REQUIRE_NOTHROW(lua.set_function("g", [ ] { return std::string("str"); }));
+    REQUIRE_NOTHROW(lua.set_function("g", [] { return std::string("str"); }));
     REQUIRE(lua.get<sol::function>("g").call<std::string>() == str);
 
-    REQUIRE_NOTHROW(lua.set_function("h", [ ] { }));
+    REQUIRE_NOTHROW(lua.set_function("h", [] { }));
     REQUIRE_NOTHROW(lua.get<sol::function>("h").call());
 
-    REQUIRE_NOTHROW(lua.set_function("i", [ ] { return sol::nil; }));
+    REQUIRE_NOTHROW(lua.set_function("i", [] { return sol::nil; }));
     REQUIRE(lua.get<sol::function>("i").call<sol::nil_t>() == sol::nil);
-    REQUIRE_NOTHROW(lua.set_function("j", [ ] { return std::make_tuple(1, 6.28f, 3.14, std::string("heh")); }));
+    REQUIRE_NOTHROW(lua.set_function("j", [] { return std::make_tuple(1, 6.28f, 3.14, std::string("heh")); }));
     REQUIRE((lua.get<sol::function>("j").call<int, float, double, std::string>() == heh_tuple));
 }
 
-TEST_CASE("advanced/callLambda2", "A C++ lambda is exposed to lua and called") {
+TEST_CASE("advanced/operator[]_calls", "Checks for lambdas returning values using operator[]") {
+    const static std::string lol = "lol", str = "str";
+    const static std::tuple<int, float, double, std::string> heh_tuple = std::make_tuple(1, 6.28f, 3.14, std::string("heh"));
+    sol::state lua;
+
+    REQUIRE_NOTHROW(lua.set_function("a", [] { return 42; }));
+    REQUIRE(lua["a"].call<int>() == 42);
+    
+    REQUIRE_NOTHROW(lua.set_function("b", [] { return 42u; }));
+    REQUIRE(lua["b"].call<unsigned int>() == 42u);
+
+    REQUIRE_NOTHROW(lua.set_function("c", [] { return 3.14; }));
+    REQUIRE(lua["c"].call<double>() == 3.14);
+
+    REQUIRE_NOTHROW(lua.set_function("d", [] { return 6.28f; }));
+    REQUIRE(lua["d"].call<float>() == 6.28f);
+
+    REQUIRE_NOTHROW(lua.set_function("e", [] { return "lol"; }));
+    REQUIRE(lua["e"].call<std::string>() == lol);
+
+    REQUIRE_NOTHROW(lua.set_function("f", [] { return true; }));
+    REQUIRE(lua["f"].call<bool>());
+
+    REQUIRE_NOTHROW(lua.set_function("g", [] { return std::string("str"); }));
+    REQUIRE(lua["g"].call<std::string>() == str);
+
+    REQUIRE_NOTHROW(lua.set_function("h", [] { }));
+    REQUIRE_NOTHROW(lua["h"].call());
+
+    REQUIRE_NOTHROW(lua.set_function("i", [] { return sol::nil; }));
+    REQUIRE(lua["i"].call<sol::nil_t>() == sol::nil);
+    REQUIRE_NOTHROW(lua.set_function("j", [] { return std::make_tuple(1, 6.28f, 3.14, std::string("heh")); }));
+    REQUIRE((lua["j"].call<int, float, double, std::string>() == heh_tuple));
+}
+
+TEST_CASE("advanced/call_lambdas", "A C++ lambda is exposed to lua and called") {
     sol::state lua;
 
     int x = 0;
-    lua.set_function("set_x", [ &] (int new_x) {
+    lua.set_function("set_x", [&] (int new_x) {
         x = new_x;
         return 0;
     });
@@ -159,13 +195,13 @@ TEST_CASE("advanced/callLambda2", "A C++ lambda is exposed to lua and called") {
     REQUIRE(x == 9);
 }
 
-TEST_CASE("negative/basicError", "Check if error handling works correctly") {
+TEST_CASE("negative/basic_errors", "Check if error handling works correctly") {
     sol::state lua;
 
     REQUIRE_THROWS(lua.script("nil[5]"));
 }
 
-TEST_CASE("libraries", "Check if we can open libraries through sol") {
+TEST_CASE("libraries", "Check if we can open libraries") {
     sol::state lua;
     REQUIRE_NOTHROW(lua.open_libraries(sol::lib::base, sol::lib::os));
 }
@@ -180,16 +216,16 @@ TEST_CASE("tables/variables", "Check if tables and variables work as intended")
 TEST_CASE("tables/functions_variables", "Check if tables and function calls work as intended") {
     sol::state lua;
     lua.open_libraries(sol::lib::base, sol::lib::os);
-    auto run_script = [ ] (sol::state& lua) -> void {
+    auto run_script = [] (sol::state& lua) -> void {
         lua.script("assert(os.fun() == \"test\")");
     };
 
     lua.get<sol::table>("os").set_function("fun",
-        [ ] () {
+        [] () {
             std::cout << "stateless lambda()" << std::endl;
             return "test";
         }
-    );
+   );
     REQUIRE_NOTHROW(run_script(lua));
 
     lua.get<sol::table>("os").set_function("fun", &free_function);
@@ -203,11 +239,11 @@ TEST_CASE("tables/functions_variables", "Check if tables and function calls work
     // stateful lambda: non-convertible, unoptomizable
     int breakit = 50;
     lua.get<sol::table>("os").set_function("fun",
-        [ &breakit ] () {
+        [&breakit] () {
         std::cout << "stateless lambda()" << std::endl;
         return "test";
     }
-    );
+   );
     REQUIRE_NOTHROW(run_script(lua));
 
     // r-value, cannot optomize
@@ -220,12 +256,12 @@ TEST_CASE("tables/functions_variables", "Check if tables and function calls work
     REQUIRE_NOTHROW(run_script(lua));
 }
 
-TEST_CASE("functions/return_order_and_multi_get", "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", [ ] { 
-        return std::make_tuple( 10, 11, 12 ); 
-    } );
+    lua.set_function("f", [] { 
+        return std::make_tuple(10, 11, 12); 
+    });
     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>();
@@ -236,4 +272,55 @@ TEST_CASE("functions/return_order_and_multi_get", "Check if return order is in t
     REQUIRE(tcpp == triple);
     REQUIRE(tlua == triple);
     REQUIRE(tluaget == triple);
-}
\ No newline at end of file
+}
+
+TEST_CASE("tables/operator[]", "Check if operator[] retrieval and setting works properly") {
+    sol::state lua;
+    lua.open_libraries(sol::lib::base);
+
+    lua.script("foo = 20\nbar = \"hello world\"");
+    // basic retrieval 
+    std::string bar = lua["bar"];
+    int foo = lua["foo"];
+    REQUIRE(bar == "hello world");
+    REQUIRE(foo == 20);
+    // test operator= for stringification
+    // errors due to ambiguous operators
+    bar = lua["bar"];
+
+    // basic setting
+    lua["bar"] = 20.4;
+    lua["foo"] = "goodbye";
+
+    // doesn't modify the actual values obviously.
+    REQUIRE(bar == "hello world");
+    REQUIRE(foo == 20);
+
+    // function setting
+    lua["test"] = plop_xyz;
+    REQUIRE_NOTHROW(lua.script("assert(test(10, 11, \"hello\") == 11)"));
+
+    // function retrieval
+    sol::function test = lua["test"];
+    REQUIRE(test.call<int>(10, 11, "hello") == 11);
+
+    // setting a lambda
+    lua["lamb"] = [](int x) {
+        return x * 2;
+    };
+
+    REQUIRE_NOTHROW(lua.script("assert(lamb(220) == 440)"));
+
+    // function retrieval of a lambda
+    sol::function lamb = lua["lamb"];
+    REQUIRE(lamb.call<int>(220) == 440);
+
+    // test const table retrieval
+    auto assert1 = [](const sol::table& t) {
+        std::string a = t["foo"];
+        int b = t["bar"];
+        std::cout << a << ',' << b << '\n';
+    };
+
+    REQUIRE_NOTHROW(assert1(lua.global_table()));
+}