diff --git a/.gitmodules b/.gitmodules
index 0dc47189..3263b211 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,19 +1,21 @@
 [submodule "external/toml-test"]
 	path = external/toml-test
 	url = https://github.com/BurntSushi/toml-test.git
+	shallow = true
 [submodule "external/toml-spec-tests"]
 	path = external/toml-spec-tests
 	url = https://github.com/iarna/toml-spec-tests.git
-[submodule "external/dox"]
-	path = external/dox
-	url = https://github.com/marzer/dox.git
-[submodule "external/Catch2"]
-	path = external/Catch2
-	url = https://github.com/catchorg/Catch2.git
-	branch = v2.x
+	shallow = true
 [submodule "external/tloptional"]
 	path = external/tloptional
 	url = https://github.com/TartanLlama/optional.git
+	shallow = true
 [submodule "external/json"]
 	path = external/json
 	url = https://github.com/nlohmann/json.git
+	shallow = true
+[submodule "external/Catch2"]
+	path = external/Catch2
+	url = https://github.com/catchorg/Catch2.git
+	branch = v2.x
+	shallow = true
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6a287e09..58b0e2d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,7 +14,7 @@ template:
 -->
 
 
-## Unreleased
+## [v3.1.0](https://github.com/marzer/tomlplusplus/releases/tag/v3.1.0) - 2022-04-22
 
 #### Fixes:
 - Fixed potential segfault when calling `at_path()` with an empty string
