diff --git a/docs/source/api/as_returns.rst b/docs/source/api/as_returns.rst
index a64ea156..1171ff19 100644
--- a/docs/source/api/as_returns.rst
+++ b/docs/source/api/as_returns.rst
@@ -12,7 +12,7 @@ turn an iterable argument into a multiple-return type
 	as_returns_t<T> as_returns( T&& );
 
 
-This allows you to wrap up a source that has ``begin`` and ``end`` iterator-returning functions on it and return it as multiple results into Lua. To have more control over the returns, use :doc:`sol::variadic_results<variadic_results>`
+This allows you to wrap up a source that has ``begin`` and ``end`` iterator-returning functions on it and return it as multiple results into Lua. To have more control over the returns, use :doc:`sol::variadic_results<variadic_results>`.
 
 
 .. code-block:: cpp
diff --git a/docs/source/api/variadic_results.rst b/docs/source/api/variadic_results.rst
index fb9da9ef..1c542c9a 100644
--- a/docs/source/api/variadic_results.rst
+++ b/docs/source/api/variadic_results.rst
@@ -7,5 +7,6 @@ push multiple disparate arguments into lua
 	
 	struct variadic_results : std::vector<object> { ... };
 
-	template <typename T>
-	as_args_t<T> as_args( T&& );
+This type allows someone to prepare multiple returns before returning them into Lua. It derives from ``std::vector``, so it can be used exactly like that, and objects can be added using the various constructors and functions relating to :doc:`sol::object<object>`. You can see it and other return-type helpers in action `here`_.
+
+.. _here: https://github.com/ThePhD/sol2/blob/develop/examples/multi_results.cpp
diff --git a/sol/in_place.hpp b/sol/in_place.hpp
index 1f7af9eb..5e380a2f 100644
--- a/sol/in_place.hpp
+++ b/sol/in_place.hpp
@@ -30,6 +30,7 @@ namespace sol {
 #ifdef SOL_CXX17_FEATURES
 	using in_place_t = std::in_place_t;
 	constexpr std::in_place_t in_place{};
+	constexpr std::in_place_t in_place_of{};
 
 	template <typename T> using in_place_type_t = std::in_place_type_t<T>;
 	template <typename T>
@@ -40,7 +41,7 @@ namespace sol {
 	constexpr in_place_index_t<I> in_place_index{};
 #else
 	namespace detail {
-		struct in_place_of {};
+		struct in_place_of_tag {};
 		template <std::size_t I>
 		struct in_place_of_i {};
 		template <typename T>
@@ -49,18 +50,19 @@ namespace sol {
 
 	struct in_place_tag { constexpr in_place_tag() = default; };
 	
-	constexpr inline in_place_tag in_place (detail::in_place_of) { return in_place_tag(); }
+	constexpr inline in_place_tag in_place (detail::in_place_of_tag) { return in_place_tag(); }
 	template <typename T>
 	constexpr inline in_place_tag in_place (detail::in_place_of_t<T>) { return in_place_tag(); }
 	template <std::size_t I>
 	constexpr inline in_place_tag in_place (detail::in_place_of_i<I>) { return in_place_tag(); }
 
+	constexpr inline in_place_tag in_place_of(detail::in_place_of_tag) { return in_place_tag(); }
 	template <typename T>
 	constexpr inline in_place_tag in_place_type (detail::in_place_of_t<T>) { return in_place_tag(); }
 	template <std::size_t I>
 	constexpr inline in_place_tag in_place_index (detail::in_place_of_i<I>) { return in_place_tag(); }
 
-	using in_place_t = in_place_tag(&)(detail::in_place_of);
+	using in_place_t = in_place_tag(&)(detail::in_place_of_tag);
 	template <typename T>
 	using in_place_type_t = in_place_tag(&)(detail::in_place_of_t<T>);
 	template <std::size_t I>
diff --git a/sol/object.hpp b/sol/object.hpp
index f520ab9c..c2c507ea 100644
--- a/sol/object.hpp
+++ b/sol/object.hpp
@@ -80,9 +80,11 @@ namespace sol {
 		basic_object(lua_State* L, int index = -1) noexcept : base_t(L, index) {}
 		basic_object(lua_State* L, ref_index index) noexcept : base_t(L, index) {}
 		template <typename T, typename... Args>
-		basic_object(lua_State* L, in_place_type_t<T>, Args&&... args) noexcept : basic_object(std::integral_constant<bool, !std::is_base_of<stack_reference, base_t>::value>(), L, -stack::push<T>(L, std::forward<Args>(args)...)) {}
+		basic_object(lua_State* L, in_place_type_t<T>, Args&&... args) noexcept 
+		: basic_object(std::integral_constant<bool, !std::is_base_of<stack_reference, base_t>::value>(), L, -stack::push<T>(L, std::forward<Args>(args)...)) {}
 		template <typename T, typename... Args>
-		basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept : basic_object(L, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {}
+		basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept 
+		: basic_object(L, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {}
 		basic_object& operator=(const basic_object&) = default;
 		basic_object& operator=(basic_object&&) = default;
 		basic_object& operator=(const base_type& b) { base_t::operator=(b); return *this; }
diff --git a/test_variadics.cpp b/test_variadics.cpp
index 127b707a..678b0832 100644
--- a/test_variadics.cpp
+++ b/test_variadics.cpp
@@ -141,17 +141,17 @@ TEST_CASE("variadics/variadic_results", "returning a variable amount of argument
 		lua.set_function("f", [](sol::this_state ts, bool maybe) {
 			if (maybe) {
 				sol::variadic_results vr;
-				vr.emplace_back(ts, sol::in_place<int>, 1);
+				vr.push_back({ ts, sol::in_place, 1 });
 				vr.push_back({ ts, sol::in_place, 2 });
 				vr.insert(vr.cend(), { ts, sol::in_place, 3 });
 				return vr;
 			}
 			else {
 				sol::variadic_results vr;
-				vr.emplace_back(ts, sol::in_place<const char*>, "bark");
-				vr.push_back({ ts, sol::in_place<const char*>, "woof" });
-				vr.insert(vr.cend(), { ts, sol::in_place<const char*>, "arf" });
-				vr.emplace_back(ts, sol::in_place<const char*>, "borf");
+				vr.push_back({ ts, sol::in_place, "bark" });
+				vr.push_back({ ts, sol::in_place, "woof" });
+				vr.insert(vr.cend(), { ts, sol::in_place, "arf" });
+				vr.push_back({ ts, sol::in_place, "borf" });
 				return vr;
 			}
 		});