@@ -22,9 +22,11 @@ template:
 - Fixed a number of spurious warnings with Clang 10 (#145, #146) (@chronoxor)
 
 #### Additions:
+- Added `toml::array::for_each()`
+- Added `toml::table::for_each()`
 - Added config options `TOML_EXPORTED_CLASS`, `TOML_EXPORTED_MEMBER_FUNCTION`, `TOML_EXPORTED_STATIC_FUNCTION` & `TOML_EXPORTED_FREE_FUNCTION`
-- Add support for escape sequence `\e` when using `TOML_ENABLE_UNRELEASED_FEATURES` ([toml/790](https://github.com/toml-lang/toml/pull/790))
-- Add support for more unicode in bare keys when using `TOML_ENABLE_UNRELEASED_FEATURES` ([toml/891](https://github.com/toml-lang/toml/pull/891))
+- Added support for escape sequence `\e` when using `TOML_ENABLE_UNRELEASED_FEATURES` ([toml/790](https://github.com/toml-lang/toml/pull/790))
+- Added support for more unicode in bare keys when using `TOML_ENABLE_UNRELEASED_FEATURES` ([toml/891](https://github.com/toml-lang/toml/pull/891))
 
 #### Removals/Deprecations:
 - Deprecated old `TOML_API` option in favour new `TOML_EXPORTED_X` options
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e7a0b8ca..41e55dd8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.14)
 
 project(
     tomlplusplus
-    VERSION 3.0.1
+    VERSION 3.1.0
     DESCRIPTION "Header-only TOML config file parser and serializer for C++17"
     HOMEPAGE_URL "https://marzer.github.io/tomlplusplus/"
     LANGUAGES CXX
diff --git a/README.md b/README.md
index 0f892ae2..e39dfa4a 100644
--- a/README.md
+++ b/README.md
@@ -99,13 +99,13 @@ You'll find some more code examples in the `examples` directory, and plenty more
 2. `#include <toml++/toml.h>`
 
 ### Conan
-Add `tomlplusplus/3.0.1` to your conanfile.
+Add `tomlplusplus/3.1.0` to your conanfile.
 
 ### DDS
 Add `tomlpp` to your `package.json5`, e.g.:
 ```
 depends: [
-    'tomlpp^3.0.1',
+    'tomlpp^3.1.0',
 ]
 ```
 > ℹ&#xFE0F; _[What is DDS?](https://dds.pizza/)_
@@ -121,12 +121,21 @@ include(FetchContent)
 FetchContent_Declare(
     tomlplusplus
     GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
-    GIT_TAG        v3.0.1
+    GIT_TAG        v3.1.0
 )
 FetchContent_MakeAvailable(tomlplusplus)
 ```
 > ℹ&#xFE0F; _[What is FetchContent?](https://cmake.org/cmake/help/latest/module/FetchContent.html)_
 
+### Git submodules
+```
+git submodule add --depth 1 https://github.com/marzer/tomlplusplus.git tomlplusplus
+git config -f .gitmodules submodule.tomlplusplus.shallow true
+```
+> ℹ&#xFE0F; The toml++ repository has some submodules of its own, but **they are only used for testing**!
+> You do not need to use the `--recursive` option for regular library consumption.
+
+
 ### Other environments and package managers
 `toml++` is a fairly new project and I'm not up-to-speed with all of the available packaging and integration options
 in the C++ ecosystem. I'm also a cmake novice, for better or worse. If there's an integration option missing be
diff --git a/docs/pages/main_page.dox b/docs/pages/main_page.dox
index 13ac7a9a..3ffe9e61 100644
--- a/docs/pages/main_page.dox
+++ b/docs/pages/main_page.dox
@@ -457,7 +457,7 @@
 
 
  \subsection mainpage-adding-lib-conan Conan
- Add `tomlplusplus/3.0.1` to your conanfile.
+ Add `tomlplusplus/3.1.0` to your conanfile.
 
 
 
@@ -465,7 +465,7 @@
  Add `tomlpp` to your `package.json5`, e.g.:
  \bash
  depends: [
-		'tomlpp^3.0.1',
+		'tomlpp^3.1.0',
  ]
  \ebash
 
@@ -497,7 +497,7 @@
  FetchContent_Declare(
      tomlplusplus
      GIT_REPOSITORY https://github.com/marzer/tomlplusplus.git
-     GIT_TAG        v3.0.1
+     GIT_TAG        v3.1.0
  )
  FetchContent_MakeAvailable(tomlplusplus)
  \endcode
@@ -506,6 +506,16 @@
 
 
 
+\subsection mainpage-adding-lib-git-submodules Git submodules
+\bash
+git submodule add --depth 1 https://github.com/marzer/tomlplusplus.git tomlplusplus
+git config -f .gitmodules submodule.tomlplusplus.shallow true
+\ebash
+\note The toml++ repository has some submodules of its own, but **they are only used for testing**! You do not need to
+use the `--recursive` option for regular library consumption.
+
+
+
  \subsection mainpage-adding-lib-other Other environments and package managers
  toml++ is a fairly new project and I'm not up-to-speed with all of the available packaging and integration options
  in the C++ ecosystem. I'm also a cmake novice, for better or worse. If there's an integration option missing
diff --git a/external/Catch2 b/external/Catch2
index 958944d2..d71b4617 160000
--- a/external/Catch2
+++ b/external/Catch2
@@ -1 +1 @@
-Subproject commit 958944d27a2d2fb82aa008377bf4f8752f6b848e
+Subproject commit d71b4617e9935f8589870af211f5b7552d743654
diff --git a/external/json b/external/json
index e4643d1f..fcc36f99 160000
--- a/external/json
+++ b/external/json
@@ -1 +1 @@
-Subproject commit e4643d1f1b03fc7a1d7b65f17e012ca93680cad8
+Subproject commit fcc36f99ba1afc7baebe24e0c7429d2039d32d99
diff --git a/external/toml-test b/external/toml-test
index 983c1a54..10cdc99d 160000
--- a/external/toml-test
+++ b/external/toml-test
@@ -1 +1 @@
-Subproject commit 983c1a54c5faad31b5d217b1e47c0e074dea7840
+Subproject commit 10cdc99d96fbf1350a8891a9d93295fcc85aa694
diff --git a/include/toml++/impl/array.h b/include/toml++/impl/array.h
index 7372933d..29c9168b 100644
--- a/include/toml++/impl/array.h
+++ b/include/toml++/impl/array.h
@@ -773,7 +773,7 @@ TOML_NAMESPACE_START
 
 		/// @}
 
-		/// \name Iterators
+		/// \name Iteration
 		/// @{
 
 		/// \brief A RandomAccessIterator for iterating over elements in a toml::array.
@@ -824,6 +824,232 @@ TOML_NAMESPACE_START
 			return const_iterator{ elems_.cend() };
 		}
 
+	  private:
+		/// \cond
+
+		template <typename T, typename Array>
+		using for_each_elem_ref = impl::copy_cvref<impl::wrap_node<impl::remove_cvref<impl::unwrap_node<T>>>, Array>;
+
+		template <typename Func, typename Array, typename T>
+		static constexpr bool can_for_each = std::is_invocable_v<Func, for_each_elem_ref<T, Array>, size_t> //
+										  || std::is_invocable_v<Func, size_t, for_each_elem_ref<T, Array>> //
+										  || std::is_invocable_v<Func, for_each_elem_ref<T, Array>>;
+
+		template <typename Func, typename Array, typename T>
+		static constexpr bool can_for_each_nothrow =
+			std::is_nothrow_invocable_v<Func, for_each_elem_ref<T, Array>, size_t>	  //
+			|| std::is_nothrow_invocable_v<Func, size_t, for_each_elem_ref<T, Array>> //
+			|| std::is_nothrow_invocable_v<Func, for_each_elem_ref<T, Array>>;
+
+		template <typename Func, typename Array>
+		static constexpr bool can_for_each_any = can_for_each<Func, Array, table>		//
+											  || can_for_each<Func, Array, array>		//
+											  || can_for_each<Func, Array, std::string> //
+											  || can_for_each<Func, Array, int64_t>		//
+											  || can_for_each<Func, Array, double>		//
+											  || can_for_each<Func, Array, bool>		//
+											  || can_for_each<Func, Array, date>		//
+											  || can_for_each<Func, Array, time>		//
+											  || can_for_each<Func, Array, date_time>;
+
+		template <typename Func, typename Array, typename T>
+		static constexpr bool for_each_is_nothrow_one = !can_for_each<Func, Array, T> //
+													 || can_for_each_nothrow<Func, Array, T>;
+
+		// clang-format off
+
+
+		template <typename Func, typename Array>
+		static constexpr bool for_each_is_nothrow = for_each_is_nothrow_one<Func, Array, table>		  //
+												 && for_each_is_nothrow_one<Func, Array, array>		  //
+												 && for_each_is_nothrow_one<Func, Array, std::string> //
+												 && for_each_is_nothrow_one<Func, Array, int64_t>	  //
+												 && for_each_is_nothrow_one<Func, Array, double>	  //
+												 && for_each_is_nothrow_one<Func, Array, bool>		  //
+												 && for_each_is_nothrow_one<Func, Array, date>		  //
+												 && for_each_is_nothrow_one<Func, Array, time>		  //
+												 && for_each_is_nothrow_one<Func, Array, date_time>;
+
+		// clang-format on
+
+		template <typename Func, typename Array>
+		static void do_for_each(Func&& visitor, Array&& arr) noexcept(for_each_is_nothrow<Func&&, Array&&>)
+		{
+			static_assert(can_for_each_any<Func&&, Array&&>,
+						  "TOML array for_each visitors must be invocable for at least one of the toml::node "
+						  "specializations:" TOML_SA_NODE_TYPE_LIST);
+
+			for (size_t i = 0; i < arr.size(); i++)
+			{
+				using node_ref = impl::copy_cvref<toml::node, Array&&>;
+				static_assert(std::is_reference_v<node_ref>);
+
+				const auto keep_going =
+					static_cast<node_ref>(static_cast<Array&&>(arr)[i])
+						.visit(
+							[&](auto&& elem) noexcept(for_each_is_nothrow_one<Func&&, Array&&, decltype(elem)>)
+							{
+								using elem_ref = for_each_elem_ref<decltype(elem), Array&&>;
+								static_assert(std::is_reference_v<elem_ref>);
+
+								// func(elem, i)
+								if constexpr (std::is_invocable_v<Func&&, elem_ref, size_t>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i);
+										return true;
+									}
+								}
+
+								// func(i, elem)
+								else if constexpr (std::is_invocable_v<Func&&, size_t, elem_ref>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem));
+										return true;
+									}
+								}
+
+								// func(elem)
+								else if constexpr (std::is_invocable_v<Func&&, elem_ref>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem));
+										return true;
+									}
+								}
+
+								// visitor not compatible with this particular type
+								else
+									return true;
+							});
+
+				if (!keep_going)
+					return;
+			}
+		}
+
+		/// \endcond
+
+	  public:
+		/// \brief	Invokes a visitor on each element in the array.
+		///
+		/// \tparam	Func	A callable type invocable with one of the following signatures:
+		///					<ul>
+		///					<li> `func(elem, index)`
+		///					<li> `func(elem)`
+		///					<li> `func(index, elem)`
+		///					</ul>
+		///					Where:
+		///					<ul>
+		///					<li> `elem` will recieve the element as it's concrete type with cvref-qualifications matching the array
+		///					<li> `index` will recieve a `size_t` indicating the element's index
+		///					</ul>
+		///					Visitors returning `bool` (or something convertible to `bool`) will cause iteration to
+		///					stop if they return `false`.
+		///
+		/// \param 	visitor	The visitor object.
+		///
+		/// \returns A reference to the array.
+		///
+		/// \details \cpp
+		/// toml::array arr{ 0, 1, 2, 3.0, "four", "five", 6 };
+		///
+		/// // select only the integers using a strongly-typed visitor
+		/// arr.for_each([](toml::value<int64_t>& elem)
+		/// {
+		///		std::cout << elem << ", ";
+		/// });
+		/// std::cout << "\n";
+		///
+		/// // select all the numeric values using a generic visitor + is_number<> metafunction
+		/// arr.for_each([](auto&& elem)
+		/// {
+		///		if constexpr (toml::is_number<decltype(elem)>)
+		///			std::cout << elem << ", ";
+		/// });
+		/// std::cout << "\n";
+		///
+		/// // select all the numeric values until we encounter something non-numeric
+		/// arr.for_each([](auto&& elem)
+		/// {
+		///		if constexpr (toml::is_number<decltype(elem)>)
+		///		{
+		///			std::cout << elem << ", ";
+		///			return true; // "keep going"
+		///		}
+		///		else
+		///			return false; // "stop!"
+		///
+		/// });
+		/// std::cout << "\n";
+		///
+		/// \ecpp
+		/// \out
+		/// 0, 1, 2, 6,
+		/// 0, 1, 2, 3.0, 6,
+		/// 0, 1, 2, 3.0,
+		/// \eout
+		///
+		/// \see node::visit()
+		template <typename Func>
+		array& for_each(Func&& visitor) & noexcept(for_each_is_nothrow<Func&&, array&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		/// \brief	Invokes a visitor on each element in the array (rvalue overload).
+		template <typename Func>
+		array&& for_each(Func&& visitor) && noexcept(for_each_is_nothrow<Func&&, array&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<array&&>(*this));
+			return static_cast<array&&>(*this);
+		}
+
+		/// \brief	Invokes a visitor on each element in the array (const lvalue overload).
+		template <typename Func>
+		const array& for_each(Func&& visitor) const& noexcept(for_each_is_nothrow<Func&&, const array&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		/// \brief	Invokes a visitor on each element in the array (const rvalue overload).
+		template <typename Func>
+		const array&& for_each(Func&& visitor) const&& noexcept(for_each_is_nothrow<Func&&, const array&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<const array&&>(*this));
+			return static_cast<const array&&>(*this);
+		}
+
 		/// @}
 
 		/// \name Size and Capacity
@@ -1004,8 +1230,6 @@ TOML_NAMESPACE_START
 		array& flatten() &;
 
 		/// \brief	 Flattens this array, recursively hoisting the contents of child arrays up into itself (rvalue overload).
-		///
-		/// \returns An rvalue reference to the array.
 		array&& flatten() &&
 		{
 			return static_cast<toml::array&&>(this->flatten());
diff --git a/include/toml++/impl/forward_declarations.h b/include/toml++/impl/forward_declarations.h
index 2cd795e5..d89ea407 100644
--- a/include/toml++/impl/forward_declarations.h
+++ b/include/toml++/impl/forward_declarations.h
@@ -916,6 +916,10 @@ TOML_IMPL_NAMESPACE_START
 	};
 	template <typename T>
 	inline constexpr node_type node_type_of = node_type_getter<unwrap_node<remove_cvref<T>>>::value;
+
+	template <typename T, typename ConvertFrom>
+	inline constexpr bool is_constructible_or_convertible = std::is_constructible_v<T, ConvertFrom> //
+														 || std::is_convertible_v<ConvertFrom, T>;
 }
 TOML_IMPL_NAMESPACE_END;
 /// \endcond
@@ -990,8 +994,8 @@ TOML_NAMESPACE_START
 
 	/// \brief	Metafunction for determining if a type is, or is a reference to, a toml::node (or one of its subclasses).
 	template <typename T>
-	inline constexpr bool is_node =
-		std::is_same_v<toml::node, impl::remove_cvref<T>> || std::is_base_of_v<toml::node, impl::remove_cvref<T>>;
+	inline constexpr bool is_node = std::is_same_v<toml::node, impl::remove_cvref<T>> //
+								 || std::is_base_of_v<toml::node, impl::remove_cvref<T>>;
 
 	/// \brief	Metafunction for determining if a type is, or is a reference to, a toml::node_view.
 	template <typename T>
diff --git a/include/toml++/impl/key.h b/include/toml++/impl/key.h
index 9ef7b0a3..da407980 100644
--- a/include/toml++/impl/key.h
+++ b/include/toml++/impl/key.h
@@ -287,7 +287,7 @@ TOML_NAMESPACE_START
 
 		/// @}
 
-		/// \name Iterators
+		/// \name Iteration
 		/// @{
 
 		/// A const iterator for iterating over the characters in the key.
@@ -327,8 +327,8 @@ TOML_NAMESPACE_START
 	/// \brief	Metafunction for determining if a type is, or is a reference to, a toml::key,
 	///			or is implicitly or explicitly convertible to one.
 	template <typename T>
-	inline constexpr bool is_key_or_convertible =
-		is_key<T> || std::is_constructible_v<toml::key, T> || std::is_convertible_v<T, toml::key>;
+	inline constexpr bool is_key_or_convertible = is_key<T> //
+											   || impl::is_constructible_or_convertible<toml::key, T>;
 }
 TOML_NAMESPACE_END;
 
diff --git a/include/toml++/impl/node.h b/include/toml++/impl/node.h
index bd8f8e51..5634a13b 100644
--- a/include/toml++/impl/node.h
+++ b/include/toml++/impl/node.h
@@ -530,7 +530,7 @@ TOML_NAMESPACE_START
 		/// 	{
 		/// 		std::cout << "- " << std::setw(18) << std::left << type_name;
 		/// 		using type = std::remove_pointer_t<decltype(dummy)>;
-		/// 		if (std::optional<type> val = tbl.get(key)->value<type>())
+		/// 		if (auto val = tbl.get(key)->value<type>(); val)
 		/// 			std::cout << *val << "\n";
 		/// 		else
 		/// 			std::cout << "n/a\n";
@@ -732,145 +732,141 @@ TOML_NAMESPACE_START
 	  private:
 		/// \cond
 
+		template <typename Func, typename Node, typename T>
+		static constexpr bool can_visit = std::is_invocable_v<Func, ref_cast_type<T, Node>>;
+
+		template <typename Func, typename Node, typename T>
+		static constexpr bool can_visit_nothrow = std::is_nothrow_invocable_v<Func, ref_cast_type<T, Node>>;
+
+		template <typename Func, typename Node>
+		static constexpr bool can_visit_any = can_visit<Func, Node, table>		 //
+										   || can_visit<Func, Node, array>		 //
+										   || can_visit<Func, Node, std::string> //
+										   || can_visit<Func, Node, int64_t>	 //
+										   || can_visit<Func, Node, double>		 //
+										   || can_visit<Func, Node, bool>		 //
+										   || can_visit<Func, Node, date>		 //
+										   || can_visit<Func, Node, time>		 //
+										   || can_visit<Func, Node, date_time>;
+
 		// clang-format off
 
-		template <typename Func, typename N, typename T>
-		static constexpr bool can_visit = std::is_invocable_v<Func, ref_cast_type<T, N>>;
-
-		template <typename Func, typename N>
-		static constexpr bool can_visit_any =
-			can_visit<Func, N, table>
-			|| can_visit<Func, N, array>
-			|| can_visit<Func, N, std::string>
-			|| can_visit<Func, N, int64_t>
-			|| can_visit<Func, N, double>
-			|| can_visit<Func, N, bool>
-			|| can_visit<Func, N, date>
-			|| can_visit<Func, N, time>
-			|| can_visit<Func, N, date_time>;
-
-		template <typename Func, typename N>
-		static constexpr bool can_visit_all =
-			can_visit<Func, N, table>
-			&& can_visit<Func, N, array>
-			&& can_visit<Func, N, std::string>
-			&& can_visit<Func, N, int64_t>
-			&& can_visit<Func, N, double>
-			&& can_visit<Func, N, bool>
-			&& can_visit<Func, N, date>
-			&& can_visit<Func, N, time>
-			&& can_visit<Func, N, date_time>;
-
-		template <typename Func, typename N, typename T>
-		static constexpr bool visit_is_nothrow_one =
-			!can_visit<Func, N, T>
-			|| std::is_nothrow_invocable_v<Func, ref_cast_type<T, N>>;
-
-		template <typename Func, typename N>
-		static constexpr bool visit_is_nothrow =
-			visit_is_nothrow_one<Func, N, table>
-			&& visit_is_nothrow_one<Func, N, array>
-			&& visit_is_nothrow_one<Func, N, std::string>
-			&& visit_is_nothrow_one<Func, N, int64_t>
-			&& visit_is_nothrow_one<Func, N, double>
-			&& visit_is_nothrow_one<Func, N, bool>
-			&& visit_is_nothrow_one<Func, N, date>
-			&& visit_is_nothrow_one<Func, N, time>
-			&& visit_is_nothrow_one<Func, N, date_time>;
+		template <typename Func, typename Node>
+		static constexpr bool can_visit_all = can_visit<Func, Node, table>		 //
+										   && can_visit<Func, Node, array>		 //
+										   && can_visit<Func, Node, std::string> //
+										   && can_visit<Func, Node, int64_t>	 //
+										   && can_visit<Func, Node, double>		 //
+										   && can_visit<Func, Node, bool>		 //
+										   && can_visit<Func, Node, date>		 //
+										   && can_visit<Func, Node, time>		 //
+										   && can_visit<Func, Node, date_time>;
+
+		template <typename Func, typename Node, typename T>
+		static constexpr bool visit_is_nothrow_one = !can_visit<Func, Node, T> || can_visit_nothrow<Func, Node, T>;
+
+		template <typename Func, typename Node>
+		static constexpr bool visit_is_nothrow = visit_is_nothrow_one<Func, Node, table>	   //
+											  && visit_is_nothrow_one<Func, Node, array>	   //
+											  && visit_is_nothrow_one<Func, Node, std::string> //
+											  && visit_is_nothrow_one<Func, Node, int64_t>	   //
+											  && visit_is_nothrow_one<Func, Node, double>	   //
+											  && visit_is_nothrow_one<Func, Node, bool>		   //
+											  && visit_is_nothrow_one<Func, Node, date>		   //
+											  && visit_is_nothrow_one<Func, Node, time>		   //
+											  && visit_is_nothrow_one<Func, Node, date_time>;
 
 		// clang-format on
 
-		template <typename Func, typename N, typename T, bool = can_visit<Func, N, T>>
+		template <typename Func, typename Node, typename T, bool = can_visit<Func, Node, T>>
 		struct visit_return_type_
 		{
-			using type = decltype(std::declval<Func>()(std::declval<ref_cast_type<T, N>>()));
+			using type = decltype(std::declval<Func>()(std::declval<ref_cast_type<T, Node>>()));
 		};
-		template <typename Func, typename N, typename T>
-		struct visit_return_type_<Func, N, T, false>
+		template <typename Func, typename Node, typename T>
+		struct visit_return_type_<Func, Node, T, false>
 		{
 			using type = void;
 		};
 
-		template <typename Func, typename N, typename T>
-		using visit_return_type = typename visit_return_type_<Func, N, T>::type;
+		template <typename Func, typename Node, typename T>
+		using visit_return_type = typename visit_return_type_<Func, Node, T>::type;
 
 		template <typename A, typename B>
 		using nonvoid = std::conditional_t<std::is_void_v<A>, B, A>;
 
-		template <typename N, typename Func>
-		static decltype(auto) do_visit(N&& n, Func&& visitor) noexcept(visit_is_nothrow<Func&&, N&&>)
+		template <typename Func, typename Node>
+		static decltype(auto) do_visit(Func&& visitor, Node&& n) noexcept(visit_is_nothrow<Func&&, Node&&>)
 		{
-			static_assert(can_visit_any<Func&&, N&&>,
+			static_assert(can_visit_any<Func&&, Node&&>,
 						  "TOML node visitors must be invocable for at least one of the toml::node "
 						  "specializations:" TOML_SA_NODE_TYPE_LIST);
 
 			switch (n.type())
 			{
 				case node_type::table:
-					if constexpr (can_visit<Func&&, N&&, table>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<table>());
+					if constexpr (can_visit<Func&&, Node&&, table>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<table>());
 					break;
 
 				case node_type::array:
-					if constexpr (can_visit<Func&&, N&&, array>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<array>());
+					if constexpr (can_visit<Func&&, Node&&, array>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<array>());
 					break;
 
 				case node_type::string:
-					if constexpr (can_visit<Func&&, N&&, std::string>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<std::string>());
+					if constexpr (can_visit<Func&&, Node&&, std::string>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<std::string>());
 					break;
 
 				case node_type::integer:
-					if constexpr (can_visit<Func&&, N&&, int64_t>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<int64_t>());
+					if constexpr (can_visit<Func&&, Node&&, int64_t>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<int64_t>());
 					break;
 
 				case node_type::floating_point:
-					if constexpr (can_visit<Func&&, N&&, double>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<double>());
+					if constexpr (can_visit<Func&&, Node&&, double>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<double>());
 					break;
 
 				case node_type::boolean:
-					if constexpr (can_visit<Func&&, N&&, bool>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<bool>());
+					if constexpr (can_visit<Func&&, Node&&, bool>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<bool>());
 					break;
 
 				case node_type::date:
-					if constexpr (can_visit<Func&&, N&&, date>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<date>());
+					if constexpr (can_visit<Func&&, Node&&, date>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<date>());
 					break;
 
 				case node_type::time:
-					if constexpr (can_visit<Func&&, N&&, time>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<time>());
+					if constexpr (can_visit<Func&&, Node&&, time>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<time>());
 					break;
 
 				case node_type::date_time:
-					if constexpr (can_visit<Func&&, N&&, date_time>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<date_time>());
+					if constexpr (can_visit<Func&&, Node&&, date_time>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<date_time>());
 					break;
 
 				case node_type::none: TOML_UNREACHABLE;
 				default: TOML_UNREACHABLE;
 			}
 
-			if constexpr (can_visit_all<Func&&, N&&>)
-				TOML_UNREACHABLE;
-			else
+			if constexpr (!can_visit_all<Func&&, Node&&>)
 			{
 				// clang-format off
 
 				using return_type =
-					nonvoid<visit_return_type<Func&&, N&&, table>,
-					nonvoid<visit_return_type<Func&&, N&&, array>,
-					nonvoid<visit_return_type<Func&&, N&&, std::string>,
-					nonvoid<visit_return_type<Func&&, N&&, int64_t>,
-					nonvoid<visit_return_type<Func&&, N&&, double>,
-					nonvoid<visit_return_type<Func&&, N&&, bool>,
-					nonvoid<visit_return_type<Func&&, N&&, date>,
-					nonvoid<visit_return_type<Func&&, N&&, time>,
-							visit_return_type<Func&&, N&&, date_time>
+					nonvoid<visit_return_type<Func&&, Node&&, table>,
+					nonvoid<visit_return_type<Func&&, Node&&, array>,
+					nonvoid<visit_return_type<Func&&, Node&&, std::string>,
+					nonvoid<visit_return_type<Func&&, Node&&, int64_t>,
+					nonvoid<visit_return_type<Func&&, Node&&, double>,
+					nonvoid<visit_return_type<Func&&, Node&&, bool>,
+					nonvoid<visit_return_type<Func&&, Node&&, date>,
+					nonvoid<visit_return_type<Func&&, Node&&, time>,
+							visit_return_type<Func&&, Node&&, date_time>
 				>>>>>>>>;
 
 				// clang-format on
@@ -903,13 +899,17 @@ TOML_NAMESPACE_START
 		///			do_something_with_a_string(*n)); //n is a toml::value<std::string>
 		///		else if constexpr (toml::is_integer<decltype(n)>)
 		///			do_something_with_an_int(*n); //n is a toml::value<int64_t>
-		///		else
-		///			throw std::exception{ "Expected string or integer" };
 		/// });
 		/// \ecpp
 		///
-		/// \tparam	Func	A callable type invocable with one or more of the
-		/// 				toml++ node types.
+		/// Visitor functions need not be generic; specifying a concrete node type as the input argument type
+		/// effectively acts a 'filter', only invoking the visitor if the concrete type is compatible.
+		/// Thus the example above can be re-written as: \cpp
+		/// node.visit([](toml::value<std::string>& s) { do_something_with_a_string(*s)); });
+		/// node.visit([](toml::value<int64_t>& i)     { do_something_with_an_int(*i)); });
+		/// \ecpp
+		///
+		/// \tparam	Func	A callable type invocable with one or more of the toml++ node types.
 		///
 		/// \param 	visitor	The visitor object.
 		///
@@ -920,28 +920,28 @@ TOML_NAMESPACE_START
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) & noexcept(visit_is_nothrow<Func&&, node&>)
 		{
-			return do_visit(*this, static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), *this);
 		}
 
 		/// \brief	Invokes a visitor on the node based on the node's concrete type (rvalue overload).
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) && noexcept(visit_is_nothrow<Func&&, node&&>)
 		{
-			return do_visit(static_cast<node&&>(*this), static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), static_cast<node&&>(*this));
 		}
 
 		/// \brief	Invokes a visitor on the node based on the node's concrete type (const lvalue overload).
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) const& noexcept(visit_is_nothrow<Func&&, const node&>)
 		{
-			return do_visit(*this, static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), *this);
 		}
 
 		/// \brief	Invokes a visitor on the node based on the node's concrete type (const rvalue overload).
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) const&& noexcept(visit_is_nothrow<Func&&, const node&&>)
 		{
-			return do_visit(static_cast<const node&&>(*this), static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), static_cast<const node&&>(*this));
 		}
 
 		/// @}
diff --git a/include/toml++/impl/node.inl b/include/toml++/impl/node.inl
index 66375638..1a37c46d 100644
--- a/include/toml++/impl/node.inl
+++ b/include/toml++/impl/node.inl
@@ -102,16 +102,13 @@ TOML_IMPL_NAMESPACE_START
 		if ((!lhs != !rhs) || lhs->type() != rhs->type())
 			return false;
 
-		bool same;
-		lhs->visit(
-			[=, &same](auto& l) noexcept
+		return lhs->visit(
+			[=](auto& l) noexcept
 			{
 				using concrete_type = remove_cvref<decltype(l)>;
 
-				same = (l == *(rhs->as<concrete_type>()));
+				return l == *(rhs->as<concrete_type>());
 			});
-
-		return same;
 	}
 }
 TOML_IMPL_NAMESPACE_END;
diff --git a/include/toml++/impl/parse_result.h b/include/toml++/impl/parse_result.h
index 3b13bb4b..45c3f059 100644
--- a/include/toml++/impl/parse_result.h
+++ b/include/toml++/impl/parse_result.h
@@ -269,7 +269,7 @@ TOML_NAMESPACE_START
 
 		/// @}
 
-		/// \name Iterators
+		/// \name Iteration
 		/// @{
 
 		/// \brief A BidirectionalIterator for iterating over key-value pairs in a wrapped toml::table.
diff --git a/include/toml++/impl/preprocessor.h b/include/toml++/impl/preprocessor.h
index d761b5db..665aad71 100644
--- a/include/toml++/impl/preprocessor.h
+++ b/include/toml++/impl/preprocessor.h
@@ -1102,8 +1102,8 @@
 /// \def TOML_SMALL_FLOAT_TYPE
 /// \brief If your codebase has an additional 'small' float type (e.g. half-precision), this tells toml++ about it.
 /// \detail Not defined by default.
-/// \remark	If you're building for a platform that has a built-in half precision float (e.g. `_Float16`), you don't
-/// 		need to use this configuration option to make toml++ aware of it; the library comes with that built-in.
+/// \remark	If you're building for a platform that has `_Float16` and/or `__fp16`, you don't
+/// 		need to use this configuration option to make toml++ aware of them. The library comes with that built-in.
 
 
 #define TOML_SMALL_INT_TYPE
diff --git a/include/toml++/impl/table.h b/include/toml++/impl/table.h
index 590fdc8e..b5648385 100644
--- a/include/toml++/impl/table.h
+++ b/include/toml++/impl/table.h
@@ -221,6 +221,7 @@ TOML_NAMESPACE_START
 		/// \cond
 
 		using map_type			 = std::map<toml::key, impl::node_ptr, std::less<>>;
+		using map_pair			 = std::pair<const toml::key, impl::node_ptr>;
 		using map_iterator		 = typename map_type::iterator;
 		using const_map_iterator = typename map_type::const_iterator;
 		map_type map_;
@@ -784,7 +785,7 @@ TOML_NAMESPACE_START
 
 		/// @}
 
-		/// \name Iterators
+		/// \name Iteration
 		/// @{
 
 		/// \brief A BidirectionalIterator for iterating over key-value pairs in a toml::table.
@@ -835,6 +836,236 @@ TOML_NAMESPACE_START
 			return const_iterator{ map_.cend() };
 		}
 
+	  private:
+		/// \cond
+
+		template <typename T, typename Table>
+		using for_each_value_ref = impl::copy_cvref<impl::wrap_node<impl::remove_cvref<impl::unwrap_node<T>>>, Table>;
+
+		template <typename Func, typename Table, typename T>
+		static constexpr bool can_for_each = std::is_invocable_v<Func, const key&, for_each_value_ref<T, Table>> //
+										  || std::is_invocable_v<Func, for_each_value_ref<T, Table>>;
+
+		template <typename Func, typename Table, typename T>
+		static constexpr bool can_for_each_nothrow =
+			std::is_nothrow_invocable_v<Func, const key&, for_each_value_ref<T, Table>> //
+			|| std::is_nothrow_invocable_v<Func, for_each_value_ref<T, Table>>;
+
+		template <typename Func, typename Table>
+		static constexpr bool can_for_each_any = can_for_each<Func, Table, table>		//
+											  || can_for_each<Func, Table, array>		//
+											  || can_for_each<Func, Table, std::string> //
+											  || can_for_each<Func, Table, int64_t>		//
+											  || can_for_each<Func, Table, double>		//
+											  || can_for_each<Func, Table, bool>		//
+											  || can_for_each<Func, Table, date>		//
+											  || can_for_each<Func, Table, time>		//
+											  || can_for_each<Func, Table, date_time>;
+
+		template <typename Func, typename Table, typename T>
+		static constexpr bool for_each_is_nothrow_one = !can_for_each<Func, Table, T> //
+													 || can_for_each_nothrow<Func, Table, T>;
+
+		// clang-format off
+
+
+		  template <typename Func, typename Table>
+		  static constexpr bool for_each_is_nothrow = for_each_is_nothrow_one<Func, Table, table>		//
+												   && for_each_is_nothrow_one<Func, Table, array>		//
+												   && for_each_is_nothrow_one<Func, Table, std::string> //
+												   && for_each_is_nothrow_one<Func, Table, int64_t>		//
+												   && for_each_is_nothrow_one<Func, Table, double>		//
+												   && for_each_is_nothrow_one<Func, Table, bool>		//
+												   && for_each_is_nothrow_one<Func, Table, date>		//
+												   && for_each_is_nothrow_one<Func, Table, time>		//
+												   && for_each_is_nothrow_one<Func, Table, date_time>;
+
+		// clang-format on
+
+		template <typename Func, typename Table>
+		static void do_for_each(Func&& visitor, Table&& tbl) noexcept(for_each_is_nothrow<Func&&, Table&&>)
+		{
+			static_assert(can_for_each_any<Func&&, Table&&>,
+						  "TOML table for_each visitors must be invocable for at least one of the toml::node "
+						  "specializations:" TOML_SA_NODE_TYPE_LIST);
+
+			using kvp_type = impl::copy_cv<map_pair, std::remove_reference_t<Table>>;
+
+			for (kvp_type& kvp : tbl.map_)
+			{
+				using node_ref = impl::copy_cvref<toml::node, Table&&>;
+				static_assert(std::is_reference_v<node_ref>);
+
+				const auto keep_going =
+					static_cast<node_ref>(*kvp.second)
+						.visit(
+							[&](auto&& v) noexcept(for_each_is_nothrow_one<Func&&, Table&&, decltype(v)>)
+							{
+								using value_ref = for_each_value_ref<decltype(v), Table&&>;
+								static_assert(std::is_reference_v<value_ref>);
+
+								// func(key, val)
+								if constexpr (std::is_invocable_v<Func&&, const key&, value_ref>)
+								{
+									using return_type = decltype(static_cast<Func&&>(
+										visitor)(static_cast<const key&>(kvp.first), static_cast<value_ref>(v)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(static_cast<Func&&>(
+											visitor)(static_cast<const key&>(kvp.first), static_cast<value_ref>(v)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<const key&>(kvp.first),
+																	 static_cast<value_ref>(v));
+										return true;
+									}
+								}
+
+								// func(val)
+								else if constexpr (std::is_invocable_v<Func&&, value_ref>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(static_cast<value_ref>(v)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(static_cast<value_ref>(v)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<value_ref>(v));
+										return true;
+									}
+								}
+
+								// visitor not compatible with this particular type
+								else
+									return true;
+							});
+
+				if (!keep_going)
+					return;
+			}
+		}
+
+		/// \endcond
+
+	  public:
+		/// \brief	Invokes a visitor on each key-value pair in the table.
+		///
+		/// \tparam	Func	A callable type invocable with one of the following signatures:
+		///					<ul>
+		///					<li> `func(key, val)`
+		///					<li> `func(val)`
+		///					</ul>
+		///					Where:
+		///					<ul>
+		///					<li> `key` will recieve a const reference to a toml::key
+		///					<li> `val` will recieve the value as it's concrete type with cvref-qualifications matching the table
+		///					</ul>
+		///					Visitors returning `bool` (or something convertible to `bool`) will cause iteration to
+		///					stop if they return `false`.
+		///
+		/// \param 	visitor	The visitor object.
+		///
+		/// \returns A reference to the table.
+		///
+		/// \details \cpp
+		/// toml::table tbl{
+		///		{ "0",  0      },
+		/// 	{ "1",  1      },
+		/// 	{ "2",  2      },
+		/// 	{ "3",  3.0    },
+		/// 	{ "4",  "four" },
+		/// 	{ "5",  "five" },
+		/// 	{ "6",  6      }
+		/// };
+		///
+		/// // select only the integers using a strongly-typed visitor
+		/// tbl.for_each([](toml::value<int64_t>& val)
+		/// {
+		/// 	std::cout << val << ", ";
+		/// });
+		/// std::cout << "\n";
+		///
+		/// // select all the numeric values using a generic visitor + is_number<> metafunction
+		/// tbl.for_each([](auto&& val)
+		/// {
+		/// 	if constexpr (toml::is_number<decltype(val)>)
+		/// 		std::cout << val << ", ";
+		/// });
+		/// std::cout << "\n";
+		///
+		/// // select all the numeric values until we encounter something non-numeric
+		/// tbl.for_each([](auto&& val)
+		/// {
+		///		if constexpr (toml::is_number<decltype(val)>)
+		///		{
+		///			std::cout << val << ", ";
+		///			return true; // "keep going"
+		///		}
+		///		else
+		///			return false; // "stop!"
+		///
+		/// });
+		/// std::cout << "\n\n";
+		///
+		/// // visitors may also recieve the key
+		/// tbl.for_each([](const toml::key& key, auto&& val)
+		/// {
+		///		std::cout << key << ": " << val << "\n";
+		/// });
+		///
+		/// \ecpp
+		/// \out
+		/// 0, 1, 2, 6,
+		/// 0, 1, 2, 3.0, 6,
+		/// 0, 1, 2, 3.0,
+		///
+		/// 0: 0
+		/// 1: 1
+		/// 2: 2
+		/// 3: 3.0
+		/// 4: 'four'
+		/// 5: 'five'
+		/// 6: 6
+		/// \eout
+		///
+		/// \see node::visit()
+		template <typename Func>
+		table& for_each(Func&& visitor) & noexcept(for_each_is_nothrow<Func&&, table&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		/// \brief	Invokes a visitor on each key-value pair in the table (rvalue overload).
+		template <typename Func>
+		table&& for_each(Func&& visitor) && noexcept(for_each_is_nothrow<Func&&, table&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<table&&>(*this));
+			return static_cast<table&&>(*this);
+		}
+
+		/// \brief	Invokes a visitor on each key-value pair in the table (const lvalue overload).
+		template <typename Func>
+		const table& for_each(Func&& visitor) const& noexcept(for_each_is_nothrow<Func&&, const table&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		/// \brief	Invokes a visitor on each key-value pair in the table (const rvalue overload).
+		template <typename Func>
+		const table&& for_each(Func&& visitor) const&& noexcept(for_each_is_nothrow<Func&&, const table&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<const table&&>(*this));
+			return static_cast<const table&&>(*this);
+		}
+
 		/// @}
 
 		/// \name Size and Capacity
diff --git a/include/toml++/impl/version.h b/include/toml++/impl/version.h
index b4d9d73d..f6d630c7 100644
--- a/include/toml++/impl/version.h
+++ b/include/toml++/impl/version.h
@@ -5,8 +5,8 @@
 #pragma once
 
 #define TOML_LIB_MAJOR 3
-#define TOML_LIB_MINOR 0
-#define TOML_LIB_PATCH 1
+#define TOML_LIB_MINOR 1
+#define TOML_LIB_PATCH 0
 
 #define TOML_LANG_MAJOR 1
 #define TOML_LANG_MINOR 0
diff --git a/meson.build b/meson.build
index 4c511a38..d527d623 100644
--- a/meson.build
+++ b/meson.build
@@ -1,7 +1,7 @@
 project(
 	'tomlplusplus',
 	'cpp',
-	version: '3.0.1',
+	version: '3.1.0',
 	meson_version: '>=0.54.0',
 	license: 'MIT',
 	subproject_dir: 'external',
diff --git a/tests/conformance_burntsushi_valid.cpp b/tests/conformance_burntsushi_valid.cpp
index 7ac17eb3..8ed91b67 100644
--- a/tests/conformance_burntsushi_valid.cpp
+++ b/tests/conformance_burntsushi_valid.cpp
@@ -555,6 +555,12 @@ backslash = 'This string has a \\ backslash character.')"sv;
 	static constexpr auto string_with_pound	   = R"(pound = "We see no # comments here."
 poundcomment = "But there are # some comments here." # Did I # mess you up?)"sv;
 
+#if TOML_LANG_UNRELEASED
+
+	static constexpr auto string_escape_esc = R"(esc = "\e There is no escape! \e")"sv;
+
+#endif // TOML_LANG_UNRELEASED
+
 #if UNICODE_LITERALS_OK
 
 	static constexpr auto string_escape_tricky	 = R"(end_esc = "String does not end here\" but ends here\\"
@@ -2287,6 +2293,20 @@ in it.)"sv },
 							   REQUIRE(tbl == expected);
 						   });
 
+#if TOML_LANG_UNRELEASED
+
+	parsing_should_succeed(FILE_LINE_ARGS,
+						   string_escape_esc,
+						   [](toml::table&& tbl) // string-escape-esc
+						   {
+							   const auto expected = toml::table{
+								   { R"(esc)"sv, "\x1B There is no escape! \x1B"sv },
+							   };
+							   REQUIRE(tbl == expected);
+						   });
+
+#endif // TOML_LANG_UNRELEASED
+
 #if UNICODE_LITERALS_OK
 
 	parsing_should_succeed(FILE_LINE_ARGS,
diff --git a/tests/for_each.cpp b/tests/for_each.cpp
new file mode 100644
index 00000000..c69ad1da
--- /dev/null
+++ b/tests/for_each.cpp
@@ -0,0 +1,372 @@
+// This file is a part of toml++ and is subject to the the terms of the MIT license.
+// Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
+// See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
+// SPDX-License-Identifier: MIT
+
+#include "tests.h"
+TOML_DISABLE_SPAM_WARNINGS;
+
+TEST_CASE("array::for_each")
+{
+	toml::array arr{ 0, 1, 2, 3.0, "four", "five", 6 };
+
+	// check lvalue propagates correctly
+	static_cast<array&>(arr).for_each(
+		[](auto&& elem, size_t) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<array&>(arr).for_each(
+		[](size_t, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<array&>(arr).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check rvalue propagates correctly
+	static_cast<array&&>(arr).for_each(
+		[](auto&& elem, size_t) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<array&&>(arr).for_each(
+		[](size_t, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<array&&>(arr).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check const lvalue propagates correctly
+	static_cast<const array&>(arr).for_each(
+		[](auto&& elem, size_t) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<const array&>(arr).for_each(
+		[](size_t, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<const array&>(arr).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check const rvalue propagates correctly
+	static_cast<const array&&>(arr).for_each(
+		[](auto&& elem, size_t) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<const array&&>(arr).for_each(
+		[](size_t, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<const array&&>(arr).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check noexcept - func(elem, i)
+	{
+		static constexpr auto throwing_visitor	   = [](auto&&, size_t) noexcept(false) {};
+		static constexpr auto non_throwing_visitor = [](auto&&, size_t) noexcept(true) {};
+		static_assert(!noexcept(static_cast<array&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<array&&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const array&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const array&&>(arr).for_each(throwing_visitor)));
+		static_assert(noexcept(static_cast<array&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<array&&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const array&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const array&&>(arr).for_each(non_throwing_visitor)));
+	}
+
+	// check noexcept - func(i, elem)
+	{
+		static constexpr auto throwing_visitor	   = [](size_t, auto&&) noexcept(false) {};
+		static constexpr auto non_throwing_visitor = [](size_t, auto&&) noexcept(true) {};
+		static_assert(!noexcept(static_cast<array&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<array&&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const array&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const array&&>(arr).for_each(throwing_visitor)));
+		static_assert(noexcept(static_cast<array&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<array&&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const array&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const array&&>(arr).for_each(non_throwing_visitor)));
+	}
+
+	// check noexcept - func(elem)
+	{
+		static constexpr auto throwing_visitor	   = [](auto&&) noexcept(false) {};
+		static constexpr auto non_throwing_visitor = [](auto&&) noexcept(true) {};
+		static_assert(!noexcept(static_cast<array&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<array&&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const array&>(arr).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const array&&>(arr).for_each(throwing_visitor)));
+		static_assert(noexcept(static_cast<array&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<array&&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const array&>(arr).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const array&&>(arr).for_each(non_throwing_visitor)));
+	}
+
+	// check that the iteration actually does what it says on the box
+	{
+		toml::array arr2;
+		arr.for_each([&](const auto& val) { arr2.push_back(val); });
+		CHECK(arr == arr2);
+	}
+
+	// check that visitation works for a specific type
+	{
+		toml::array arr2;
+		arr.for_each([&](const toml::value<int64_t>& val) { arr2.push_back(val); });
+		CHECK(arr2 == toml::array{ 0, 1, 2, 6 });
+	}
+
+	// check that early-stopping works
+	{
+		toml::array arr2;
+		arr.for_each(
+			[&](const auto& val)
+			{
+				if constexpr (!toml::is_number<decltype(val)>)
+					return false;
+				else
+				{
+					arr2.push_back(val);
+					return true;
+				}
+			});
+		CHECK(arr2 == toml::array{ 0, 1, 2, 3.0 });
+	}
+}
+
+TEST_CASE("table::for_each")
+{
+	table tbl{ { "zero", 0 },	   //
+			   { "one", 1 },	   //
+			   { "two", 2 },	   //
+			   { "three", 3.0 },   //
+			   { "four", "four" }, //
+			   { "five", "five" }, //
+			   { "six", 6 } };
+
+	// check lvalue propagates correctly
+	static_cast<table&>(tbl).for_each(
+		[](const toml::key&, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<table&>(tbl).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check rvalue propagates correctly
+	static_cast<table&&>(tbl).for_each(
+		[](const toml::key&, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<table&&>(tbl).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(!std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check const lvalue propagates correctly
+	static_cast<const table&>(tbl).for_each(
+		[](const toml::key&, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<const table&>(tbl).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_lvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check const rvalue propagates correctly
+	static_cast<const table&&>(tbl).for_each(
+		[](const toml::key&, auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+	static_cast<const table&&>(tbl).for_each(
+		[](auto&& elem) noexcept
+		{
+			using elem_ref_type = decltype(elem);
+			static_assert(std::is_rvalue_reference_v<elem_ref_type>);
+
+			using elem_type = std::remove_reference_t<elem_ref_type>;
+			static_assert(std::is_const_v<elem_type>);
+			static_assert(!std::is_volatile_v<elem_type>);
+		});
+
+	// check noexcept - func(key, value)
+	{
+		static constexpr auto throwing_visitor	   = [](const toml::key&, auto&&) noexcept(false) {};
+		static constexpr auto non_throwing_visitor = [](const toml::key&, auto&&) noexcept(true) {};
+		static_assert(!noexcept(static_cast<table&>(tbl).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<table&&>(tbl).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const table&>(tbl).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const table&&>(tbl).for_each(throwing_visitor)));
+		static_assert(noexcept(static_cast<table&>(tbl).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<table&&>(tbl).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const table&>(tbl).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const table&&>(tbl).for_each(non_throwing_visitor)));
+	}
+
+	// check noexcept - func(value)
+	{
+		static constexpr auto throwing_visitor	   = [](auto&&) noexcept(false) {};
+		static constexpr auto non_throwing_visitor = [](auto&&) noexcept(true) {};
+		static_assert(!noexcept(static_cast<table&>(tbl).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<table&&>(tbl).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const table&>(tbl).for_each(throwing_visitor)));
+		static_assert(!noexcept(static_cast<const table&&>(tbl).for_each(throwing_visitor)));
+		static_assert(noexcept(static_cast<table&>(tbl).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<table&&>(tbl).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const table&>(tbl).for_each(non_throwing_visitor)));
+		static_assert(noexcept(static_cast<const table&&>(tbl).for_each(non_throwing_visitor)));
+	}
+
+	// check that the iteration actually does what it says on the box
+	{
+		toml::table tbl2;
+		tbl.for_each([&](auto&& key, auto&& val) { tbl2.insert_or_assign(key, val); });
+		CHECK(tbl == tbl2);
+	}
+
+	// check that visitation works for a specific type
+	{
+		toml::table tbl2;
+		tbl.for_each([&](auto&& key, const toml::value<int64_t>& val) { tbl2.insert_or_assign(key, val); });
+		CHECK(tbl2
+			  == table{ { "zero", 0 }, //
+						{ "one", 1 },  //
+						{ "two", 2 },  //
+						{ "six", 6 } });
+	}
+
+	// check that early-stopping works
+	{
+		toml::table tbl2;
+		size_t added{};
+		tbl.for_each(
+			[&](auto&& key, const auto& val)
+			{
+				tbl2.insert_or_assign(key, val);
+				added++;
+				return added < 3u;
+			});
+		CHECK(tbl2.size() == 3u);
+	}
+}
diff --git a/tests/meson.build b/tests/meson.build
index ddc5a8af..a464089a 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -5,25 +5,27 @@ test_sources = [
 	'conformance_iarna_invalid.cpp',
 	'conformance_iarna_valid.cpp',
 	'formatters.cpp',
+	'for_each.cpp',
 	'impl_toml.cpp',
-	'tests.cpp',
-	'parsing_floats.cpp',
+	'main.cpp',
+	'manipulating_arrays.cpp',
+	'manipulating_parse_result.cpp',
+	'manipulating_tables.cpp',
+	'manipulating_values.cpp',
 	'parsing_arrays.cpp',
 	'parsing_booleans.cpp',
 	'parsing_comments.cpp',
 	'parsing_dates_and_times.cpp',
+	'parsing_floats.cpp',
 	'parsing_integers.cpp',
 	'parsing_key_value_pairs.cpp',
 	'parsing_spec_example.cpp',
 	'parsing_strings.cpp',
 	'parsing_tables.cpp',
-	'main.cpp',
-	'manipulating_arrays.cpp',
-	'manipulating_tables.cpp',
-	'manipulating_values.cpp',
-	'visit.cpp',
+	'tests.cpp',
 	'user_feedback.cpp',
 	'using_iterators.cpp',
+	'visit.cpp',
 	'windows_compat.cpp'
 ]
 
diff --git a/tests/vs/test_debug_x64.vcxproj b/tests/vs/test_debug_x64.vcxproj
index 2b96d60a..2cba6e08 100644
--- a/tests/vs/test_debug_x64.vcxproj
+++ b/tests/vs/test_debug_x64.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x64_cpplatest.vcxproj b/tests/vs/test_debug_x64_cpplatest.vcxproj
index 9f6dc836..300d6e71 100644
--- a/tests/vs/test_debug_x64_cpplatest.vcxproj
+++ b/tests/vs/test_debug_x64_cpplatest.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x64_cpplatest_noexcept.vcxproj b/tests/vs/test_debug_x64_cpplatest_noexcept.vcxproj
index be7ad645..aa14ce28 100644
--- a/tests/vs/test_debug_x64_cpplatest_noexcept.vcxproj
+++ b/tests/vs/test_debug_x64_cpplatest_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x64_cpplatest_noexcept_unrel.vcxproj b/tests/vs/test_debug_x64_cpplatest_noexcept_unrel.vcxproj
index 1d946748..0df0202a 100644
--- a/tests/vs/test_debug_x64_cpplatest_noexcept_unrel.vcxproj
+++ b/tests/vs/test_debug_x64_cpplatest_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x64_cpplatest_unrel.vcxproj b/tests/vs/test_debug_x64_cpplatest_unrel.vcxproj
index aa8f930f..92ded473 100644
--- a/tests/vs/test_debug_x64_cpplatest_unrel.vcxproj
+++ b/tests/vs/test_debug_x64_cpplatest_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x64_noexcept.vcxproj b/tests/vs/test_debug_x64_noexcept.vcxproj
index e4e9dd87..1a729fc8 100644
--- a/tests/vs/test_debug_x64_noexcept.vcxproj
+++ b/tests/vs/test_debug_x64_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x64_noexcept_unrel.vcxproj b/tests/vs/test_debug_x64_noexcept_unrel.vcxproj
index a7399f6b..732bcac9 100644
--- a/tests/vs/test_debug_x64_noexcept_unrel.vcxproj
+++ b/tests/vs/test_debug_x64_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x64_unrel.vcxproj b/tests/vs/test_debug_x64_unrel.vcxproj
index 20b3f8be..c707504f 100644
--- a/tests/vs/test_debug_x64_unrel.vcxproj
+++ b/tests/vs/test_debug_x64_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86.vcxproj b/tests/vs/test_debug_x86.vcxproj
index 634ec22e..c825ceb4 100644
--- a/tests/vs/test_debug_x86.vcxproj
+++ b/tests/vs/test_debug_x86.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86_cpplatest.vcxproj b/tests/vs/test_debug_x86_cpplatest.vcxproj
index 77011478..34a6d9c2 100644
--- a/tests/vs/test_debug_x86_cpplatest.vcxproj
+++ b/tests/vs/test_debug_x86_cpplatest.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86_cpplatest_noexcept.vcxproj b/tests/vs/test_debug_x86_cpplatest_noexcept.vcxproj
index ae4ec0ae..9e0f3f5a 100644
--- a/tests/vs/test_debug_x86_cpplatest_noexcept.vcxproj
+++ b/tests/vs/test_debug_x86_cpplatest_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86_cpplatest_noexcept_unrel.vcxproj b/tests/vs/test_debug_x86_cpplatest_noexcept_unrel.vcxproj
index d16089c7..2099ef73 100644
--- a/tests/vs/test_debug_x86_cpplatest_noexcept_unrel.vcxproj
+++ b/tests/vs/test_debug_x86_cpplatest_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86_cpplatest_unrel.vcxproj b/tests/vs/test_debug_x86_cpplatest_unrel.vcxproj
index 34fc310c..985609fb 100644
--- a/tests/vs/test_debug_x86_cpplatest_unrel.vcxproj
+++ b/tests/vs/test_debug_x86_cpplatest_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86_noexcept.vcxproj b/tests/vs/test_debug_x86_noexcept.vcxproj
index 192ae510..1d203216 100644
--- a/tests/vs/test_debug_x86_noexcept.vcxproj
+++ b/tests/vs/test_debug_x86_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86_noexcept_unrel.vcxproj b/tests/vs/test_debug_x86_noexcept_unrel.vcxproj
index 57598fe7..5dcc3fd3 100644
--- a/tests/vs/test_debug_x86_noexcept_unrel.vcxproj
+++ b/tests/vs/test_debug_x86_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_debug_x86_unrel.vcxproj b/tests/vs/test_debug_x86_unrel.vcxproj
index a808b560..2a6abc5e 100644
--- a/tests/vs/test_debug_x86_unrel.vcxproj
+++ b/tests/vs/test_debug_x86_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64.vcxproj b/tests/vs/test_release_x64.vcxproj
index ee66af0a..c14ace39 100644
--- a/tests/vs/test_release_x64.vcxproj
+++ b/tests/vs/test_release_x64.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64_cpplatest.vcxproj b/tests/vs/test_release_x64_cpplatest.vcxproj
index b0a4971b..8793957c 100644
--- a/tests/vs/test_release_x64_cpplatest.vcxproj
+++ b/tests/vs/test_release_x64_cpplatest.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64_cpplatest_noexcept.vcxproj b/tests/vs/test_release_x64_cpplatest_noexcept.vcxproj
index 327e53ec..b4ab9d8f 100644
--- a/tests/vs/test_release_x64_cpplatest_noexcept.vcxproj
+++ b/tests/vs/test_release_x64_cpplatest_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64_cpplatest_noexcept_unrel.vcxproj b/tests/vs/test_release_x64_cpplatest_noexcept_unrel.vcxproj
index 44ca1db0..af6f2098 100644
--- a/tests/vs/test_release_x64_cpplatest_noexcept_unrel.vcxproj
+++ b/tests/vs/test_release_x64_cpplatest_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64_cpplatest_unrel.vcxproj b/tests/vs/test_release_x64_cpplatest_unrel.vcxproj
index 80e65754..6f8619a2 100644
--- a/tests/vs/test_release_x64_cpplatest_unrel.vcxproj
+++ b/tests/vs/test_release_x64_cpplatest_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64_noexcept.vcxproj b/tests/vs/test_release_x64_noexcept.vcxproj
index 1a1d4c19..07d44a56 100644
--- a/tests/vs/test_release_x64_noexcept.vcxproj
+++ b/tests/vs/test_release_x64_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64_noexcept_unrel.vcxproj b/tests/vs/test_release_x64_noexcept_unrel.vcxproj
index b9f5c917..6ddae978 100644
--- a/tests/vs/test_release_x64_noexcept_unrel.vcxproj
+++ b/tests/vs/test_release_x64_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x64_unrel.vcxproj b/tests/vs/test_release_x64_unrel.vcxproj
index 64507f37..c3c6f6a0 100644
--- a/tests/vs/test_release_x64_unrel.vcxproj
+++ b/tests/vs/test_release_x64_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86.vcxproj b/tests/vs/test_release_x86.vcxproj
index 20da1db4..4f7747f5 100644
--- a/tests/vs/test_release_x86.vcxproj
+++ b/tests/vs/test_release_x86.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86_cpplatest.vcxproj b/tests/vs/test_release_x86_cpplatest.vcxproj
index 765d41b1..0a6c7a2e 100644
--- a/tests/vs/test_release_x86_cpplatest.vcxproj
+++ b/tests/vs/test_release_x86_cpplatest.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86_cpplatest_noexcept.vcxproj b/tests/vs/test_release_x86_cpplatest_noexcept.vcxproj
index d3b27ea3..eb3c04e5 100644
--- a/tests/vs/test_release_x86_cpplatest_noexcept.vcxproj
+++ b/tests/vs/test_release_x86_cpplatest_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86_cpplatest_noexcept_unrel.vcxproj b/tests/vs/test_release_x86_cpplatest_noexcept_unrel.vcxproj
index 55d7d348..54c7b290 100644
--- a/tests/vs/test_release_x86_cpplatest_noexcept_unrel.vcxproj
+++ b/tests/vs/test_release_x86_cpplatest_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86_cpplatest_unrel.vcxproj b/tests/vs/test_release_x86_cpplatest_unrel.vcxproj
index 4399f974..817936ec 100644
--- a/tests/vs/test_release_x86_cpplatest_unrel.vcxproj
+++ b/tests/vs/test_release_x86_cpplatest_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86_noexcept.vcxproj b/tests/vs/test_release_x86_noexcept.vcxproj
index 4c9661d0..4985df8e 100644
--- a/tests/vs/test_release_x86_noexcept.vcxproj
+++ b/tests/vs/test_release_x86_noexcept.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86_noexcept_unrel.vcxproj b/tests/vs/test_release_x86_noexcept_unrel.vcxproj
index ac49efee..cd2a5827 100644
--- a/tests/vs/test_release_x86_noexcept_unrel.vcxproj
+++ b/tests/vs/test_release_x86_noexcept_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/tests/vs/test_release_x86_unrel.vcxproj b/tests/vs/test_release_x86_unrel.vcxproj
index 7b074520..e594c3fc 100644
--- a/tests/vs/test_release_x86_unrel.vcxproj
+++ b/tests/vs/test_release_x86_unrel.vcxproj
@@ -78,6 +78,7 @@
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>
diff --git a/toml.hpp b/toml.hpp
index 409a1cae..234ef235 100644
--- a/toml.hpp
+++ b/toml.hpp
@@ -1,6 +1,6 @@
 //----------------------------------------------------------------------------------------------------------------------
 //
-// toml++ v3.0.1
+// toml++ v3.1.0
 // https://github.com/marzer/tomlplusplus
 // SPDX-License-Identifier: MIT
 //
@@ -846,8 +846,8 @@
 //********  impl/version.h  ********************************************************************************************
 
 #define TOML_LIB_MAJOR 3
-#define TOML_LIB_MINOR 0
-#define TOML_LIB_PATCH 1
+#define TOML_LIB_MINOR 1
+#define TOML_LIB_PATCH 0
 
 #define TOML_LANG_MAJOR 1
 #define TOML_LANG_MINOR 0
@@ -1892,6 +1892,10 @@ TOML_IMPL_NAMESPACE_START
 	};
 	template <typename T>
 	inline constexpr node_type node_type_of = node_type_getter<unwrap_node<remove_cvref<T>>>::value;
+
+	template <typename T, typename ConvertFrom>
+	inline constexpr bool is_constructible_or_convertible = std::is_constructible_v<T, ConvertFrom> //
+														 || std::is_convertible_v<ConvertFrom, T>;
 }
 TOML_IMPL_NAMESPACE_END;
 
@@ -1951,8 +1955,8 @@ TOML_NAMESPACE_START
 	inline constexpr bool is_value = is_string<T> || is_number<T> || is_boolean<T> || is_chronological<T>;
 
 	template <typename T>
-	inline constexpr bool is_node =
-		std::is_same_v<toml::node, impl::remove_cvref<T>> || std::is_base_of_v<toml::node, impl::remove_cvref<T>>;
+	inline constexpr bool is_node = std::is_same_v<toml::node, impl::remove_cvref<T>> //
+								 || std::is_base_of_v<toml::node, impl::remove_cvref<T>>;
 
 	template <typename T>
 	inline constexpr bool is_node_view = impl::is_one_of<impl::remove_cvref<T>, node_view<node>, node_view<const node>>;
@@ -2990,145 +2994,141 @@ TOML_NAMESPACE_START
 
 	  private:
 
+		template <typename Func, typename Node, typename T>
+		static constexpr bool can_visit = std::is_invocable_v<Func, ref_cast_type<T, Node>>;
+
+		template <typename Func, typename Node, typename T>
+		static constexpr bool can_visit_nothrow = std::is_nothrow_invocable_v<Func, ref_cast_type<T, Node>>;
+
+		template <typename Func, typename Node>
+		static constexpr bool can_visit_any = can_visit<Func, Node, table>		 //
+										   || can_visit<Func, Node, array>		 //
+										   || can_visit<Func, Node, std::string> //
+										   || can_visit<Func, Node, int64_t>	 //
+										   || can_visit<Func, Node, double>		 //
+										   || can_visit<Func, Node, bool>		 //
+										   || can_visit<Func, Node, date>		 //
+										   || can_visit<Func, Node, time>		 //
+										   || can_visit<Func, Node, date_time>;
+
 		// clang-format off
 
-		template <typename Func, typename N, typename T>
-		static constexpr bool can_visit = std::is_invocable_v<Func, ref_cast_type<T, N>>;
-
-		template <typename Func, typename N>
-		static constexpr bool can_visit_any =
-			can_visit<Func, N, table>
-			|| can_visit<Func, N, array>
-			|| can_visit<Func, N, std::string>
-			|| can_visit<Func, N, int64_t>
-			|| can_visit<Func, N, double>
-			|| can_visit<Func, N, bool>
-			|| can_visit<Func, N, date>
-			|| can_visit<Func, N, time>
-			|| can_visit<Func, N, date_time>;
-
-		template <typename Func, typename N>
-		static constexpr bool can_visit_all =
-			can_visit<Func, N, table>
-			&& can_visit<Func, N, array>
-			&& can_visit<Func, N, std::string>
-			&& can_visit<Func, N, int64_t>
-			&& can_visit<Func, N, double>
-			&& can_visit<Func, N, bool>
-			&& can_visit<Func, N, date>
-			&& can_visit<Func, N, time>
-			&& can_visit<Func, N, date_time>;
-
-		template <typename Func, typename N, typename T>
-		static constexpr bool visit_is_nothrow_one =
-			!can_visit<Func, N, T>
-			|| std::is_nothrow_invocable_v<Func, ref_cast_type<T, N>>;
-
-		template <typename Func, typename N>
-		static constexpr bool visit_is_nothrow =
-			visit_is_nothrow_one<Func, N, table>
-			&& visit_is_nothrow_one<Func, N, array>
-			&& visit_is_nothrow_one<Func, N, std::string>
-			&& visit_is_nothrow_one<Func, N, int64_t>
-			&& visit_is_nothrow_one<Func, N, double>
-			&& visit_is_nothrow_one<Func, N, bool>
-			&& visit_is_nothrow_one<Func, N, date>
-			&& visit_is_nothrow_one<Func, N, time>
-			&& visit_is_nothrow_one<Func, N, date_time>;
+		template <typename Func, typename Node>
+		static constexpr bool can_visit_all = can_visit<Func, Node, table>		 //
+										   && can_visit<Func, Node, array>		 //
+										   && can_visit<Func, Node, std::string> //
+										   && can_visit<Func, Node, int64_t>	 //
+										   && can_visit<Func, Node, double>		 //
+										   && can_visit<Func, Node, bool>		 //
+										   && can_visit<Func, Node, date>		 //
+										   && can_visit<Func, Node, time>		 //
+										   && can_visit<Func, Node, date_time>;
+
+		template <typename Func, typename Node, typename T>
+		static constexpr bool visit_is_nothrow_one = !can_visit<Func, Node, T> || can_visit_nothrow<Func, Node, T>;
+
+		template <typename Func, typename Node>
+		static constexpr bool visit_is_nothrow = visit_is_nothrow_one<Func, Node, table>	   //
+											  && visit_is_nothrow_one<Func, Node, array>	   //
+											  && visit_is_nothrow_one<Func, Node, std::string> //
+											  && visit_is_nothrow_one<Func, Node, int64_t>	   //
+											  && visit_is_nothrow_one<Func, Node, double>	   //
+											  && visit_is_nothrow_one<Func, Node, bool>		   //
+											  && visit_is_nothrow_one<Func, Node, date>		   //
+											  && visit_is_nothrow_one<Func, Node, time>		   //
+											  && visit_is_nothrow_one<Func, Node, date_time>;
 
 		// clang-format on
 
-		template <typename Func, typename N, typename T, bool = can_visit<Func, N, T>>
+		template <typename Func, typename Node, typename T, bool = can_visit<Func, Node, T>>
 		struct visit_return_type_
 		{
-			using type = decltype(std::declval<Func>()(std::declval<ref_cast_type<T, N>>()));
+			using type = decltype(std::declval<Func>()(std::declval<ref_cast_type<T, Node>>()));
 		};
-		template <typename Func, typename N, typename T>
-		struct visit_return_type_<Func, N, T, false>
+		template <typename Func, typename Node, typename T>
+		struct visit_return_type_<Func, Node, T, false>
 		{
 			using type = void;
 		};
 
-		template <typename Func, typename N, typename T>
-		using visit_return_type = typename visit_return_type_<Func, N, T>::type;
+		template <typename Func, typename Node, typename T>
+		using visit_return_type = typename visit_return_type_<Func, Node, T>::type;
 
 		template <typename A, typename B>
 		using nonvoid = std::conditional_t<std::is_void_v<A>, B, A>;
 
-		template <typename N, typename Func>
-		static decltype(auto) do_visit(N&& n, Func&& visitor) noexcept(visit_is_nothrow<Func&&, N&&>)
+		template <typename Func, typename Node>
+		static decltype(auto) do_visit(Func&& visitor, Node&& n) noexcept(visit_is_nothrow<Func&&, Node&&>)
 		{
-			static_assert(can_visit_any<Func&&, N&&>,
+			static_assert(can_visit_any<Func&&, Node&&>,
 						  "TOML node visitors must be invocable for at least one of the toml::node "
 						  "specializations:" TOML_SA_NODE_TYPE_LIST);
 
 			switch (n.type())
 			{
 				case node_type::table:
-					if constexpr (can_visit<Func&&, N&&, table>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<table>());
+					if constexpr (can_visit<Func&&, Node&&, table>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<table>());
 					break;
 
 				case node_type::array:
-					if constexpr (can_visit<Func&&, N&&, array>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<array>());
+					if constexpr (can_visit<Func&&, Node&&, array>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<array>());
 					break;
 
 				case node_type::string:
-					if constexpr (can_visit<Func&&, N&&, std::string>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<std::string>());
+					if constexpr (can_visit<Func&&, Node&&, std::string>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<std::string>());
 					break;
 
 				case node_type::integer:
-					if constexpr (can_visit<Func&&, N&&, int64_t>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<int64_t>());
+					if constexpr (can_visit<Func&&, Node&&, int64_t>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<int64_t>());
 					break;
 
 				case node_type::floating_point:
-					if constexpr (can_visit<Func&&, N&&, double>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<double>());
+					if constexpr (can_visit<Func&&, Node&&, double>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<double>());
 					break;
 
 				case node_type::boolean:
-					if constexpr (can_visit<Func&&, N&&, bool>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<bool>());
+					if constexpr (can_visit<Func&&, Node&&, bool>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<bool>());
 					break;
 
 				case node_type::date:
-					if constexpr (can_visit<Func&&, N&&, date>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<date>());
+					if constexpr (can_visit<Func&&, Node&&, date>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<date>());
 					break;
 
 				case node_type::time:
-					if constexpr (can_visit<Func&&, N&&, time>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<time>());
+					if constexpr (can_visit<Func&&, Node&&, time>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<time>());
 					break;
 
 				case node_type::date_time:
-					if constexpr (can_visit<Func&&, N&&, date_time>)
-						return static_cast<Func&&>(visitor)(static_cast<N&&>(n).template ref_cast<date_time>());
+					if constexpr (can_visit<Func&&, Node&&, date_time>)
+						return static_cast<Func&&>(visitor)(static_cast<Node&&>(n).template ref_cast<date_time>());
 					break;
 
 				case node_type::none: TOML_UNREACHABLE;
 				default: TOML_UNREACHABLE;
 			}
 
-			if constexpr (can_visit_all<Func&&, N&&>)
-				TOML_UNREACHABLE;
-			else
+			if constexpr (!can_visit_all<Func&&, Node&&>)
 			{
 				// clang-format off
 
 				using return_type =
-					nonvoid<visit_return_type<Func&&, N&&, table>,
-					nonvoid<visit_return_type<Func&&, N&&, array>,
-					nonvoid<visit_return_type<Func&&, N&&, std::string>,
-					nonvoid<visit_return_type<Func&&, N&&, int64_t>,
-					nonvoid<visit_return_type<Func&&, N&&, double>,
-					nonvoid<visit_return_type<Func&&, N&&, bool>,
-					nonvoid<visit_return_type<Func&&, N&&, date>,
-					nonvoid<visit_return_type<Func&&, N&&, time>,
-							visit_return_type<Func&&, N&&, date_time>
+					nonvoid<visit_return_type<Func&&, Node&&, table>,
+					nonvoid<visit_return_type<Func&&, Node&&, array>,
+					nonvoid<visit_return_type<Func&&, Node&&, std::string>,
+					nonvoid<visit_return_type<Func&&, Node&&, int64_t>,
+					nonvoid<visit_return_type<Func&&, Node&&, double>,
+					nonvoid<visit_return_type<Func&&, Node&&, bool>,
+					nonvoid<visit_return_type<Func&&, Node&&, date>,
+					nonvoid<visit_return_type<Func&&, Node&&, time>,
+							visit_return_type<Func&&, Node&&, date_time>
 				>>>>>>>>;
 
 				// clang-format on
@@ -3147,25 +3147,25 @@ TOML_NAMESPACE_START
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) & noexcept(visit_is_nothrow<Func&&, node&>)
 		{
-			return do_visit(*this, static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), *this);
 		}
 
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) && noexcept(visit_is_nothrow<Func&&, node&&>)
 		{
-			return do_visit(static_cast<node&&>(*this), static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), static_cast<node&&>(*this));
 		}
 
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) const& noexcept(visit_is_nothrow<Func&&, const node&>)
 		{
-			return do_visit(*this, static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), *this);
 		}
 
 		template <typename Func>
 		decltype(auto) visit(Func&& visitor) const&& noexcept(visit_is_nothrow<Func&&, const node&&>)
 		{
-			return do_visit(static_cast<const node&&>(*this), static_cast<Func&&>(visitor));
+			return do_visit(static_cast<Func&&>(visitor), static_cast<const node&&>(*this));
 		}
 
 		TOML_NODISCARD
@@ -5564,6 +5564,166 @@ TOML_NAMESPACE_START
 			return const_iterator{ elems_.cend() };
 		}
 
+	  private:
+
+		template <typename T, typename Array>
+		using for_each_elem_ref = impl::copy_cvref<impl::wrap_node<impl::remove_cvref<impl::unwrap_node<T>>>, Array>;
+
+		template <typename Func, typename Array, typename T>
+		static constexpr bool can_for_each = std::is_invocable_v<Func, for_each_elem_ref<T, Array>, size_t> //
+										  || std::is_invocable_v<Func, size_t, for_each_elem_ref<T, Array>> //
+										  || std::is_invocable_v<Func, for_each_elem_ref<T, Array>>;
+
+		template <typename Func, typename Array, typename T>
+		static constexpr bool can_for_each_nothrow =
+			std::is_nothrow_invocable_v<Func, for_each_elem_ref<T, Array>, size_t>	  //
+			|| std::is_nothrow_invocable_v<Func, size_t, for_each_elem_ref<T, Array>> //
+			|| std::is_nothrow_invocable_v<Func, for_each_elem_ref<T, Array>>;
+
+		template <typename Func, typename Array>
+		static constexpr bool can_for_each_any = can_for_each<Func, Array, table>		//
+											  || can_for_each<Func, Array, array>		//
+											  || can_for_each<Func, Array, std::string> //
+											  || can_for_each<Func, Array, int64_t>		//
+											  || can_for_each<Func, Array, double>		//
+											  || can_for_each<Func, Array, bool>		//
+											  || can_for_each<Func, Array, date>		//
+											  || can_for_each<Func, Array, time>		//
+											  || can_for_each<Func, Array, date_time>;
+
+		template <typename Func, typename Array, typename T>
+		static constexpr bool for_each_is_nothrow_one = !can_for_each<Func, Array, T> //
+													 || can_for_each_nothrow<Func, Array, T>;
+
+		// clang-format off
+
+		template <typename Func, typename Array>
+		static constexpr bool for_each_is_nothrow = for_each_is_nothrow_one<Func, Array, table>		  //
+												 && for_each_is_nothrow_one<Func, Array, array>		  //
+												 && for_each_is_nothrow_one<Func, Array, std::string> //
+												 && for_each_is_nothrow_one<Func, Array, int64_t>	  //
+												 && for_each_is_nothrow_one<Func, Array, double>	  //
+												 && for_each_is_nothrow_one<Func, Array, bool>		  //
+												 && for_each_is_nothrow_one<Func, Array, date>		  //
+												 && for_each_is_nothrow_one<Func, Array, time>		  //
+												 && for_each_is_nothrow_one<Func, Array, date_time>;
+
+		// clang-format on
+
+		template <typename Func, typename Array>
+		static void do_for_each(Func&& visitor, Array&& arr) noexcept(for_each_is_nothrow<Func&&, Array&&>)
+		{
+			static_assert(can_for_each_any<Func&&, Array&&>,
+						  "TOML array for_each visitors must be invocable for at least one of the toml::node "
+						  "specializations:" TOML_SA_NODE_TYPE_LIST);
+
+			for (size_t i = 0; i < arr.size(); i++)
+			{
+				using node_ref = impl::copy_cvref<toml::node, Array&&>;
+				static_assert(std::is_reference_v<node_ref>);
+
+				const auto keep_going =
+					static_cast<node_ref>(static_cast<Array&&>(arr)[i])
+						.visit(
+							[&](auto&& elem) noexcept(for_each_is_nothrow_one<Func&&, Array&&, decltype(elem)>)
+							{
+								using elem_ref = for_each_elem_ref<decltype(elem), Array&&>;
+								static_assert(std::is_reference_v<elem_ref>);
+
+								// func(elem, i)
+								if constexpr (std::is_invocable_v<Func&&, elem_ref, size_t>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem), i);
+										return true;
+									}
+								}
+
+								// func(i, elem)
+								else if constexpr (std::is_invocable_v<Func&&, size_t, elem_ref>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(i, static_cast<elem_ref>(elem));
+										return true;
+									}
+								}
+
+								// func(elem)
+								else if constexpr (std::is_invocable_v<Func&&, elem_ref>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<elem_ref>(elem));
+										return true;
+									}
+								}
+
+								// visitor not compatible with this particular type
+								else
+									return true;
+							});
+
+				if (!keep_going)
+					return;
+			}
+		}
+
+	  public:
+
+		template <typename Func>
+		array& for_each(Func&& visitor) & noexcept(for_each_is_nothrow<Func&&, array&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		template <typename Func>
+		array&& for_each(Func&& visitor) && noexcept(for_each_is_nothrow<Func&&, array&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<array&&>(*this));
+			return static_cast<array&&>(*this);
+		}
+
+		template <typename Func>
+		const array& for_each(Func&& visitor) const& noexcept(for_each_is_nothrow<Func&&, const array&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		template <typename Func>
+		const array&& for_each(Func&& visitor) const&& noexcept(for_each_is_nothrow<Func&&, const array&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<const array&&>(*this));
+			return static_cast<const array&&>(*this);
+		}
+
 		TOML_NODISCARD
 		bool empty() const noexcept
 		{
@@ -6115,8 +6275,8 @@ TOML_NAMESPACE_START
 	inline constexpr bool is_key = std::is_same_v<impl::remove_cvref<T>, toml::key>;
 
 	template <typename T>
-	inline constexpr bool is_key_or_convertible =
-		is_key<T> || std::is_constructible_v<toml::key, T> || std::is_convertible_v<T, toml::key>;
+	inline constexpr bool is_key_or_convertible = is_key<T> //
+											   || impl::is_constructible_or_convertible<toml::key, T>;
 }
 TOML_NAMESPACE_END;
 
@@ -6316,6 +6476,7 @@ TOML_NAMESPACE_START
 	  private:
 
 		using map_type			 = std::map<toml::key, impl::node_ptr, std::less<>>;
+		using map_pair			 = std::pair<const toml::key, impl::node_ptr>;
 		using map_iterator		 = typename map_type::iterator;
 		using const_map_iterator = typename map_type::const_iterator;
 		map_type map_;
@@ -6709,6 +6870,149 @@ TOML_NAMESPACE_START
 			return const_iterator{ map_.cend() };
 		}
 
+	  private:
+
+		template <typename T, typename Table>
+		using for_each_value_ref = impl::copy_cvref<impl::wrap_node<impl::remove_cvref<impl::unwrap_node<T>>>, Table>;
+
+		template <typename Func, typename Table, typename T>
+		static constexpr bool can_for_each = std::is_invocable_v<Func, const key&, for_each_value_ref<T, Table>> //
+										  || std::is_invocable_v<Func, for_each_value_ref<T, Table>>;
+
+		template <typename Func, typename Table, typename T>
+		static constexpr bool can_for_each_nothrow =
+			std::is_nothrow_invocable_v<Func, const key&, for_each_value_ref<T, Table>> //
+			|| std::is_nothrow_invocable_v<Func, for_each_value_ref<T, Table>>;
+
+		template <typename Func, typename Table>
+		static constexpr bool can_for_each_any = can_for_each<Func, Table, table>		//
+											  || can_for_each<Func, Table, array>		//
+											  || can_for_each<Func, Table, std::string> //
+											  || can_for_each<Func, Table, int64_t>		//
+											  || can_for_each<Func, Table, double>		//
+											  || can_for_each<Func, Table, bool>		//
+											  || can_for_each<Func, Table, date>		//
+											  || can_for_each<Func, Table, time>		//
+											  || can_for_each<Func, Table, date_time>;
+
+		template <typename Func, typename Table, typename T>
+		static constexpr bool for_each_is_nothrow_one = !can_for_each<Func, Table, T> //
+													 || can_for_each_nothrow<Func, Table, T>;
+
+		// clang-format off
+
+		  template <typename Func, typename Table>
+		  static constexpr bool for_each_is_nothrow = for_each_is_nothrow_one<Func, Table, table>		//
+												   && for_each_is_nothrow_one<Func, Table, array>		//
+												   && for_each_is_nothrow_one<Func, Table, std::string> //
+												   && for_each_is_nothrow_one<Func, Table, int64_t>		//
+												   && for_each_is_nothrow_one<Func, Table, double>		//
+												   && for_each_is_nothrow_one<Func, Table, bool>		//
+												   && for_each_is_nothrow_one<Func, Table, date>		//
+												   && for_each_is_nothrow_one<Func, Table, time>		//
+												   && for_each_is_nothrow_one<Func, Table, date_time>;
+
+		// clang-format on
+
+		template <typename Func, typename Table>
+		static void do_for_each(Func&& visitor, Table&& tbl) noexcept(for_each_is_nothrow<Func&&, Table&&>)
+		{
+			static_assert(can_for_each_any<Func&&, Table&&>,
+						  "TOML table for_each visitors must be invocable for at least one of the toml::node "
+						  "specializations:" TOML_SA_NODE_TYPE_LIST);
+
+			using kvp_type = impl::copy_cv<map_pair, std::remove_reference_t<Table>>;
+
+			for (kvp_type& kvp : tbl.map_)
+			{
+				using node_ref = impl::copy_cvref<toml::node, Table&&>;
+				static_assert(std::is_reference_v<node_ref>);
+
+				const auto keep_going =
+					static_cast<node_ref>(*kvp.second)
+						.visit(
+							[&](auto&& v) noexcept(for_each_is_nothrow_one<Func&&, Table&&, decltype(v)>)
+							{
+								using value_ref = for_each_value_ref<decltype(v), Table&&>;
+								static_assert(std::is_reference_v<value_ref>);
+
+								// func(key, val)
+								if constexpr (std::is_invocable_v<Func&&, const key&, value_ref>)
+								{
+									using return_type = decltype(static_cast<Func&&>(
+										visitor)(static_cast<const key&>(kvp.first), static_cast<value_ref>(v)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(static_cast<Func&&>(
+											visitor)(static_cast<const key&>(kvp.first), static_cast<value_ref>(v)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<const key&>(kvp.first),
+																	 static_cast<value_ref>(v));
+										return true;
+									}
+								}
+
+								// func(val)
+								else if constexpr (std::is_invocable_v<Func&&, value_ref>)
+								{
+									using return_type =
+										decltype(static_cast<Func&&>(visitor)(static_cast<value_ref>(v)));
+
+									if constexpr (impl::is_constructible_or_convertible<bool, return_type>)
+									{
+										return static_cast<bool>(
+											static_cast<Func&&>(visitor)(static_cast<value_ref>(v)));
+									}
+									else
+									{
+										static_cast<Func&&>(visitor)(static_cast<value_ref>(v));
+										return true;
+									}
+								}
+
+								// visitor not compatible with this particular type
+								else
+									return true;
+							});
+
+				if (!keep_going)
+					return;
+			}
+		}
+
+	  public:
+
+		template <typename Func>
+		table& for_each(Func&& visitor) & noexcept(for_each_is_nothrow<Func&&, table&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		template <typename Func>
+		table&& for_each(Func&& visitor) && noexcept(for_each_is_nothrow<Func&&, table&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<table&&>(*this));
+			return static_cast<table&&>(*this);
+		}
+
+		template <typename Func>
+		const table& for_each(Func&& visitor) const& noexcept(for_each_is_nothrow<Func&&, const table&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), *this);
+			return *this;
+		}
+
+		template <typename Func>
+		const table&& for_each(Func&& visitor) const&& noexcept(for_each_is_nothrow<Func&&, const table&&>)
+		{
+			do_for_each(static_cast<Func&&>(visitor), static_cast<const table&&>(*this));
+			return static_cast<const table&&>(*this);
+		}
+
 		TOML_PURE_INLINE_GETTER
 		bool empty() const noexcept
 		{
@@ -9190,16 +9494,13 @@ TOML_IMPL_NAMESPACE_START
 		if ((!lhs != !rhs) || lhs->type() != rhs->type())
 			return false;
 
-		bool same;
-		lhs->visit(
-			[=, &same](auto& l) noexcept
+		return lhs->visit(
+			[=](auto& l) noexcept
 			{
 				using concrete_type = remove_cvref<decltype(l)>;
 
-				same = (l == *(rhs->as<concrete_type>()));
+				return l == *(rhs->as<concrete_type>());
 			});
-
-		return same;
 	}
 }
 TOML_IMPL_NAMESPACE_END;
diff --git a/tools/generate_conformance_tests.py b/tools/generate_conformance_tests.py
index ad8afd52..8da97497 100755
--- a/tools/generate_conformance_tests.py
+++ b/tools/generate_conformance_tests.py
@@ -446,6 +446,9 @@ def load_valid_inputs(tests, extern_root):
 	add_condition(tests['valid']['burntsushi'], '!TOML_MSVC', (
 		'inline-table-key-dotted', # causes MSVC to run out of heap space during compilation O_o
 	))
+	add_condition(tests['valid']['burntsushi'], 'TOML_LANG_UNRELEASED', (
+		'string-escape-esc', # \e in strings
+	))
 
 	tests['valid']['iarna'] = load_tests(Path(extern_root, 'toml-spec-tests', 'values'), True, (
 		# these are stress-tests for 'large' datasets. I test these separately. Having them inline in C++ code is insane.
diff --git a/tools/generate_windows_test_targets.py b/tools/generate_windows_test_targets.py
index ff7fed34..b3a4e7e2 100755
--- a/tools/generate_windows_test_targets.py
+++ b/tools/generate_windows_test_targets.py
@@ -121,6 +121,7 @@ def main():
 		<ClCompile Include="..\conformance_burntsushi_valid.cpp" />
 		<ClCompile Include="..\conformance_iarna_invalid.cpp" />
 		<ClCompile Include="..\conformance_iarna_valid.cpp" />
+		<ClCompile Include="..\for_each.cpp" />
 		<ClCompile Include="..\formatters.cpp" />
 		<ClCompile Include="..\impl_toml.cpp">
 			<PrecompiledHeader>NotUsing</PrecompiledHeader>