diff --git a/tc/algorithm/accumulate.h b/tc/algorithm/accumulate.h
index f71e4be..c1412ac 100644
--- a/tc/algorithm/accumulate.h
+++ b/tc/algorithm/accumulate.h
@@ -46,7 +46,7 @@ namespace tc {
 
 			template< typename S >
 			constexpr auto operator()( S&& s ) const& MAYTHROW {
-				return CONDITIONAL_PRVALUE_AS_VAL(
+				return tc_conditional_prvalue_as_val(
 					m_t,
 					tc::continue_if_not_break( m_accuop, *m_t, std::forward<S>(s) ),
 					TC_FWD(tc::optional_emplace(m_t, std::forward<S>(s)), tc::constant<tc::continue_>())
diff --git a/tc/algorithm/accumulator.h b/tc/algorithm/accumulator.h
deleted file mode 100644
index 01dd491..0000000
--- a/tc/algorithm/accumulator.h
+++ /dev/null
@@ -1,47 +0,0 @@
-
-// think-cell public library
-//
-// Copyright (C) 2016-2023 think-cell Software GmbH
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
-
-#pragma once
-
-#include "../base/assert_defs.h"
-#include "../base/functors.h"
-#include "../base/return_decltype.h"
-#include "../base/casts.h"
-#include "../base/derivable.h"
-#include "../base/assign.h"
-
-#include <utility>
-
-namespace tc {
-
-template<typename Value, typename Accumulate>
-struct [[nodiscard]] FAccumulator final : tc::derivable_t<tc::decay_t<Value>> {
-	using value_t = tc::decay_t<Value>;
-
-	FAccumulator(Value&& value, Accumulate&& accumulate) noexcept
-	:	tc::derivable_t<value_t>(std::forward<Value>(value))
-	,	m_accumulate(std::forward<Accumulate>(accumulate))
-	{}
-
-	template<typename... Args>
-	void operator() (Args&& ... args) & noexcept {
-		m_accumulate( tc::base_cast<value_t>(*this), std::forward<Args>(args)... );
-	}
-
-private:
-	tc::decay_t<Accumulate> m_accumulate;
-};
-
-///////////////////////////////////////////////
-// accumulators
-
-template<typename Value, typename Accumulate>
-auto make_accumulator(Value&& value, Accumulate&& accumulate)
-	return_ctor_noexcept( TC_FWD(FAccumulator<Value, Accumulate>), (std::forward<Value>(value),std::forward<Accumulate>(accumulate)) )
-
-} // namespace tc
diff --git a/tc/algorithm/algorithm.h b/tc/algorithm/algorithm.h
index 5653ff8..3fcc03d 100644
--- a/tc/algorithm/algorithm.h
+++ b/tc/algorithm/algorithm.h
@@ -72,38 +72,12 @@ namespace tc {
 		});
 	}
 	template< typename Rng, typename Less = tc::fn_less>
-	[[nodiscard]] constexpr bool is_sorted(Rng const& rng, Less less = Less()) noexcept {
-		return !tc::any_of(tc::adjacent<2>(rng), [&](auto const& first, auto const& second) noexcept {
-			return less(second, first);
+	[[nodiscard]] constexpr bool is_sorted(Rng const& rng, Less less = Less()) MAYTHROW {
+		return !tc::any_of(tc::adjacent<2>(rng), [&](auto const& first, auto const& second) MAYTHROW {
+			return less(second, first); // MAYTHROW
 		});
 	}
 
-	template< typename Rng, typename Equal = tc::fn_equal_to >
-	[[nodiscard]] constexpr bool all_same(Rng const& rng, Equal equal = Equal()) noexcept {
-		if constexpr( tc::range_with_iterators<Rng> ) {
-			auto const itBegin=tc::begin(rng);
-			auto const itEnd=tc::end(rng);
-			if(itBegin==itEnd) return true;
-			auto const itNext=tc_modified(itBegin, ++_);
-			if(itNext==itEnd) return true;
-			tc_auto_cref( front, *itBegin );
-			return all_of(
-				tc::drop(rng, itNext),
-				[&](auto const& _) noexcept { return equal(front, _); }
-			);
-		} else {
-			std::optional<tc::range_value_t<Rng const&>> oFirst;
-			return tc::continue_ == tc::for_each(rng, [&](auto&& val) noexcept {
-				if (oFirst) {
-					return tc::continue_if(equal(*oFirst, val));
-				} else {
-					oFirst.emplace(tc_move_if_owned(val));
-					return tc::continue_;
-				}
-			});
-		}
-	}
-
 	/////////////////////////////////
 	// associative containers
 
@@ -266,7 +240,7 @@ namespace tc {
 				);
 			}
 
-			sorted_index_adaptor(sorted_index_adaptor&& rng) noexcept requires tc::is_index_valid_for_move_constructed_range<Rng>::value // reference_or_value is movable for const Rng as well
+			sorted_index_adaptor(sorted_index_adaptor&& rng) noexcept requires tc::stable_index_on_move<Rng> // reference_or_value is movable for const Rng as well
 				: range_adaptor_base_range<Rng>(tc_move(rng))
 				, m_vecidx(tc_move(rng).m_vecidx)
 			{
@@ -347,11 +321,11 @@ namespace tc {
 		struct [[nodiscard]] untransform_adaptor
 			:  tc::index_range_adaptor<
 				untransform_adaptor<Rng>,
-				Rng
+				Rng, tc::index_range_adaptor_flags::inherit_begin_end | tc::index_range_adaptor_flags::inherit_traversal
 			>
 		{
 		private:
-			using base_ = tc::index_range_adaptor<untransform_adaptor<Rng>, Rng>;
+			using base_ = typename untransform_adaptor::index_range_adaptor;
 
 		public:
 			using typename base_::tc_index;
@@ -464,7 +438,7 @@ namespace tc {
 	}
 
 	template<typename Cont, typename Less=tc::fn_less>
-	constexpr void ordered_unique_inplace( Cont& cont, Less less=Less() ) noexcept {
+	constexpr void ordered_unique_inplace( Cont& cont, Less less=Less() ) MAYTHROW {
 		_ASSERTDEBUG( tc::is_sorted( cont, less ) );
 		tc::adjacent_unique_inplace( cont, std::not_fn( tc_move(less) ) );
 	}
@@ -481,34 +455,30 @@ namespace tc {
 		tc::ordered_unique_inplace( cont, tc_move(less) );
 	}
 
-	template<typename Rng, typename Less, typename Func>
-	auto ordered_for_each_occurrence(Rng&& rng, Less&& less, Func func) noexcept {
-		return tc::for_each(tc::ordered_unique_range( std::forward<Rng>(rng), std::forward<Less>(less)), [&](auto const& rngSub) noexcept {
-			return tc::continue_if_not_break( func, std::make_pair(
+	template<typename Rng, typename Less>
+	auto ordered_unique_begin_and_count(Rng&& rng, Less&& less) noexcept {
+		return tc::transform(tc::ordered_unique_range( std::forward<Rng>(rng), std::forward<Less>(less)), [&](auto const& rngSub) noexcept {
+			return std::make_pair(
 				tc::begin(rngSub),
 				tc::implicit_cast<typename boost::range_size< std::remove_reference_t<Rng> >::type >(tc::size_linear(rngSub))
-			) );
+			);
 		});
 	}
 
 	template<typename RangeReturn, typename Rng>
 	[[nodiscard]] auto plurality_element(Rng&& rng) noexcept {
-		if(tc::empty(rng)) {
+		auto vecitSorted = tc::sorted_iterator_range(rng, tc::fn_less()); // do not inline, oit->first points into vecitSorted
+		if(auto oit = tc::max_element<tc::return_value_or_none>(
+			tc::ordered_unique_begin_and_count(
+				vecitSorted,
+				tc::projected(tc::fn_less(), fn_indirection())
+			),
+			tc_member(.second)
+		)) {
+			return RangeReturn::pack_element(tc_move_always(*oit->first), std::forward<Rng>(rng));
+		} else {
 			return RangeReturn::pack_no_element(std::forward<Rng>(rng));
 		}
-		auto const rng2=tc::sorted_iterator_range(rng, tc::fn_less());
-
-		auto it = *( tc::accumulate(
-			[&](auto const& func) noexcept {
-				return tc::ordered_for_each_occurrence(rng2, tc::projected(tc::fn_less(), fn_indirection()), func);
-			},
-			std::pair<
-				tc::iterator_t<decltype(rng2)>,
-				typename boost::range_size<decltype(rng2)>::type
-			>(), // value-initialized, second=0
-			tc::fn_assign_better(tc::projected(tc::fn_greater(), tc_member(.second)))
-		).first );
-		return RangeReturn::pack_element(it, std::forward<Rng>(rng));
 	}
 
 	template< typename RangeReturn, typename Rng, typename Pred >
@@ -525,8 +495,14 @@ namespace tc {
 
 	template< typename Rng, typename Pred >
 	[[nodiscard]] decltype(auto) trim_if(Rng&& rng, Pred&& pred) MAYTHROW {
-		auto rngTrimmed = tc::trim_right_if<tc::return_take>( std::forward<Rng>(rng), pred );
-		return tc::trim_left_if<tc::return_drop>( tc_move(rngTrimmed), std::forward<Pred>(pred) );
+		decltype(auto) rngTrimmed = tc::trim_right_if<tc::return_take>( tc_move_if_owned(rng), pred );
+		if constexpr (std::is_reference<decltype(rngTrimmed)>::value) {
+			_ASSERTEQUAL(std::addressof(rngTrimmed), std::addressof(rng));
+			return tc::trim_left_if<tc::return_drop>( tc_move_if_owned(rngTrimmed), tc_move_if_owned(pred) );
+		} else {
+			static_assert(tc::instance<decltype(rngTrimmed), tc::subrange>);
+			return tc::decay_copy(tc::trim_left_if<tc::return_drop>( tc_move(rngTrimmed), tc_move_if_owned(pred) ));
+		}
 	}
 
 	template< typename RangeReturn, typename Rng, typename RngTrim >
@@ -685,7 +661,7 @@ namespace tc {
 
 		template<typename Cont, typename Func>
 		Cont get_truncating_buffer_allowing_nulls(Func func) noexcept {
-			return tc::get_buffer_detail::get_buffer_allowing_nulls<Cont>([&](auto pBuffer, auto nBufferSize) noexcept {
+			return tc::get_buffer_detail::get_buffer_allowing_nulls<Cont>([&](auto pBuffer, auto const nBufferSize) noexcept {
 				auto nSize = func(pBuffer, nBufferSize);
 				if (nSize == nBufferSize) {
 					return nSize+1; // Any return value larger than nBufferSize causes a retry with a larger buffer
@@ -863,7 +839,7 @@ namespace tc {
 	template<typename Rng, typename Less=tc::fn_less>
 	[[nodiscard]] constexpr auto constexpr_sort_unique(Rng&& rng, Less&& less=Less()) noexcept {
 		return tc_modified(
-			tc::make_static_vector<tc::constexpr_size<Rng>::value>(std::forward<Rng>(rng)),
+			tc::make_static_vector<tc::constexpr_size<Rng>()>(std::forward<Rng>(rng)),
 			tc::sort_unique_inplace(_, std::forward<Less>(less))
 		);
 	}
@@ -884,64 +860,63 @@ namespace tc {
 	template< typename RangeReturn, typename SetType, typename T, typename Less >
 	void binary_find_unique(tc::unordered_set<SetType> const& rng, T const& t, Less less) noexcept = delete;
 
-	template< typename RangeReturn, typename Rng, typename T, typename Pred >
-	[[nodiscard]] decltype(auto) binary_find_unique(Rng&& rng, T const& t, Pred predLessOr3way) noexcept {
-		// The result of tc::binary_find_unique must be unambiguous. In general, this means that rng is strictly
-		// ordered. In some cases, it is convenient to allow multiple occurrences of the same item in
-		// rng, which is not a problem as long as these items are not searched for.
-
-		// preserve order of arguments for 3way predicates
-		static constexpr bool c_b3way = tc::is_comparison_category<decltype(predLessOr3way(tc::front(rng), t))>;
-		auto it=[&]() noexcept {
-			if constexpr(c_b3way) {
-				return tc::lower_bound<tc::return_border>( rng, t, tc::lessfrom3way(std::ref(predLessOr3way)) );
-			} else {
-				_ASSERTDEBUG( tc::is_sorted(rng, predLessOr3way) );
-				return tc::lower_bound<tc::return_border>( rng, t, std::ref(predLessOr3way) );
-			}
-		}();
-		if( it==tc::end( rng ) ) {
-			return RangeReturn::pack_no_element(std::forward<Rng>(rng));
-		} else {
-			auto Greater = [&](auto const& elem) noexcept {
+	namespace binary_find_first_or_unique_adl {
+		template< typename RangeReturn, bool c_bAssertUniqueness, typename Rng, typename T, typename Pred >
+		[[nodiscard]] decltype(auto) binary_find_first_or_unique(Rng&& rng, T const& t, Pred predLessOr3way) noexcept {
+			// The result of tc::binary_find_unique must be unambiguous. In general, this means that rng is strictly
+			// ordered. In some cases, it is convenient to allow multiple occurrences of the same item in
+			// rng, which is not a problem as long as these items are not searched for.
+
+			// preserve order of arguments for 3way predicates
+			static constexpr bool c_b3way = tc::is_comparison_category<decltype(predLessOr3way(tc::front(rng), t))>;
+			auto it=[&]() noexcept {
 				if constexpr(c_b3way) {
-					return std::is_gt(predLessOr3way(elem, t));
+					_ASSERTDEBUG( tc::is_sorted(rng, tc::lessfrom3way(std::ref(predLessOr3way))) );
+					return tc::lower_bound<tc::return_border>( rng, t, tc::lessfrom3way(std::ref(predLessOr3way)) );
 				} else {
-					return predLessOr3way(t, elem);
+					_ASSERTDEBUG( tc::is_sorted(rng, predLessOr3way) );
+					return tc::lower_bound<tc::return_border>( rng, t, std::ref(predLessOr3way) );
 				}
-			};
-			auto && ref=*it;
-			if (Greater(tc::as_const(ref))) {
+			}();
+			if( it==tc::end( rng ) ) {
 				return RangeReturn::pack_no_element(std::forward<Rng>(rng));
 			} else {
-		#ifdef _CHECKS
-				auto itNext = tc_modified(it, ++_);
-				_ASSERT( tc::end(rng)==itNext || Greater(tc::as_const(*itNext)));
-		#endif
-				return RangeReturn::pack_element(it,std::forward<Rng>(rng),tc_move_if_owned(ref));
+				auto const Greater = [&](auto const& elem) noexcept {
+					if constexpr(c_b3way) {
+						return std::is_gt(predLessOr3way(elem, t));
+					} else {
+						return predLessOr3way(t, elem);
+					}
+				};
+				auto && ref=*it;
+				if (Greater(tc::as_const(ref))) {
+					return RangeReturn::pack_no_element(std::forward<Rng>(rng));
+				} else {
+#ifdef _CHECKS
+					if constexpr(c_bAssertUniqueness) {
+						auto itNext = tc_modified(it, ++_);
+						_ASSERT( tc::end(rng)==itNext || Greater(tc::as_const(*itNext)));
+					}
+#endif
+					return RangeReturn::pack_element(it,std::forward<Rng>(rng),tc_move_if_owned(ref));
+				}
 			}
 		}
 	}
-
+	
+	template< typename RangeReturn, typename Rng, typename T, typename Pred >
+	[[nodiscard]] decltype(auto) binary_find_unique(Rng&& rng, T const& t, Pred predLessOr3way) noexcept {
+		return binary_find_first_or_unique_adl::binary_find_first_or_unique<RangeReturn, /*c_bAssertUniqueness*/ true>(tc_move_if_owned(rng), t, tc_move(predLessOr3way));
+	}
+	
 	template< typename RangeReturn, typename Rng, typename T >
 	[[nodiscard]] decltype(auto) binary_find_unique(Rng&& rng, T const& t) noexcept {
 		return tc::binary_find_unique<RangeReturn>( std::forward<Rng>(rng), t, tc::fn_less() );
 	}
 
-	template< typename RangeReturn, typename Rng, typename T, typename Less >
-	[[nodiscard]] decltype(auto) binary_find_first(Rng&& rng, T const& t, Less less) noexcept {
-		_ASSERTDEBUG( tc::is_sorted(rng, less) );
-		auto it=tc::lower_bound<tc::return_border>( rng, t, less );
-		if (it == tc::end(rng)) {
-			return RangeReturn::pack_no_element(std::forward<Rng>(rng));
-		} else {
-			auto && ref = *it;
-			if (less(t, tc::as_const(ref))) {
-				return RangeReturn::pack_no_element(std::forward<Rng>(rng));
-			} else {
-				return RangeReturn::pack_element(it, std::forward<Rng>(rng), tc_move_if_owned(ref));
-			}
-		}
+	template< typename RangeReturn, typename Rng, typename T, typename Pred >
+	[[nodiscard]] decltype(auto) binary_find_first(Rng&& rng, T const& t, Pred predLessOr3way) noexcept {
+		return binary_find_first_or_unique_adl::binary_find_first_or_unique<RangeReturn, /*c_bAssertUniqueness*/ false>(tc_move_if_owned(rng), t, tc_move(predLessOr3way));
 	}
 
 	template< typename RangeReturn, typename Rng, typename T >
@@ -1043,7 +1018,7 @@ namespace tc {
 		};
 	}
 
-	template< typename RngA, typename RngB, typename Comp, typename SinkA, typename SinkB, typename SinkAB >
+	template< typename RngA, tc::range_with_iterators RngB, typename Comp, typename SinkA, typename SinkB, typename SinkAB >
 	auto interleave_2(RngA&& rnga, RngB&& rngb, Comp const comp, SinkA const sinka, SinkB const sinkb, SinkAB const sinkab) MAYTHROW -> tc::common_type_t<
 		decltype(tc::for_each(rnga,
 			std::declval<no_adl::interleave_2_sink<decltype(tc::begin(rngb)), decltype(tc::end(rngb)), Comp, SinkA, SinkB, SinkAB>>()
@@ -1065,6 +1040,23 @@ namespace tc {
 		return tc::constant<tc::continue_>();
 	}
 
+	template< tc::range_with_iterators RngA, typename RngB, typename Comp, typename SinkA, typename SinkB, typename SinkAB >
+		requires (!tc::range_with_iterators<RngB>)
+	auto interleave_2(RngA&& rnga, RngB&& rngb, Comp&& comp, SinkA&& sinka, SinkB&& sinkb, SinkAB&& sinkab) MAYTHROW {
+		return tc::interleave_2(
+			std::forward<RngB>(rngb),
+			std::forward<RngA>(rnga),
+			[comp=tc::decay_copy(std::forward<Comp>(comp))](auto const& elemb, auto const& elema) noexcept {
+				return tc::negate(comp(elema, elemb));
+			},
+			std::forward<SinkB>(sinkb),
+			std::forward<SinkA>(sinka),
+			[sinkab=tc::decay_copy(std::forward<SinkAB>(sinkab))](auto&& elemb, auto&& elema) noexcept {
+				return sinkab(tc_move_if_owned(elema), tc_move_if_owned(elemb));
+			}
+		);
+	}
+
 	namespace no_adl {
 		template<typename Compare>
 		struct SInterleaveImpl {
diff --git a/tc/algorithm/algorithm.t.cpp b/tc/algorithm/algorithm.t.cpp
index 1cf9382..7f21943 100644
--- a/tc/algorithm/algorithm.t.cpp
+++ b/tc/algorithm/algorithm.t.cpp
@@ -28,33 +28,6 @@ namespace {
 		void(tc::explicit_cast<SCopy>(tc::vector<int>{}));
 	}
 
-UNITTESTDEF( quantifiers ) {
-
-	tc::vector<int> v{1,2,3,4,5,6,7};
-
-	tc::vector<int> all_even{2,4,6,8};
-	tc::vector<int> all_odd{3,5,7,9};
-
-	auto even = [](int i) noexcept { return i%2==0; };
-
-	int const existing_value = 5;
-	int const non_existing_value = 9;
-
-	auto const_range = tc::slice(tc::as_const(v)); TEST_RANGE_LENGTH(const_range, 7);
-
-	_ASSERT( tc::find_first<tc::return_bool>(const_range, existing_value));
-	_ASSERT(!tc::find_first<tc::return_bool>(const_range, non_existing_value));
-
-	_ASSERT(! tc::all_of(const_range, even));
-	_ASSERT(  tc::any_of(const_range, even));
-
-	_ASSERT(  tc::all_of(all_even, even));
-	_ASSERT(  tc::any_of(all_even, even));
-
-	_ASSERT(! tc::all_of(all_odd, even));
-	_ASSERT(! tc::any_of(all_odd, even));
-}
-
 UNITTESTDEF( sort_accumulate_each_unique_range_2 ) {
 	struct SValAccu final {
 		SValAccu(int val, int accu) noexcept : m_val(val), m_accu(accu) {}
@@ -102,10 +75,10 @@ UNITTESTDEF(filter_no_self_assignment_of_rvalues) {
 
 UNITTESTDEF( trim_leftright_if ) {
 	tc::vector<int> v{1,2,3,4,5,6,7,7,7};
-	auto rng = tc::trim_left_if<tc::return_drop>(v, [] (int n) noexcept {return n<4;});
+	auto rng = tc::trim_left_if<tc::return_drop>(v, [] (int const n) noexcept {return n<4;});
 	_ASSERT(tc::begin(rng) != tc::end(rng));
 	_ASSERTEQUAL(tc::size(rng), 6);
-	_ASSERTEQUAL(tc::size(tc::trim_right_if<tc::return_take>(rng, [] (int n) noexcept {return n==7;})), 3);
+	_ASSERTEQUAL(tc::size(tc::trim_right_if<tc::return_take>(rng, [] (int const n) noexcept {return n==7;})), 3);
 }
 
 UNITTESTDEF( is_sorted ) {
@@ -145,43 +118,10 @@ UNITTESTDEF( is_sorted ) {
 
 UNITTESTDEF( make_vector_on_r_vector_is_identity ) {
 	tc::vector<int> v{1,2,3};
-	auto pvecdata = v.data();
+	auto pvecdata = tc::ptr_begin(v);
 
 	auto vNew = tc::make_vector(tc_move(v));
-	_ASSERTEQUAL(vNew.data(), pvecdata);
-}
-
-UNITTESTDEF(rangefilter_on_subrange) {
-	tc::vector<int> vecn={2,3,3,0, /*rngn starts here*/ 3,4,5,6,4,5,6,7};
-	auto rngn=tc::begin_next<tc::return_drop>(vecn, 4);
-
-	{
-		tc::sort_unique_inplace(rngn); // uses range_filter<tc::subrange<tc::vector<int>&> > internally
-		int const anExpected[]={2,3,3,0, /*rngn starts here*/ 3,4,5,6,7};
-		_ASSERT(tc::equal(vecn, anExpected));
-		_ASSERTEQUAL(tc::begin(rngn), tc::begin_next<tc::return_border>(vecn,4));
-		_ASSERTEQUAL(tc::end(rngn), tc::end(vecn));
-	}
-
-	{
-		{
-			tc::range_filter<tc::subrange<tc::vector<int>&> > filter(rngn);
-			auto it=tc::begin(rngn);
-			filter.keep(it++);
-			filter.keep(it++);
-			filter.keep(it++);
-			int i=0;
-			while(tc::begin(filter)!=tc::end(filter)) {
-				tc::drop_last_inplace(filter);
-				++i;
-			}
-			_ASSERTEQUAL(i,3);
-		}
-		int const anExpected[]={2,3,3,0, /*rngn starts here*/};
-		_ASSERT(tc::equal(vecn, anExpected));
-		_ASSERTEQUAL(tc::begin(rngn), tc::begin_next<tc::return_border>(vecn,4));
-		_ASSERTEQUAL(tc::end(rngn), tc::end(vecn));
-	}
+	_ASSERTEQUAL(tc::ptr_begin(vNew), pvecdata);
 }
 
 UNITTESTDEF(is_strictly_sorted){
@@ -231,7 +171,7 @@ UNITTESTDEF(Naryinterleave) {
 	);
 
 	_ASSERT(tc::equal(
-		tc::transform(vecnBCopy, [](int n) noexcept {return n+100;}),
+		tc::transform(vecnBCopy, [](int const n) noexcept {return n+100;}),
 		vecnB
 	));
 }
@@ -273,7 +213,7 @@ UNITTESTDEF(NaryinterleaveBreak) {
 	);
 
 	_ASSERT(tc::equal(
-		tc::transform(vecnBCopy, [](int n) noexcept {return n < 7 ? n + 100 : n; }),
+		tc::transform(vecnBCopy, [](int const n) noexcept {return n < 7 ? n + 100 : n; }),
 		vecnB
 	));
 }
@@ -337,7 +277,7 @@ UNITTESTDEF(plurality_element_test) {
 	auto const str3 = "a";
 	_ASSERTEQUAL(tc::begin(str3),tc::plurality_element<tc::return_element>(str3));
 	int an[] = {1,2,3,4,3,4,3,5,6};
-	_ASSERTEQUAL(std::optional(4), tc::plurality_element<tc::return_value_or_none>(tc::filter(an, [](auto n) noexcept { return n % 2 == 0; })));
+	_ASSERTEQUAL(std::optional(4), tc::plurality_element<tc::return_value_or_none>(tc::filter(an, [](auto const n) noexcept { return n % 2 == 0; })));
 }
 
 static_assert(std::is_move_constructible<decltype(tc::sort(std::declval<tc::string<char> const&>()))>::value);
@@ -361,7 +301,7 @@ UNITTESTDEF(constexpr_sort_test) {
 	std::mt19937 gen; // same sequence of numbers each time for reproducibility
 	std::uniform_int_distribution<> dist(0, 63);
 
-	auto Test = [](auto rngn) noexcept {
+	static auto constexpr Test = [](auto rngn) noexcept {
 		auto vecn = tc::explicit_cast<tc::vector<int>>(rngn);
 		_ASSERTEQUAL(tc_modified(vecn, tc::sort_inplace(_)), tc_modified(vecn, tc::constexpr_sort_inplace_detail::constexpr_sort_inplace(tc::begin(_), tc::end(_), tc::fn_less())));
 	};
diff --git a/tc/algorithm/any_accu.h b/tc/algorithm/any_accu.h
index 12c2b66..e5a9dc6 100644
--- a/tc/algorithm/any_accu.h
+++ b/tc/algorithm/any_accu.h
@@ -25,7 +25,7 @@ namespace tc {
 				return m_b;
 			}
 
-			constexpr void operator()(bool b) & noexcept {
+			constexpr void operator()(bool const b) & noexcept {
 				tc_inplace(m_b) || b;
 			}
 
diff --git a/tc/algorithm/append.h b/tc/algorithm/append.h
index 23c0460..fab1e31 100644
--- a/tc/algorithm/append.h
+++ b/tc/algorithm/append.h
@@ -10,6 +10,7 @@
 
 #include "../base/assert_defs.h"
 #include "../base/construction_restrictiveness.h"
+#include "../base/inside_unwinding.h"
 
 #include "../container/container_traits.h"
 #include "../container/insert.h"
@@ -143,7 +144,7 @@ namespace tc {
 		} else {
 			// assume iterators are stable to get iterator to first inserted element
 			auto const it = tc::back<tc::return_element_or_null>(cont);
-			auto FirstAppendedElement = [&]() noexcept {
+			auto const FirstAppendedElement = [&]() noexcept {
 				return it ? tc_modified(it, ++_) : tc::begin(cont);
 			};
 			try {
@@ -163,6 +164,36 @@ namespace tc {
 		return tc::append<RangeReturn>(std::forward<Cont>(cont), tc::concat(std::forward<Rng>(rng)...));
 	}
 
+	namespace no_adl {
+		template<typename Cont, typename Rng>
+		struct append_on_dtor_t final : tc::noncopyable, tc::inside_unwinding {
+			tc::optional<Cont&> m_ocont;
+			tc::reference_or_value<Rng> m_rng;
+
+			append_on_dtor_t(Cont& cont, Rng&& rng) noexcept
+			: m_ocont(cont), m_rng(tc::aggregate_tag, std::forward<Rng>(rng))
+			{}
+
+			append_on_dtor_t(append_on_dtor_t&& other) noexcept
+			: m_ocont(tc_move(other.m_ocont)), m_rng(tc_move(other.m_rng))
+			{
+				other.m_ocont = std::nullopt;
+			}
+			ASSIGN_BY_RENEW(append_on_dtor_t, append_on_dtor_t&&);
+
+			~append_on_dtor_t() MAYTHROW {
+				if(m_ocont && !inside_stack_unwinding()) {
+					tc::append(*m_ocont, *tc_move(m_rng)); // MAYTHROW
+				}
+			}
+		};
+	}
+
+	template<typename Cont, tc::appendable<Cont&> Rng>
+	constexpr decltype(auto) make_append_on_dtor(Cont& cont, Rng&& rng) MAYTHROW {
+		return no_adl::append_on_dtor_t<Cont, Rng>(cont, std::forward<Rng>(rng));
+	}
+
 	namespace explicit_convert_to_container_detail {
 		template<typename TTarget, typename Rng0, typename... RngN>
 		using use_ctor=tc::constant<
diff --git a/tc/algorithm/append.t.cpp b/tc/algorithm/append.t.cpp
index 6ab1490..029cb64 100644
--- a/tc/algorithm/append.t.cpp
+++ b/tc/algorithm/append.t.cpp
@@ -14,7 +14,6 @@
 #include "../static_vector.h"
 #include "../range/filter_adaptor.h"
 
-
 static_assert(tc::appendable<char const*, tc::string<char>&>);
 static_assert(!tc::appendable<int, tc::string<char>&>);
 static_assert(tc::appendable<tc::char16 const*, tc::string<char>&>);
@@ -25,85 +24,27 @@ static_assert(!tc::appendable<tc::static_vector<int, 3>, tc::string<char>&>);
 
 UNITTESTDEF(nonappendable) {
 	tc::vector<int> vecnTest{1, 2, 3};
-	auto rngTest1=tc::transform(vecnTest, [](auto n) noexcept { return n + 1; });
+	auto rngTest1=tc::transform(vecnTest, [](auto const n) noexcept { return n + 1; });
 	static_assert(!tc::appendable<decltype(rngTest1), tc::string<char>&>);
 	auto rngTest2=tc::filter(vecnTest, [](auto const n) noexcept { return n%2==1; });
 	static_assert(!tc::appendable<decltype(rngTest2), tc::string<char>&>);
 }
 
-namespace {
-	struct SNonReportAppendable final {
-		friend bool operator==(SNonReportAppendable const&, int) noexcept {
-			return true;
-		}
-	};
-}
-
-UNITTESTDEF(nonreportappendable) {
-	int n = 5;
-	_ASSERTEQUAL(SNonReportAppendable(), n);
-	VERIFYEQUAL(SNonReportAppendable(), n);
-#ifdef TC_PRIVATE
-	VERIFYPRED(SNonReportAppendable(), _==n);
-#endif
-}
-
-#ifdef TC_PRIVATE
-#include "Library/ErrorReporting/decl.h"
-
-namespace {
-	struct STestError1 {
-		friend auto debug_output_impl(STestError1 const&) noexcept {
-			return tc::concat("STestError1(", tc::debug_output(-1), ")");
+UNITTESTDEF(append_on_dtor) {
+	{
+		tc::string<char> str;
+		tc::append(str, "Hello ");
+		{
+			tc::make_append_on_dtor(str, "World!");
 		}
-	};
-	
-	struct STestError2 {
-		DECLARE_FRIEND_FN_DEBUG_OUTPUT_IMPL(STestError2)
-	};
-
-	DEFINE_FRIEND_FN_DEBUG_OUTPUT_IMPL(STestError2) {
-		tc::for_each(tc::concat("STestError2(", tc::debug_output(5), ", ", tc::debug_output(STestError1()), ")"), tc_move(appdr));
+		_ASSERT(tc::equal(str, "Hello World!"));
 	}
-
-	struct STestError3 {};
-
-	auto debug_output_impl(STestError3 const&) noexcept {
-		return [](tc::report_appender appdr) noexcept {
-			tc::for_each(tc::concat("STestError3(", tc::debug_output(STestError2()), ", ", tc::debug_output(nullptr), ")"), tc_move(appdr));
-		};
+	{
+		tc::string<char> str;
+		{
+			tc_auto_cref(a1, tc::make_append_on_dtor(str, "World!"));
+			tc_auto_cref(a2, tc::make_append_on_dtor(str, "Hello "));
+		}
+		_ASSERT(tc::equal(str, "Hello World!"));
 	}
 }
-
-UNITTESTDEF(SReportStreamTest) {
-	tc::SReportStream rs;
-	char const* pt = nullptr;
-	tc::append(rs, UTF16("abc["));
-	tc::append(rs, tc::debug_output(10));
-	tc::append(rs, "][", tc::debug_output(pt), "]");
-	tc::append(rs, tc::debug_output(STestError3()));
-	_ASSERTEQUAL(rs.m_str, "abc[10][nullptr]STestError3(STestError2(5, STestError1(-1)), nullptr)");
-}
-
-
-UNITTESTDEF(SReportStreamExceptionTest) {
-	tc::SReportStream rs;
-	tc::append(rs,
-		"Generate msg#0: ", [](auto sink) MAYTHROW {
-			tc::for_each("<part0>", sink);
-			tc::for_each([](auto sink) MAYTHROW { throw 0; }, sink);
-			throw 1;
-		}, "\n"
-		"Generate msg#1: ", [](tc::report_appender appdr) MAYTHROW {
-			tc::for_each([](auto sink) MAYTHROW { throw 0; }, appdr);
-			tc::for_each([](auto sink) MAYTHROW { throw 1; }, appdr);
-			tc::for_each("<part2>", appdr);
-			throw 0;
-		}, "\n"
-	);
-	_ASSERTEQUAL(rs.m_str,
-		"Generate msg#0: <part0><tc::report threw exception>\n"
-		"Generate msg#1: <tc::report threw exception><tc::report threw exception><part2><tc::report threw exception>\n"
-	);
-}
-#endif
diff --git a/tc/algorithm/best_element.h b/tc/algorithm/best_element.h
index 503bf98..fe55a76 100644
--- a/tc/algorithm/best_element.h
+++ b/tc/algorithm/best_element.h
@@ -8,7 +8,6 @@
 
 #pragma once
 
-#include "../range/range_fwd.h"
 #include "../range/subrange.h"
 #include "../storage_for.h"
 #include "../base/assign.h"
@@ -52,7 +51,9 @@ namespace tc {
 					}
 				}
 			}
-		} else if (auto ovalue = tc::accumulate_with_front(std::forward<Rng>(rng), tc::fn_assign_better(tc_move(better)))) {
+		} else if (auto ovalue = tc::accumulate_with_front(std::forward<Rng>(rng), [&](auto& valueBest, auto&& value) noexcept {
+			return tc::assign_better(better, valueBest, tc_move_if_owned(value));
+		})) {
 			return RangeReturn::template pack_element<Rng>(*tc_move(ovalue));
 		} else {
 			return RangeReturn::template pack_no_element<Rng>();
diff --git a/tc/algorithm/break_or_continue.h b/tc/algorithm/break_or_continue.h
index 752ce68..c1dc265 100644
--- a/tc/algorithm/break_or_continue.h
+++ b/tc/algorithm/break_or_continue.h
@@ -15,8 +15,6 @@
 #include "../base/derivable.h"
 #include "../base/invoke.h"
 
-#include "accumulator.h"
-
 #include <type_traits>
 #include <functional>
 
@@ -85,6 +83,11 @@ namespace tc {
 	//// continue_if_not_break ///////////////////////////////////////////////////////////////////////////
 	// Func returns break_or_continue
 
+	template <typename Sink, typename ... Args>
+	concept sinkable = tc::invocable<std::remove_cvref_t<Sink> const&, Args...>;
+	template <typename Sink, typename ... Args>
+	concept nothrow_sinkable = tc::sinkable<Sink, Args...> && tc::nothrow_invocable<std::remove_cvref_t<Sink> const&, Args...>;
+
 	template<typename Sink, typename... Args>
 	constexpr auto continue_if_not_break(Sink const& sink, Args&&... args) return_decltype_MAYTHROW(
 		tc_internal_continue_if_not_break(tc::invoke(sink, std::forward<Args>(args)...))
@@ -198,7 +201,7 @@ namespace tc {
 
 	using no_adl::move_only_function;
 
-	inline bool cyclic_improve_impl(int n, int& nSkipRule) noexcept {
+	inline bool cyclic_improve_impl(int const n, int& nSkipRule) noexcept {
 		return false;
 	}
 
diff --git a/tc/algorithm/compare.h b/tc/algorithm/compare.h
index e5b86f7..fd58ab9 100644
--- a/tc/algorithm/compare.h
+++ b/tc/algorithm/compare.h
@@ -39,24 +39,9 @@ namespace tc {
 }
 
 namespace tc {
-	// we do not allow std::partial_ordering by tc::explicit_cast it to std::weak_ordering in tc::compare
+	// we always use tc::compare to perform 3 way comparison and tc::compare tc::explicit_cast std::strong_ordering/partial_ordering result to std::weak_ordering
 	template<typename Cat>
-	concept is_comparison_category = std::same_as<std::common_comparison_category_t<Cat, std::weak_ordering>, std::weak_ordering>;
-
-	namespace no_adl {
-		template<typename TypeList, typename=void>
-		struct common_comparison_category;
-
-		template<typename... T>
-		struct common_comparison_category<tc::type::list<T...>, std::enable_if_t<(... && tc::is_comparison_category<T>)>> final {
-			using type = std::common_comparison_category_t<T...>;
-			static_assert(tc::is_comparison_category<type>);
-		};
-	}
-
-	// provides a common type if every T is either std::weak_ordering or std::strong_ordering
-	template<typename... T>
-	using common_comparison_category_t = typename tc::no_adl::common_comparison_category<tc::type::list<T...>>::type;
+	concept is_comparison_category = std::same_as<Cat, std::weak_ordering>;
 
 	namespace no_adl {
 		// class T derives from tc::equal_from_three_way if T has a user defined operator<=> and implements operator== with operator<=>
@@ -82,7 +67,7 @@ namespace tc {
 			template<typename T> requires std::same_as<T, comparable>
 			friend constexpr bool operator==(T const&, T const&) noexcept { return true; }
 			template<typename T> requires std::same_as<T, comparable>
-			friend constexpr auto operator<=>(T const&, T const&) noexcept { return std::strong_ordering::equal; }
+			friend constexpr auto operator<=>(T const&, T const&) noexcept { return std::weak_ordering::equivalent; }
 		};
 	}
 	using no_adl::equal_from_three_way;
@@ -124,15 +109,12 @@ namespace tc {
 	concept has_operator_3way_compare = requires(Lhs const& lhs, Rhs const& rhs) { lhs<=>rhs; };
 
 	template<typename Lhs, typename Rhs>
-	constexpr auto compare(Lhs const& lhs, Rhs const& rhs) noexcept(noexcept(lhs<=>rhs)) requires has_operator_3way_compare<Lhs, Rhs> && (!tc::comparable_pointers<Lhs, Rhs>) {
-		if constexpr (std::same_as<decltype(lhs<=>rhs), std::partial_ordering>) {
-			// 1. floating point comparison
-			// 2. library types comparison may return std::partial_ordering if they contain floating point values. e.g. std::vector, std::pair, std::variant, std::tuple
-			return tc::explicit_cast<std::weak_ordering>(lhs<=>rhs);
-		} else {
-			static_assert(tc::is_comparison_category<decltype(lhs<=>rhs)>);
-			return lhs<=>rhs;
-		}
+	constexpr std::weak_ordering compare(Lhs const& lhs, Rhs const& rhs) noexcept(noexcept(lhs<=>rhs)) requires has_operator_3way_compare<Lhs, Rhs> && (!tc::comparable_pointers<Lhs, Rhs>) {
+		// We tc::explicit_cast std::partial_ordering/std::strong_ordering result to std::weak_ordering.
+		// Comparisons that return std::partial_ordering:
+		// 1. floating point comparison
+		// 2. library types comparison may return std::partial_ordering if they contain floating point values. e.g. std::vector, std::pair, std::variant, std::tuple
+		tc_return_cast(lhs<=>rhs);
 	}
 
 	// similar to Synthesized three-way comparison except with tc::less instead of operator<
@@ -221,7 +203,7 @@ namespace tc {
 			return tc::is_neq(order);
 		}), std::weak_ordering::equal);
 #else // constexpr workaround
-		tc::range_value_t<Rng> order=std::strong_ordering::equivalent;
+		tc::range_value_t<Rng> order=std::weak_ordering::equivalent;
 		tc::for_each(rng, [&](auto const& order2) noexcept {
 			if(tc::is_neq(order2)) {
 				order = order2;
@@ -247,19 +229,19 @@ namespace tc {
 			for(;;) {
 				if( itLhs==itLhsEnd ) {
 					if constexpr(eprefixEQUIVALENT==eprefix) {
-						return std::strong_ordering::equivalent; // if lhs is a prefix of rhs this is considered equivalent
+						return std::weak_ordering::equivalent; // if lhs is a prefix of rhs this is considered equivalent
 					} else {
 						if( itRhs==itRhsEnd ) {
-							return std::strong_ordering::equivalent;
+							return std::weak_ordering::equivalent;
 						} else {
 							_ASSERTE(eprefixALLOW==eprefix);
-							return std::strong_ordering::less; // lhs shorter than rhs, thus <
+							return std::weak_ordering::less; // lhs shorter than rhs, thus <
 						}
 					}
 				}
 				if( itRhs==itRhsEnd ) {
 					_ASSERTE(eprefixFORBID!=eprefix);
-					return std::strong_ordering::greater; // rhs shorter than lhs, thus >
+					return std::weak_ordering::greater; // rhs shorter than lhs, thus >
 				}
 				tc_return_if_not_equal( fnCompare( *itLhs, *itRhs ) );
 				++itLhs;
@@ -299,13 +281,13 @@ namespace std { // ADL
 	}
 
 	template< typename First, typename Second >
-	[[nodiscard]] constexpr auto operator<=>(std::pair<First, Second> const& lhs, std::pair<First, Second> const& rhs ) noexcept -> tc::common_comparison_category_t<
-		decltype(tc::compare(lhs.first, rhs.first)),
-		decltype(tc::compare(lhs.second, rhs.second))
-	> {
+	[[nodiscard]] constexpr auto operator<=>(std::pair<First, Second> const& lhs, std::pair<First, Second> const& rhs) noexcept requires requires {
+		tc::compare(lhs.first, rhs.first);
+		tc::compare(lhs.second, rhs.second);
+	} {
 		tc_compare_expr( _.first );
 		tc_compare_expr( _.second );
-		return std::strong_ordering::equivalent;
+		return std::weak_ordering::equivalent;
 	}
 	
 	template<typename T, typename Alloc>
@@ -320,22 +302,21 @@ namespace std { // ADL
 	
 	template<typename... T>
 	[[nodiscard]] constexpr auto operator<=>(std::variant<T...> const& lhs, std::variant<T...> const& rhs) noexcept
-		-> tc::common_comparison_category_t<decltype(tc::compare(std::declval<T const&>(), std::declval<T const&>()))...>
+		requires requires { typename tc::type::list<decltype(tc::compare(std::declval<T const&>(), std::declval<T const&>()))...>; }
 	{
 		if(lhs.valueless_by_exception() && rhs.valueless_by_exception()) {
-			return std::strong_ordering::equal;
+			return std::weak_ordering::equivalent;
 		} else if(lhs.valueless_by_exception()) {
-			return std::strong_ordering::less;
+			return std::weak_ordering::less;
 		} else if(rhs.valueless_by_exception()) {
-			return std::strong_ordering::greater;
+			return std::weak_ordering::greater;
 		} else {
 			tc_compare_expr(_.index());
-			using result_t = tc::common_comparison_category_t<decltype(tc::compare(std::declval<T const&>(), std::declval<T const&>()))...>;
 			return tc::fn_visit(
-				[]<typename TVal>(TVal const& valLhs, TVal const& valRhs) noexcept -> result_t {
+				[]<typename TVal>(TVal const& valLhs, TVal const& valRhs) noexcept {
 					return tc::compare(valLhs, valRhs);
 				},
-				tc::never_called<result_t>()
+				tc::never_called<std::weak_ordering>()
 			)(lhs, rhs);
 		}
 	}
@@ -346,13 +327,13 @@ namespace std { // ADL
 	}
 
 	template<typename T>
-	constexpr std::strong_ordering operator<=>(std::optional<T> const& opt, std::nullopt_t) noexcept {
+	constexpr std::weak_ordering operator<=>(std::optional<T> const& opt, std::nullopt_t) noexcept {
 		return tc::compare(static_cast<bool>(opt), false);
 	}
 
 	template<typename T, typename U, std::enable_if_t<!tc::instance<U, std::optional>>* = nullptr>
 	constexpr auto operator<=>(std::optional<T> const& opt, U const& value) noexcept -> decltype(tc::compare(*opt, value)) {
-		return opt ? tc::compare(*opt, value) : std::strong_ordering::less;
+		return opt ? tc::compare(*opt, value) : std::weak_ordering::less;
 	}
 }
 #endif
@@ -418,11 +399,11 @@ namespace tc {
 	}
 
 	namespace tuple_adl {
-		template<typename... T, typename... U>
+		template<typename... T, typename... U> requires requires { typename tc::type::list<decltype(tc::compare(std::declval<T const&>(), std::declval<U const&>()))...>; }
 		constexpr auto operator<=>(tc::tuple<T...> const& lhs, tc::tuple<U...> const& rhs) noexcept {
 			STATICASSERTEQUAL(sizeof...(T), sizeof...(U));
 			return tc::lexicographical_compare_3way(
-				tc::transform(std::index_sequence_for<T...>(), [&](auto nconstIndex) noexcept -> tc::common_comparison_category_t<decltype(tc::compare(std::declval<std::remove_reference_t<T> const&>(), std::declval<std::remove_reference_t<U> const&>()))...> {
+				tc::transform(std::index_sequence_for<T...>(), [&](auto const nconstIndex) noexcept -> std::weak_ordering {
 					return tc::compare(tc::get<nconstIndex()>(lhs), tc::get<nconstIndex()>(rhs));
 				})
 			);
diff --git a/tc/algorithm/element.h b/tc/algorithm/element.h
index 4f03e4a..87461e0 100644
--- a/tc/algorithm/element.h
+++ b/tc/algorithm/element.h
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "find.h"
-#include "../range/subrange.h"
+#include "../range/range_return.h"
 
 namespace tc {
 	template <typename RangeReturn>
diff --git a/tc/algorithm/empty.h b/tc/algorithm/empty.h
index c066d77..fd59ae4 100644
--- a/tc/algorithm/empty.h
+++ b/tc/algorithm/empty.h
@@ -18,7 +18,7 @@ namespace tc {
 		template<typename Rng>
 		constexpr auto empty(Rng&& rng) noexcept {
 			if constexpr(has_constexpr_size<Rng>) {
-				return [&]() return_decltype_noexcept(0==constexpr_size<Rng>::value);
+				return [&]() return_decltype_noexcept(0==constexpr_size<Rng>());
 			} else if constexpr(has_mem_fn_empty<Rng>) {
 				return [&]() return_MAYTHROW(tc_move_if_owned(rng).empty());
 			} else if constexpr(tc::range_with_iterators<Rng>) {
diff --git a/tc/algorithm/equal.t.cpp b/tc/algorithm/equal.t.cpp
index 60995b4..63ff8e1 100644
--- a/tc/algorithm/equal.t.cpp
+++ b/tc/algorithm/equal.t.cpp
@@ -38,7 +38,7 @@ UNITTESTDEF( equal_vec_int_pred ) {
 	TEST_init_hack(tc::vector, int, v123, {1,2,3});
 	TEST_init_hack(tc::vector, int, v234, {2,3,4});
 
-	auto ofByOne = [](int lhs, int rhs) noexcept { return (lhs + 1) == rhs; }; // unsymmetrical to uncover wrong order of argument application to the predicate
+	auto const ofByOne = [](int const lhs, int const rhs) noexcept { return (lhs + 1) == rhs; }; // unsymmetrical to uncover wrong order of argument application to the predicate
 
 	_ASSERT(tc::equal(v123, v234, ofByOne));
 	_ASSERT(!tc::equal(v234, v123, ofByOne));
@@ -89,7 +89,7 @@ UNITTESTDEF( equal_generator_pred ) {
 	auto g123 = tc::make_generator_range(v123);
 	auto g234 = tc::make_generator_range(v234);
 
-	auto ofByOne = [](int lhs, int rhs) noexcept { return (lhs + 1) == rhs; };  // unsymmetrical to uncover wrong order of argument application to the predicate
+	auto const ofByOne = [](int const lhs, int const rhs) noexcept { return (lhs + 1) == rhs; };  // unsymmetrical to uncover wrong order of argument application to the predicate
 
 	//_ASSERT(tc::equal(g123, g234, ofByOne)); // Fails to compile with proper msg, as it should be.
 
diff --git a/tc/algorithm/filter_inplace.h b/tc/algorithm/filter_inplace.h
index c3d95f9..c142adb 100644
--- a/tc/algorithm/filter_inplace.h
+++ b/tc/algorithm/filter_inplace.h
@@ -10,7 +10,7 @@
 
 #include "../base/assert_defs.h"
 #include "../range/meta.h"
-#include "../range/subrange.h"
+#include "../range/range_return.h"
 #include "../container/container_traits.h"
 #include "../storage_for.h"
 #include "restrict_size_decrement.h"
@@ -31,12 +31,10 @@ namespace tc {
 		has_mem_fn_hash_function<Cont>
 	struct range_filter<Cont> : tc::noncopyable {
 		static_assert(tc::decayed<Cont>);
-		using iterator = tc::iterator_t<Cont>;
-		using const_iterator = iterator; // no deep constness (analog to subrange)
 
 	private:
 		Cont& m_cont;
-		iterator m_itOutputEnd;
+		tc::iterator_t<Cont> m_itOutputEnd;
 
 	public:
 		explicit constexpr range_filter(Cont& cont) noexcept
@@ -44,7 +42,7 @@ namespace tc {
 			, m_itOutputEnd(tc::begin(cont))
 		{}
 
-		constexpr range_filter(Cont& cont, iterator const& itStart) noexcept
+		constexpr range_filter(Cont& cont, tc::iterator_t<Cont> const& itStart) noexcept
 			: m_cont(cont)
 			, m_itOutputEnd(itStart)
 		{}
@@ -53,7 +51,7 @@ namespace tc {
 			tc::take_inplace(m_cont, m_itOutputEnd);
 		}
 
-		constexpr void keep(iterator it) & noexcept {
+		constexpr void keep(tc::iterator_t<Cont> it) & noexcept {
 #ifdef _CHECKS
 			auto const nDistance = std::distance(m_itOutputEnd, it);
 			_ASSERTE( 0<=nDistance );
@@ -67,11 +65,11 @@ namespace tc {
 		// range interface for output range
 		// no deep constness (analog to subrange)
 
-		constexpr iterator begin() const& noexcept {
-			return tc::begin(tc::as_mutable(m_cont));
+		constexpr auto begin() const& noexcept {
+			return tc::begin(m_cont);
 		}
 
-		constexpr iterator end() const& noexcept {
+		constexpr auto end() const& noexcept {
 			return m_itOutputEnd;
 		}
 
@@ -83,58 +81,16 @@ namespace tc {
 		}
 	};
 
-	template<has_mem_fn_splice_after Cont>
-	struct range_filter<Cont> : Cont, private tc::noncopyable {
-		static_assert(tc::dependent_false<Cont>::value, "Careful: currently unused and without unit test");
-
-		static_assert(tc::decayed<Cont>);
-		using typename Cont::iterator;
-		using const_iterator = iterator; // no deep constness (analog to subrange)
-
-	private:
-		Cont& m_contInput;
-		iterator m_itLastOutput;
-
-	public:
-		explicit constexpr range_filter(Cont& cont) noexcept
-			: m_contInput(cont)
-			, m_itLastOutput(cont.before_begin())
-		{}
-
-		explicit constexpr range_filter(Cont& cont, iterator const& itStart) noexcept
-			: range_filter(cont)
-		{
-			for(;;) {
-				auto it=tc::begin(m_contInput);
-				if( it==itStart ) break;
-				this->splice_after(m_itLastOutput,m_contInput.before_begin());
-				m_itLastOutput=it;
-			}
-		}
-
-		constexpr ~range_filter() {
-			m_contInput=tc_move_always( tc::base_cast<Cont>(*this) );
-		}
-
-		constexpr void keep(iterator it) & noexcept {
-			while( it!=tc::begin(m_contInput) ) m_contInput.pop_front();
-			this->splice_after(m_itLastOutput,m_contInput.before_begin());
-			m_itLastOutput=it;
-		}
-	};
-
 	template<has_mem_fn_splice Cont>
 	struct range_filter<Cont> : Cont, private tc::noncopyable {
 		static_assert(tc::decayed<Cont>);
 		Cont& m_contInput;
-		using typename Cont::iterator;
-		using const_iterator = iterator; // no deep constness (analog to subrange)
 
 		explicit constexpr range_filter(Cont& cont) noexcept
 			: m_contInput(cont)
 		{}
 
-		constexpr range_filter(Cont& cont, iterator const& itStart) noexcept
+		constexpr range_filter(Cont& cont, tc::iterator_t<Cont> const& itStart) noexcept
 			: m_contInput(cont)
 		{
 			this->splice( tc::end(*this), m_contInput, tc::begin(m_contInput), itStart );
@@ -144,7 +100,7 @@ namespace tc {
 			m_contInput=tc_move_always( tc::base_cast<Cont>(*this) );
 		}
 
-		constexpr void keep(iterator it) & noexcept {
+		constexpr void keep(tc::iterator_t<Cont> it) & noexcept {
 			_ASSERTE( it!=tc::end(m_contInput) );
 			this->splice( 
 				tc::end(*this),
@@ -157,16 +113,14 @@ namespace tc {
 	template<typename Cont> requires range_filter_by_move_element<Cont>::value
 	struct range_filter<Cont> : tc::noncopyable {
 		static_assert(tc::decayed<Cont>);
-		using iterator = tc::iterator_t<Cont>;
-		using const_iterator = iterator; // no deep constness (analog to subrange)
 
 	protected:
 		Cont& m_cont;
-		iterator m_itOutput;
+		tc::iterator_t<Cont> m_itOutput;
 
 	private:
 #ifdef _CHECKS
-		iterator m_itFirstValid;
+		tc::iterator_t<Cont> m_itFirstValid;
 #endif
 
 	public:
@@ -178,7 +132,7 @@ namespace tc {
 #endif
 		{}
 
-		explicit constexpr range_filter(Cont& cont, iterator itStart) noexcept
+		explicit constexpr range_filter(Cont& cont, tc::iterator_t<Cont> itStart) noexcept
 			: m_cont(cont)
 			, m_itOutput(itStart)
 #ifdef _CHECKS
@@ -190,7 +144,7 @@ namespace tc {
 			tc::take_inplace( m_cont, m_itOutput );
 		}
 
-		constexpr void keep(iterator it) & noexcept {
+		constexpr void keep(tc::iterator_t<Cont> it) & noexcept {
 #ifdef _CHECKS
 			// Filter without reordering 
 			_ASSERTE( 0<=std::distance(m_itFirstValid, it) );
@@ -207,11 +161,11 @@ namespace tc {
 		// range interface for output range
 		// no deep constness (analog to subrange)
 
-		constexpr iterator begin() const& noexcept {
-			return tc::begin(tc::as_mutable(m_cont));
+		constexpr auto begin() const& noexcept {
+			return tc::begin(m_cont);
 		}
 
-		constexpr iterator end() const& noexcept {
+		constexpr auto end() const& noexcept {
 			return m_itOutput;
 		}
 
@@ -228,48 +182,6 @@ namespace tc {
 		}
 	};
 
-	template<typename Cont> requires range_filter_by_move_element<Cont>::value
-	struct range_filter<tc::subrange<Cont&>> {
-		using iterator = tc::iterator_t<Cont>;
-		using const_iterator = iterator; // no deep constness (analog to subrange)
-
-		explicit constexpr range_filter(tc::subrange< Cont& >& rng) noexcept : m_rng(rng) {
-			_ASSERTE(tc::end(m_rng) == tc::end(Container())); // otherwise, we would need to keep [ end(m_rng), end(Container()) ) inside dtor
-			m_orngfilter.ctor(Container(), tc::begin(rng));
-		}
-
-		constexpr void keep(iterator it) & noexcept {
-			m_orngfilter->keep(it);
-		}
-
-		constexpr iterator begin() const& noexcept {
-			return tc::begin(m_rng);
-		}
-
-		constexpr iterator end() const& noexcept {
-			return tc::end(*m_orngfilter);
-		}
-
-		constexpr void pop_back() & noexcept {
-			_ASSERTE(tc::end(*this) != tc::begin(*this));
-			m_orngfilter->pop_back();
-		}
-
-		constexpr ~range_filter() {
-			auto& cont = Container();
-			auto const nIndexBegin = tc::begin(m_rng) - tc::begin(cont);
-			m_orngfilter.dtor(); // erases cont tail and invalidates iterators in m_rng
-			m_rng = tc::begin_next<tc::return_drop>(cont, nIndexBegin);
-		}
-
-		constexpr Cont& Container() const& noexcept {
-			return tc::implicit_cast<Cont&>(m_rng.base_range());
-		}
-
-		tc::subrange< Cont& >& m_rng;
-		tc::storage_for< tc::range_filter<Cont> > m_orngfilter;
-	};
-
 	/////////////////////////////////////////////////////
 	// filter_inplace
 
diff --git a/tc/algorithm/find.h b/tc/algorithm/find.h
index bb6f37c..31dab1e 100644
--- a/tc/algorithm/find.h
+++ b/tc/algorithm/find.h
@@ -12,6 +12,7 @@
 #include "../range/meta.h"
 #include "../range/iterator_cache.h"
 #include "../base/scope.h"
+#include "../base/trivial_functors.h"
 #include "../storage_for.h"
 
 #include "equal.h"
diff --git a/tc/algorithm/find_closest_if.h b/tc/algorithm/find_closest_if.h
index 6e7a00b..985f88f 100644
--- a/tc/algorithm/find_closest_if.h
+++ b/tc/algorithm/find_closest_if.h
@@ -34,7 +34,7 @@ namespace tc {
 				return tc::constant<tc::continue_>();
 			}
 			if (tc::back(aitLimit) == tc::back(ait)) {
-				for (; tc::front(ait) != tc::front(aitLimit); ) {
+				while (tc::front(ait) != tc::front(aitLimit)) {
 					--tc::front(ait);
 					tc_yield(func, tc::begin_next<tc::return_take>(tc::as_const(ait)));
 				}
@@ -48,7 +48,7 @@ namespace tc {
 
 
 	template < typename RangeReturn, typename Rng, typename It, typename Pred = tc::identity>
-	[[nodiscard]] constexpr decltype(auto) find_closest_if(Rng&& rng, It it, bool bSkipSelf, Pred pred = Pred()) noexcept {
+	[[nodiscard]] constexpr decltype(auto) find_closest_if(Rng&& rng, It it, bool const bSkipSelf, Pred pred = Pred()) noexcept {
 		tc::storage_for<tc::iterator_cache<It>> oitc;
 		if (tc::break_ == tc::for_each_iterator_pair_outwards(rng, tc_move(it), bSkipSelf, [&](auto const& rngit) noexcept {
 			return tc::for_each(rngit, [&](auto const& it) noexcept {
@@ -66,7 +66,7 @@ namespace tc {
 	}
 
 	template < typename RangeReturn, typename Rng, typename Index, typename Pred = tc::identity>
-	[[nodiscard]] decltype(auto) find_closest_if_with_index(Rng&& rng, Index&& n, bool bSkipSelf, Pred&& pred = Pred()) noexcept {
+	[[nodiscard]] decltype(auto) find_closest_if_with_index(Rng&& rng, Index&& n, bool const bSkipSelf, Pred&& pred = Pred()) noexcept {
 		return find_closest_if<RangeReturn>(std::forward<Rng>(rng), tc::begin_next<tc::return_border>(rng, std::forward<Index>(n)), bSkipSelf, std::forward<Pred>(pred));
 	}
 }
diff --git a/tc/algorithm/find_closest_if.t.cpp b/tc/algorithm/find_closest_if.t.cpp
index bc0b562..1ddfa73 100644
--- a/tc/algorithm/find_closest_if.t.cpp
+++ b/tc/algorithm/find_closest_if.t.cpp
@@ -12,7 +12,7 @@
 UNITTESTDEF(find_closest_if) {
 	struct IntCompareOnce final : boost::noncopyable {
 		IntCompareOnce(int n) noexcept :m_n(n) { }
-		bool operator==(int n) const& noexcept {
+		bool operator==(int const n) const& noexcept {
 			_ASSERT( tc::change(m_bCompared, true) );
 			return m_n==n;
 		}
@@ -21,7 +21,7 @@ UNITTESTDEF(find_closest_if) {
 		bool mutable m_bCompared = false;
 	};
 
-	auto find=[](auto const& rngn, int iStart, int nTarget, int nComparisonsMax) noexcept {
+	auto find=[](auto const& rngn, int const iStart, int const nTarget, int const nComparisonsMax) noexcept {
 		int nComparisons = 0;
 		return tc::find_closest_if_with_index<tc::return_element_index_or_npos>(rngn, iStart, /*bSkipSelf*/false, [&](IntCompareOnce const& n) noexcept {
 			_ASSERT(++nComparisons<=nComparisonsMax);
diff --git a/tc/algorithm/for_each.h b/tc/algorithm/for_each.h
index 6059d40..ef5a2db 100644
--- a/tc/algorithm/for_each.h
+++ b/tc/algorithm/for_each.h
@@ -270,7 +270,7 @@ namespace tc {
 		)
 
 		template<typename Tuple, typename Sink,
-			std::enable_if_t<tc::instance_or_derived<Tuple, std::tuple>>* = nullptr,
+			std::enable_if_t<tc::instance_or_derived<std::remove_reference_t<Tuple>, std::tuple>>* = nullptr,
 			typename IndexList = typename for_each_detail::integer_sequence_to_type_list<std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>>::type
 		>
 		constexpr auto for_each_impl(adl_tag_t, Tuple&& tuple, Sink&& sink) return_decltype_MAYTHROW(
@@ -300,7 +300,7 @@ namespace tc {
 		template<template<typename...> typename TupleT, typename Tuple>
 		using type = tc::type::unique_t<tc::type::transform_t<
 			tc::type::transform_t<
-				typename tc::is_instance_or_derived<Tuple, TupleT>::arguments,
+				typename tc::is_instance_or_derived<std::remove_reference_t<Tuple>, TupleT>::arguments,
 				tc::type::rcurry<tc::apply_cvref_t, Tuple>::template type
 			>,
 			tc::remove_rvalue_reference_t
diff --git a/tc/algorithm/for_each.t.cpp b/tc/algorithm/for_each.t.cpp
index d2d9608..cc9f74b 100644
--- a/tc/algorithm/for_each.t.cpp
+++ b/tc/algorithm/for_each.t.cpp
@@ -57,7 +57,7 @@ namespace {
 			mock_reset();
 		}
 
-		void mock_reset(tc::vector<int> const& v = tc::vector<int>(), std::size_t break_at = 0, bool expect_break = true) & noexcept {
+		void mock_reset(tc::vector<int> const& v = tc::vector<int>(), std::size_t const break_at = 0, bool expect_break = true) & noexcept {
 			if(!m_copyed_or_moved_from && !(m_index == tc::min(m_expect.size(), (m_expect_break) ? m_break_at + 1 : m_expect.size()))) {
 				TEST_OUTPUT( << "unexpectedly terminated before index " << m_index
 							 << " went to the expected index " << tc::min(m_expect.size(), m_break_at + 1) << '\n');
@@ -70,7 +70,7 @@ namespace {
 			m_copyed_or_moved_from = false;
 		}
 
-		tc::break_or_continue operator()(int val) const& noexcept {
+		tc::break_or_continue operator()(int const val) const& noexcept {
 			if (m_copyed_or_moved_from) {
 				TEST_OUTPUT(<< "used copyed or moved consumer for real work!\n");
 			}
@@ -98,7 +98,7 @@ namespace {
 
 	all_called_mock g_mock;
 
-	void foo(int i) noexcept { g_mock(i); }
+	void foo(int const i) noexcept { g_mock(i); }
 
 //-----------------------------------------------------------------------------------------------------------------------------
 UNITTESTDEF( for_each ) {
@@ -126,8 +126,8 @@ UNITTESTDEF( for_each ) {
 	//g_mock.mock_reset(exp); tc::for_each(gv, &foo);
 
 	// call with lambda
-	g_mock.mock_reset(exp); tc::for_each(v, [](int i) noexcept { g_mock(i); });
-	g_mock.mock_reset(exp); tc::for_each(gv, [](int i) noexcept { g_mock(i); });
+	g_mock.mock_reset(exp); tc::for_each(v, [](int const i) noexcept { g_mock(i); });
+	g_mock.mock_reset(exp); tc::for_each(gv, [](int const i) noexcept { g_mock(i); });
 
 	// Todo: call with mem func, std::function and bind
 }
@@ -174,7 +174,7 @@ UNITTESTDEF( for_each ) {
 	struct consumer_break /*final*/ {
 		consumer_break(tc::vector<int> const& v, std::size_t break_at = 0, bool expect_break = true) noexcept : m_mock(v, break_at, expect_break) {}
 
-		tc::break_or_continue operator()(int i) const& noexcept { return m_mock(i); }
+		tc::break_or_continue operator()(int const i) const& noexcept { return m_mock(i); }
 		private:
 			all_called_mock m_mock;
 	};
@@ -183,7 +183,7 @@ UNITTESTDEF( for_each ) {
 		consumer_nobreak(tc::vector<int> const& v, std::size_t break_at = 0, bool expect_break = true) noexcept : m_mock(v, break_at, expect_break) {}
 		~consumer_nobreak() {}
 
-		void operator()(int i) const& noexcept { m_mock(i); }
+		void operator()(int const i) const& noexcept { m_mock(i); }
 
 		private:
 			all_called_mock m_mock;
@@ -230,7 +230,7 @@ UNITTESTDEF(for_each_adjacent_tuple_deref) {
 
 	TEST_RANGE_EQUAL(
 		vecn,
-		as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,2,1))
+		tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,2,1))
 	);
 
 	int nTransforms = 0;
@@ -238,7 +238,7 @@ UNITTESTDEF(for_each_adjacent_tuple_deref) {
 		tc::adjacent<3>(
 			tc::transform(
 				vecn,
-				[&](int n) noexcept {++nTransforms; return n;}
+				[&](int const n) noexcept {++nTransforms; return n;}
 			)
 		),
 		[](int n0, int n1, int n2) noexcept {
@@ -256,19 +256,19 @@ UNITTESTDEF(for_each_adjacent_tuple_deref) {
 			std::ref(overloads)
 		);
 
-		TEST_RANGE_EQUAL(overloads.m_n, as_constexpr(tc::make_array(tc::aggregate_tag, 3,0,0)));
+		TEST_RANGE_EQUAL(overloads.m_n, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 3,0,0)));
 	}
 
 	{
 		lr_overloads overloads;
 		tc::for_each(
 			tc::adjacent<3>(
-				tc::transform(vecn, [](int n) noexcept {return n;})
+				tc::transform(vecn, [](int const n) noexcept {return n;})
 			),
 			std::ref(overloads)
 		);
 
-		TEST_RANGE_EQUAL(overloads.m_n, as_constexpr(tc::make_array(tc::aggregate_tag, 0,2,1)));
+		TEST_RANGE_EQUAL(overloads.m_n, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 0,2,1)));
 	}
 }
 
diff --git a/tc/algorithm/interleave_ranges.h b/tc/algorithm/interleave_ranges.h
index 5d0b0dc..7b8e428 100644
--- a/tc/algorithm/interleave_ranges.h
+++ b/tc/algorithm/interleave_ranges.h
@@ -29,7 +29,7 @@ namespace tc {
 		template<typename RngRng>
 		struct SIteratorView<RngRng, false> : std::conditional_t<std::is_lvalue_reference<RangeView<RngRng>>::value, tc::copyable, tc::noncopyable>
 		{
-			static_assert( tc::is_index_valid_for_move_constructed_range<RangeView<RngRng>>::value );
+			static_assert( tc::stable_index_on_move<RangeView<RngRng>> );
 
 			explicit SIteratorView(tc::iterator_t<RngRng const&> const& itrng) noexcept
 				: m_rng(tc::aggregate_tag, *itrng)
@@ -69,6 +69,9 @@ namespace tc {
 			std::size_t m_nLast;
 
 			static_assert(!tc::is_stashing_element<tc::iterator_t<RngRng const&>>::value || std::is_copy_constructible<tc::iterator_t<RngRng const&>>::value);
+
+			interleave_ranges_index(tc::empty_range) noexcept
+				: m_nLast(0) {}
 			interleave_ranges_index(RngRng const& rng) noexcept
 				: tc_member_init_cast(m_vecview, tc::filter(
 					tc::make_range_of_iterators(rng),
@@ -124,7 +127,7 @@ namespace tc {
 			}
 
 			STATIC_FINAL_MOD(constexpr, end_index)() const& noexcept -> tc_index {
-				return {tc::empty_range(), 0};
+				return tc::empty_range();
 			}
 
 			STATIC_FINAL_MOD(constexpr, at_end_index)(tc_index const& idx) const& noexcept -> bool {
diff --git a/tc/algorithm/longest_common_prefix.t.cpp b/tc/algorithm/longest_common_prefix.t.cpp
index c0af0a2..2d9b721 100644
--- a/tc/algorithm/longest_common_prefix.t.cpp
+++ b/tc/algorithm/longest_common_prefix.t.cpp
@@ -11,7 +11,7 @@
 
 namespace {
 UNITTESTDEF( longest_common_prefix ) {
-	auto CheckLCP = [](auto const& strLhs, auto const& strRhs, auto const& strPrefix, auto const& strSuffixLhs, auto const& strSuffixRhs) noexcept {
+	auto const CheckLCP = [](auto const& strLhs, auto const& strRhs, auto const& strPrefix, auto const& strSuffixLhs, auto const& strSuffixRhs) noexcept {
 		tc_auto_cref(pairstrstrPrefix, tc::longest_common_prefix<tc::return_take>(strLhs, strRhs));
 		_ASSERT(tc::equal(pairstrstrPrefix.first, pairstrstrPrefix.second));
 		_ASSERT(tc::equal(pairstrstrPrefix.first, strPrefix));
diff --git a/tc/algorithm/minmax.h b/tc/algorithm/minmax.h
index d81696c..625e28e 100644
--- a/tc/algorithm/minmax.h
+++ b/tc/algorithm/minmax.h
@@ -43,7 +43,7 @@ namespace tc {
 					return operator()(std::forward<T0>(t0), std::forward<Args>(args)...);
 				} else {
 					STATICASSERTSAME(decltype(b), bool);
-					return CONDITIONAL_PRVALUE_AS_VAL(
+					return tc_conditional_prvalue_as_val(
 						b,
 						/*t1 is better*/operator()(std::forward<T1>(t1), std::forward<Args>(args)...),
 						/*t0 is better or equal*/operator()(std::forward<T0>(t0), std::forward<Args>(args)...)
diff --git a/tc/algorithm/partition_iterator.h b/tc/algorithm/partition_iterator.h
index c461a19..ca98a3f 100644
--- a/tc/algorithm/partition_iterator.h
+++ b/tc/algorithm/partition_iterator.h
@@ -30,7 +30,7 @@ namespace tc {
 
 		namespace adl {
 			// default forward iterator implementation
-			template<typename It>
+			template<typename It> requires true // to make it more constrained than tc::iterator::middle_point
 			It 
 			middle_point( It const& itBegin, It const& itEnd ) noexcept {
 				// SEnumerateGapConstraints::SEnumerateGapConstraints calls intersect on transforms of counting ranges of tree iterators
diff --git a/tc/algorithm/partition_range.h b/tc/algorithm/partition_range.h
index b9c4d99..5f5e10a 100644
--- a/tc/algorithm/partition_range.h
+++ b/tc/algorithm/partition_range.h
@@ -90,6 +90,23 @@ namespace tc {
 				pred
 			);
 		}
+
+		template<typename Rng, typename Value>
+		[[nodiscard]] decltype(auto) contains_exclusive_range(Rng&& rng, tc::interval<Value> const& intvlval) noexcept {
+			return lower_bound<tc::return_take>(
+				upper_bound<tc::return_drop>(std::forward<Rng>(rng),intvlval[tc::lo]),
+				intvlval[tc::hi]
+			);
+		}
+
+		template<typename Rng, typename Value, typename SortPredicate>
+		[[nodiscard]] decltype(auto) contains_exclusive_range(Rng&& rng, tc::interval<Value> const& intvlval, SortPredicate&& pred) noexcept {
+			return lower_bound<tc::return_take>(
+				upper_bound<tc::return_drop>(std::forward<Rng>(rng),intvlval[tc::lo],pred),
+				intvlval[tc::hi],
+				pred
+			);
+		}
 	}
 	using namespace range;
 }
diff --git a/tc/algorithm/quantifier.h b/tc/algorithm/quantifier.h
index 72c72ad..7059384 100644
--- a/tc/algorithm/quantifier.h
+++ b/tc/algorithm/quantifier.h
@@ -9,8 +9,8 @@
 #pragma once
 
 #include "../base/invoke.h"
-#include "../range/range_fwd.h"
 #include "../range/transform_adaptor.h"
+#include "../variant.h"
 #include "for_each.h"
 #include "find.h"
 #include "compare.h"
@@ -36,7 +36,7 @@ template< typename Rng, typename Pred = tc::identity >
 template< typename Rng >
 [[nodiscard]] std::pair<bool,bool> all_any_of( Rng const& rng ) MAYTHROW {
 	std::pair<bool,bool> pairb(true,false);
-	tc::for_each(rng, [&](bool b) noexcept {
+	tc::for_each(rng, [&](bool const b) noexcept {
 		pairb.first=pairb.first && b;
 		pairb.second=pairb.second || b;
 		return continue_if( pairb.first || !pairb.second );
@@ -73,4 +73,114 @@ template< typename Rng, typename Pred >
 	return !tc::eager_any_of(std::forward<Rng>(rng), std::not_fn(std::forward<Pred>(pred)));
 }
 
+// all_same_element
+namespace all_same_result {
+	struct empty_t final {};
+	struct not_same_t final {};
+
+	template<typename T=void>
+	struct never_empty /*final*/ {
+		constexpr T operator()(empty_t) const& noexcept { _ASSERTFALSE; return tc::construct_default_or_terminate<T>(); }
+	};
+}
+
+namespace no_adl {
+	template<typename T, typename Equal=tc::fn_equal_to>
+	struct [[nodiscard]] accumulator_all_same final {
+		static_assert(tc::decayed<Equal>);
+
+		using result_type = std::variant<all_same_result::empty_t, T, all_same_result::not_same_t>;
+
+		constexpr accumulator_all_same() noexcept = default;
+		constexpr accumulator_all_same(auto&& equal) noexcept : m_equal(tc_move_if_owned(equal)) {}
+
+		template<typename U>
+		constexpr auto operator()(U&& u) & MAYTHROW {
+			if constexpr( std::is_same<accumulator_all_same, tc::decay_t<U>>::value ) {
+				return tc::fn_visit(
+					[&](all_same_result::empty_t) noexcept {
+						return tc::continue_if(!std::holds_alternative<all_same_result::not_same_t>(m_result));
+					},
+					[&](auto&& t) MAYTHROW {
+						return operator()(tc_move_if_owned(t)); // MAYTHROW
+					},
+					[&](all_same_result::not_same_t) noexcept {
+						m_result=all_same_result::not_same_t();
+						return tc::break_;
+					}
+				)(std::forward<U>(u).m_result_());
+			} else {
+				return tc::fn_visit(
+					[&](all_same_result::empty_t) MAYTHROW {
+						m_result=std::forward<U>(u); // MAYTHROW
+						return tc::continue_;
+					},
+					[&](T const& t) noexcept {
+						if(m_equal(t, tc::as_const(u))) {
+							return tc::continue_;
+						} else {
+							m_result=all_same_result::not_same_t();
+							return tc::break_;
+						}
+					},
+					[](all_same_result::not_same_t) noexcept {
+						return tc::break_;
+					}
+				)(m_result);
+			}
+		}
+
+	private:
+		PRIVATE_MEMBER_PUBLIC_ACCESSOR(result_type, m_result)
+		Equal m_equal;
+	};
+
+	struct return_all_same_result;
+
+	template<typename RangeReturn, typename Rng, typename Equal>
+	struct all_same_element_impl;
+
+	template<typename Rng, typename Equal>
+	struct all_same_element_impl<return_all_same_result, Rng, Equal> final {
+		static constexpr auto fn(Rng&& rng, Equal&& equal) MAYTHROW {
+			accumulator_all_same<tc::range_value_t<Rng>, tc::decay_t<Equal>> accu(std::forward<Equal>(equal));
+			tc::for_each(std::forward<Rng>(rng), std::ref(accu));
+			return accu.m_result_();
+		}
+	};
+
+	template<typename RangeReturn, typename Rng, typename Equal>
+	struct all_same_element_impl final {
+		static constexpr decltype(auto) fn(Rng&& rng, Equal&& equal) MAYTHROW {
+			// TODO: For RangeReturn return_value, without _CHECKS, the algorithm should not loop but compute the result in O(1) time.
+			return tc::fn_visit(
+				[](auto&& t) noexcept -> decltype(auto) {
+					return RangeReturn::template pack_element<Rng>(tc_move_if_owned(t));
+				},
+				[](tc::all_same_result::empty_t) noexcept -> decltype(auto) {
+					return RangeReturn::template pack_no_element<Rng>();
+				},
+				[](tc::all_same_result::not_same_t) noexcept -> decltype(auto) {
+					return RangeReturn::template pack_no_element<Rng>();
+				}
+			)(all_same_element_impl<return_all_same_result, Rng, Equal>::fn(std::forward<Rng>(rng), std::forward<Equal>(equal)) /*MAYTHROW*/);
+		}
+	};
+}
+using no_adl::accumulator_all_same;
+using no_adl::return_all_same_result;
+
+template<typename RangeReturn, typename Rng, typename Equal = tc::fn_equal_to >
+[[nodiscard]] constexpr decltype(auto) all_same_element(Rng&& rng, Equal&& equal = Equal()) MAYTHROW {
+	return no_adl::all_same_element_impl<RangeReturn, Rng, Equal>::fn(std::forward<Rng>(rng), std::forward<Equal>(equal));
+}
+
+template< typename Rng, typename Equal = tc::fn_equal_to >
+[[nodiscard]] constexpr bool all_same(Rng&& rng, Equal&& equal = Equal()) noexcept {
+	return tc::fn_visit(
+		[](auto&&) noexcept { return true; },
+		[](tc::all_same_result::empty_t) noexcept { return true; },
+		[](tc::all_same_result::not_same_t) noexcept { return false; }
+	)(tc::all_same_element<tc::return_all_same_result>(std::forward<Rng>(rng), std::forward<Equal>(equal)));
+}
 }
diff --git a/tc/algorithm/quantifier.t.cpp b/tc/algorithm/quantifier.t.cpp
new file mode 100644
index 0000000..b15ae03
--- /dev/null
+++ b/tc/algorithm/quantifier.t.cpp
@@ -0,0 +1,55 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "../base/assert_defs.h"
+#include "../container/container.h" // tc::vector
+#include "../unittest.h"
+#include "quantifier.h"
+
+UNITTESTDEF( quantifiers ) {
+
+	tc::vector<int> v{1,2,3,4,5,6,7};
+
+	tc::vector<int> all_even{2,4,6,8};
+	tc::vector<int> all_odd{3,5,7,9};
+
+	auto const even = [](int const i) noexcept { return i%2==0; };
+
+	int const existing_value = 5;
+	int const non_existing_value = 9;
+
+	auto const_range = tc::all(tc::as_const(v)); TEST_RANGE_LENGTH(const_range, 7);
+
+	_ASSERT( tc::find_first<tc::return_bool>(const_range, existing_value));
+	_ASSERT(!tc::find_first<tc::return_bool>(const_range, non_existing_value));
+
+	_ASSERT(! tc::all_of(const_range, even));
+	_ASSERT(  tc::any_of(const_range, even));
+
+	_ASSERT(  tc::all_of(all_even, even));
+	_ASSERT(  tc::any_of(all_even, even));
+
+	_ASSERT(! tc::all_of(all_odd, even));
+	_ASSERT(! tc::any_of(all_odd, even));
+}
+
+UNITTESTDEF( all_same ) {
+	tc::vector<int> const v_empty{};
+	tc::vector<int> const v_same{1, 1, 1, 1, 1};
+	tc::vector<int> const v_different{1, 1, 2, 1, 1};
+
+	_ASSERT(tc::all_same(v_empty));
+	_ASSERT(!tc::all_same_element<tc::return_bool>(v_empty));
+
+	_ASSERT(tc::all_same(v_same));
+	_ASSERT(tc::all_same_element<tc::return_bool>(v_same));
+	_ASSERTEQUAL(tc::all_same_element<tc::return_value>(v_same), 1);
+
+	_ASSERT(!tc::all_same(v_different));
+	_ASSERT(!tc::all_same_element<tc::return_bool>(v_different));
+}
diff --git a/tc/algorithm/round.h b/tc/algorithm/round.h
index 899a774..590ede5 100644
--- a/tc/algorithm/round.h
+++ b/tc/algorithm/round.h
@@ -74,7 +74,7 @@ namespace tc {
 #ifdef __clang__
 		__attribute__((optnone)) // Disable compiler optimization num/den ---> num*(1/den) resulting in tc::fdiv(49,49)==0.99999999999999989
 #endif
-	double fdiv(double num, double den) noexcept {
+	double fdiv(double const num, double const den) noexcept {
 		return num/den;
 	}
 #ifdef _MSC_VER
@@ -165,6 +165,9 @@ namespace tc {
 	struct SRoundBanker final {
 	} inline constexpr roundBANKER{};
 
+	struct SNoRounding final {
+	} inline constexpr norounding{};
+
 	namespace idiv_impl {
 		// The standard guarantees that integer division rounds to zero.
 		// [expr.mul]/4 (oder 5.6/4) 
@@ -174,7 +177,7 @@ namespace tc {
 			static_assert( tc::actual_integer_like< Denom > );
 			STATICASSERTEQUAL( std::numeric_limits<Num>::is_signed, std::numeric_limits<Denom>::is_signed );
 			_ASSERTE( 0<denom );
-			if constexpr( std::is_same<Round, SRoundBanker>::value ) {
+			if constexpr(std::same_as<Round, SRoundBanker>) {
 				auto result = num / denom;
 				auto remainder = num - result * denom;
 				if(remainder<0) -tc::inplace(remainder);
@@ -182,6 +185,9 @@ namespace tc {
 					result += num < 0 ? -1 : 1;
 				}
 				tc_return_cast(result);
+			} else if constexpr(std::same_as<Round, SNoRounding>) {
+				_ASSERTEQUAL(num%denom, 0);
+				tc_return_cast(num/denom);
 			} else {
 				tc_return_cast( ( num<0 ? num-Round::NegativeOffset(denom) : num+Round::PositiveOffset(denom) )/denom );
 			}
diff --git a/tc/algorithm/size.h b/tc/algorithm/size.h
index ee26ff7..55bc12a 100644
--- a/tc/algorithm/size.h
+++ b/tc/algorithm/size.h
@@ -15,8 +15,7 @@
 #include "../base/generic_macros.h"
 #include "../base/tag_type.h"
 #include "../container/container_traits.h"
-
-#include <boost/range/traversal.hpp>
+#include "../range/meta.h"
 
 #include <limits>
 
@@ -164,16 +163,6 @@ namespace tc {
 		}
 	}
 
-	namespace detail {
-		template<typename Rng, typename Required>
-		concept has_traversal = tc::range_with_iterators<Rng> && std::convertible_to<typename boost::range_traversal<Rng>::type, Required>;
-	}
-
-	template<typename Rng>
-	concept bidirectional_range = detail::has_traversal<Rng, boost::iterators::bidirectional_traversal_tag>;
-	template<typename Rng>
-	concept random_access_range = detail::has_traversal<Rng, boost::iterators::random_access_traversal_tag>;
-
 	template< typename T >
 	[[nodiscard]] constexpr auto make_size_proxy(T t) noexcept {
 		if constexpr( tc::actual_integer<T> ) {
@@ -215,6 +204,32 @@ namespace tc {
 		struct common_type_decayed<T0, tc::size_proxy<T1>> : tc::common_type_decayed<tc::size_proxy<T1>, T0> {};
 	}
 
+	////////////////////////////////
+	// tc::constexpr_size
+	namespace no_adl {
+		template<typename Rng>
+		struct constexpr_size_impl;
+
+		// Rng has a size function that returns an integral_constant.
+		template <typename Rng> requires requires { decltype(std::declval<Rng&>().size())::value; }
+		struct constexpr_size_impl<Rng> : decltype(std::declval<Rng&>().size()) {};
+
+		template<typename T, std::size_t N>
+		struct constexpr_size_impl<T[N]> : tc::least_uint_constant<N - (tc::char_type<T> ? 1 : 0)> {};
+
+		template<typename T, T... t>
+		struct constexpr_size_impl<std::integer_sequence<T, t...>> : tc::least_uint_constant<sizeof...(t)> {};
+	}
+
+	template <typename Rng> requires has_constexpr_size<Rng>
+	constexpr auto constexpr_size = []() noexcept {
+		using type = no_adl::constexpr_size_impl<std::remove_cvref_t<Rng>>;
+		static_assert(std::derived_from<type, tc::least_uint_constant<type::value>>);
+		return tc::least_uint_constant<type::value>{};
+	}();
+
+	////////////////////////////////
+	// tc::size
 	namespace size_raw_internal {
 		// tc::size() requires a range with either:
 		//  - a constexpr_size_impl specialization which provide size as a compile time constant
@@ -225,7 +240,7 @@ namespace tc {
 			has_constexpr_size<Rng> || has_mem_fn_size<Rng> || (random_access_range<Rng&> && tc::common_range<Rng>)
 		constexpr auto size_raw(Rng&& rng) noexcept {
 			if constexpr( has_constexpr_size<Rng> ) {
-				return [&]() return_decltype_noexcept(constexpr_size<Rng>::value);
+				return [&]() return_decltype_noexcept(constexpr_size<Rng>());
 			} else if constexpr( has_mem_fn_size<Rng> ) {
 				return [&]() return_MAYTHROW(tc_move_if_owned(rng).size()); // .size() may throw for files
 			} else {
@@ -242,6 +257,7 @@ namespace tc {
 		size_raw_internal::size_raw(tc_move_if_owned(rng))()
 	)
 
+	// Note: This overload is only necessary for the assertion - the size is otherwise computed the same by constexpr_size.
 	template<tc::char_type T, std::size_t N>
 	[[nodiscard]] constexpr auto size_raw(T const (&ach)[N]) noexcept {
 		_ASSERTE(tc::strlen(ach)==N-1); // VERIFYEQUAL is not constexpr
@@ -255,5 +271,16 @@ namespace tc {
 
 	TC_HAS_EXPR(size, (T), size_raw(std::declval<T>()))
 	DEFINE_FN2(tc::size_raw, fn_size_raw)
+
+	template <auto Fn, typename ... Rng>
+	[[nodiscard]] constexpr auto compute_range_adaptor_size(Rng&&... rng) MAYTHROW {
+		if constexpr ((tc::has_constexpr_size<Rng> && ...)) {
+			tc::actual_unsigned_integer auto constexpr value = Fn(tc::constexpr_size<Rng>()...);
+			return tc::least_uint_constant<value>{};
+		} else {
+			tc::actual_unsigned_integer auto const value = Fn(tc::size_raw(tc_move_if_owned(rng))...);
+			return value;
+		}
+	}
 }
 
diff --git a/tc/algorithm/size_bounded.h b/tc/algorithm/size_bounded.h
index 699b2c3..73e457a 100644
--- a/tc/algorithm/size_bounded.h
+++ b/tc/algorithm/size_bounded.h
@@ -15,6 +15,31 @@
 #include "for_each.h"
 
 namespace tc {
+	template< typename It, typename T, typename Sentinel >
+	T advance_forward_bounded(It&& it, T n, Sentinel&& itBound) noexcept {
+		_ASSERT(0 <= n);
+		if constexpr( std::convertible_to<
+			typename boost::iterator_traversal<std::remove_reference_t<It>>::type,
+			boost::iterators::random_access_traversal_tag
+		> && requires { itBound - it; } ) {
+			if (tc::assign_better(tc::fn_less_equal(), n, tc::make_size_proxy(itBound - it))) {
+				it = std::forward<Sentinel>(itBound);
+			} else {
+				it += n;
+			}
+			return n;
+		} else {
+			// size_proxy does not provide operator++ and the operation cannot fail here,
+			// because nCount is always inside interval [0,n].
+			auto nCount = tc::explicit_cast<decltype(tc::unmake_size_proxy(n))>(0);
+			while (nCount != n && it != itBound) {
+				++nCount;
+				++it;
+			}
+			tc_return_cast(nCount);
+		}
+	}
+
 	template< typename Rng, typename T>
 	[[nodiscard]] constexpr auto size_bounded(Rng const& rng, T const nBound) noexcept {
 		if constexpr( tc::has_size<Rng> ) {
@@ -24,7 +49,7 @@ namespace tc {
 		} else {
 			T n = 0;
 			if (0 < nBound) {
-				auto Enumerate = [&](tc::unused) noexcept { return tc::continue_if(nBound!=++n); };
+				auto const Enumerate = [&](tc::unused) noexcept { return tc::continue_if(nBound!=++n); };
 				STATICASSERTSAME(tc::break_or_continue, decltype(tc::for_each(rng, Enumerate)), "size_bounded only works with interruptible generators");
 				tc::for_each(rng, Enumerate);
 			}
diff --git a/tc/algorithm/sort_streaming.h b/tc/algorithm/sort_streaming.h
index e8aec1d..bce94d1 100644
--- a/tc/algorithm/sort_streaming.h
+++ b/tc/algorithm/sort_streaming.h
@@ -23,7 +23,7 @@ namespace tc {
 		// tc::back(cont) = std::forward<T>(t);
 		// std::ranges::push_heap(cont, less);
 		auto const n = tc::size_raw(cont);
-		auto IndexAndIterator = [&](decltype(n) i) noexcept {
+		auto const IndexAndIterator = [&](decltype(n) i) noexcept {
 			return tc::make_tuple(i, tc::at<tc::return_element>(cont, i));
 		};
 		auto nitHole = IndexAndIterator(0);
diff --git a/tc/array.h b/tc/array.h
index f25fdd3..28b20f1 100644
--- a/tc/array.h
+++ b/tc/array.h
@@ -56,19 +56,10 @@ namespace tc {
 			typename no_adl::array_storage<T*, N>::type m_a;
 
 		public:
-			using value_type = tc::decay_t<T>;
-			using reference = T&;
-			using const_reference = T&; // reference semantics == no deep constness
-			using pointer = T *;
-			using iterator = boost::indirect_iterator<T* const*, value_type, /*CategoryOrTraversal*/boost::use_default, reference>;
-			using const_iterator = iterator; // reference semantics == no deep constness
-			using reverse_iterator = std::reverse_iterator<iterator>;
-			using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-			using size_type = std::size_t;
-			using difference_type = std::ptrdiff_t;
-
-			static constexpr std::size_t size() noexcept {
-				return N;
+			using iterator = boost::indirect_iterator<T* const*, tc::decay_t<T>, /*CategoryOrTraversal*/boost::use_default, T&>;
+
+			static constexpr auto size() noexcept {
+				return tc::least_uint_constant<N>{};
 			}
 
 		private:
@@ -139,7 +130,7 @@ namespace tc {
 
 			// access (no rvalue-qualified overloads, must not move data out of a reference)
 			// reference semantics == no deep constness
-			[[nodiscard]] constexpr T& operator[](std::size_t i) const& noexcept {
+			[[nodiscard]] constexpr T& operator[](std::size_t const i) const& noexcept {
 				_ASSERTDEBUG(i<N);
 				return *m_a[i];
 			}
@@ -163,17 +154,12 @@ namespace tc {
 	} // namespace array_adl
 	using array_adl::array;
 
-	namespace no_adl {
-		template<typename T, std::size_t N>
-		struct constexpr_size_impl<tc::array<T&, N>> : tc::constant<N> {};
-	}
-
 	/////////////////////////////////////////////////////
 	// std::array
 
 	namespace no_adl {
 		template<typename T, std::size_t N>
-		struct constexpr_size_impl<std::array<T, N>> : tc::constant<N> {};
+		struct constexpr_size_impl<std::array<T, N>> : tc::least_uint_constant<N> {};
 	}
 
 	namespace explicit_convert_std_array_detail {
@@ -282,12 +268,12 @@ namespace tc {
 
 	template<typename TTarget, typename Rng>
 	[[nodiscard]] constexpr auto make_array(Rng&& rng) return_decltype_MAYTHROW(
-		tc::make_array<TTarget, tc::constexpr_size<Rng>::value>(std::forward<Rng>(rng))
+		tc::make_array<TTarget, tc::constexpr_size<Rng>()>(std::forward<Rng>(rng))
 	)
 
 	template<typename Rng>
 	[[nodiscard]] constexpr auto make_array(Rng&& rng) return_decltype_MAYTHROW(
-		tc::make_array<tc::constexpr_size<Rng>::value>(std::forward<Rng>(rng))
+		tc::make_array<tc::constexpr_size<Rng>()>(std::forward<Rng>(rng))
 	)
 
 	template <typename T = tc::deduce_tag, typename... Ts> requires (!std::is_reference<T>::value)
diff --git a/tc/base/accessors.h b/tc/base/accessors.h
index cfc99c9..b9adca0 100644
--- a/tc/base/accessors.h
+++ b/tc/base/accessors.h
@@ -47,19 +47,19 @@ namespace tc {
 	TC_EXPAND(TC_EXPAND(BOOST_PP_IF(BOOST_PP_GREATER(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), 1), DEFINE_MEMBER_WITH_INIT, DEFINE_MEMBER_WITHOUT_INIT))(TC_FWD(type), __VA_ARGS__))
 
 #define DEFINE_ACCESSORS_BASE(type, funcname, invariant, name) \
-	constexpr typename tc::no_adl::accessor_return_type<type>::const_ref_type funcname() const& noexcept { invariant(name); return name; } \
+	[[nodiscard]] constexpr typename tc::no_adl::accessor_return_type<type>::const_ref_type funcname() const& noexcept { invariant(name); return name; } \
 	\
 	template<ENABLE_SFINAE> requires /*dummy constraint making this function preferred in overload resolution over the deleted function below*/true \
-	constexpr typename tc::no_adl::accessor_return_type<SFINAE_TYPE(type)>::ref_ref_type funcname() && noexcept { invariant(name); return tc_move(name); } \
+	[[nodiscard]] constexpr typename tc::no_adl::accessor_return_type<SFINAE_TYPE(type)>::ref_ref_type funcname() && noexcept { invariant(name); return tc_move(name); } \
 	\
 	template<ENABLE_SFINAE> /* needed to stay behind non-deleted function in overload resolution */ \
-	constexpr type&& funcname() && noexcept = delete; /* Visual Studio gives improper error message if it returns a dummy type */ \
+	[[nodiscard]] constexpr type&& funcname() && noexcept = delete; /* Visual Studio gives improper error message if it returns a dummy type */ \
 	\
 	template<ENABLE_SFINAE> requires true \
-	constexpr typename tc::no_adl::accessor_return_type<SFINAE_TYPE(type)>::const_ref_ref_type funcname() const&& noexcept { invariant(name); return std::move(name); } \
+	[[nodiscard]] constexpr typename tc::no_adl::accessor_return_type<SFINAE_TYPE(type)>::const_ref_ref_type funcname() const&& noexcept { invariant(name); return std::move(name); } \
 	\
 	template<ENABLE_SFINAE> \
-	constexpr type const&& funcname() const&& noexcept = delete; /* Visual Studio gives improper error message if it returns a dummy type */
+	[[nodiscard]] constexpr type const&& funcname() const&& noexcept = delete; /* Visual Studio gives improper error message if it returns a dummy type */
 
 #define DEFINE_MEMBER_INVARIANT(...) ([&](auto const& _) constexpr noexcept { \
 	_ASSERTINITIALIZED(_); \
diff --git a/tc/base/assert_defs.h b/tc/base/assert_defs.h
index 28f891e..e87050c 100644
--- a/tc/base/assert_defs.h
+++ b/tc/base/assert_defs.h
@@ -46,6 +46,9 @@
 	#ifndef _ASSERTNORETURN
 		#define _ASSERTNORETURN _ASSERT
 	#endif
+	#ifndef _ASSERTNORETURNFALSE
+		#define _ASSERTNORETURNFALSE _ASSERTFALSE
+	#endif
 	#ifndef _ASSERTNOTIFY
 		#define _ASSERTNOTIFY _ASSERT
 	#endif
@@ -97,7 +100,7 @@
 				return std::forward<Expr>(expr);
 			}
 		}
-		#define VERIFY( expr ) ErrorHandling::Verify(expr)
+		#define VERIFY ErrorHandling::Verify
 	#endif
 	#ifndef VERIFYPRED
 		#include <utility>
diff --git a/tc/base/assign.h b/tc/base/assign.h
index b3e645d..790eb63 100644
--- a/tc/base/assign.h
+++ b/tc/base/assign.h
@@ -166,7 +166,7 @@ constexpr auto assign_better( Better better, Var&& var, Val&& val ) noexcept {
 		[&](tc::constant<false> b) noexcept {
 			return b;
 		},
-		[&](bool b) noexcept {
+		[&](bool const b) noexcept {
 			if (b) {
 				static_assert( tc::safely_assignable_from<Var&&, Val&&> );
 				std::forward<Var>(var) = std::forward<Val>(val);
@@ -238,13 +238,6 @@ void change_with_or(Var&& var, Val&& val, bool& bChanged) noexcept {
 tc_define_fn( assign_max );
 tc_define_fn( assign_min );
 
-template< typename Better >
-[[nodiscard]] constexpr auto fn_assign_better(Better&& better) noexcept {
-	return [better=std::forward<Better>(better)](auto&& var, auto&& val0, auto&&... val) noexcept {
-		return tc::assign_better(better, tc_move_if_owned(var), tc_move_if_owned(val0), tc_move_if_owned(val)...);
-	};
-}
-
 ////////////////////////////////////
 // change for float/double
 
diff --git a/tc/base/bit_cast.h b/tc/base/bit_cast.h
index fbad7a9..43e0cc7 100644
--- a/tc/base/bit_cast.h
+++ b/tc/base/bit_cast.h
@@ -10,14 +10,124 @@
 
 #include "casts.h"
 #include "../range/subrange.h"
+#include "../array.h"
 #include <boost/range/algorithm/copy.hpp>
 
 //-----------------------------------------------------------------------------------------------------------------------------
 
 namespace tc {
+
+	//--------------------------------------------------------------------------------------------------------------------------
+	// as_blob
+	// reinterprets a range of items as a range of bytes
+
+	// We use unsigned char for uninterpreted memory.
+	// - The type used must support aliasing, so the only candidates are char, signed char and unsigned char.
+	// - char is bad because we interpret char as UTF-8 and char* as zero-terminated range.
+	// - unsigned char is better than signed char because the binary representation of signs may vary between platforms.
+	// - char is bad because it is either signed or unsigned, so it has the same problem.
+	// - unsigned char is better than std::uint8_t because the latter must be 8 bit, but we mean the smallest addressable unit, which is char and may be larger (or smaller?) on other platforms.
+
+	static_assert(!tc::range_with_iterators< void const* >);
+
+	template<tc::contiguous_range Rng>
+	[[nodiscard]] auto range_as_blob(Rng&& rng) noexcept {
+		using cv_value_type = std::remove_pointer_t<decltype(tc::ptr_begin(rng))>;
+		static_assert( std::is_trivially_copyable< cv_value_type >::value, "as_blob only works on std::is_trivially_copyable types" );
+		if constexpr(tc::safely_constructible_from<tc::span<cv_value_type>, Rng>) {
+			return tc::make_iterator_range(
+				reinterpret_cast<same_cvref_t<unsigned char, cv_value_type>*>(tc::ptr_begin(rng)),
+				reinterpret_cast<same_cvref_t<unsigned char, cv_value_type>*>(tc::ptr_end(rng))
+			);
+		} else {
+			// not inside blob_range_t because templates cannot be declared inside of a local class
+			static auto constexpr as_blob_ptr=[](auto ptr) noexcept {
+				return reinterpret_cast<same_cvref_t<unsigned char, std::remove_pointer_t<decltype(ptr)>>*>(ptr);
+			};
+			struct blob_range_t final {
+				explicit blob_range_t(Rng&& rng) noexcept : m_rng(tc_move(rng)) {}
+				auto begin() & noexcept { return as_blob_ptr(tc::ptr_begin(m_rng)); }
+				auto begin() const& noexcept { return as_blob_ptr(tc::ptr_begin(m_rng)); }
+				auto end() & noexcept { return as_blob_ptr(tc::ptr_end(m_rng)); }
+				auto end() const& noexcept { return as_blob_ptr(tc::ptr_end(m_rng)); }
+			private:
+				static_assert(!std::is_reference<Rng>::value);
+				std::remove_cv_t<Rng> m_rng;
+			};
+			return blob_range_t(tc_move(rng));
+		}
+	}
+
+	namespace no_adl {
+		template<typename Sink>
+		struct range_as_blob_sink { // no final: verify_sink_result_impl derives
+		private:
+			// range_as_blob_sink is only used inline in range_as_blob below, and m_sink is only passed to tc::for_each, so holding by lvalue reference ok
+			Sink& m_sink;
+
+		public:
+			explicit range_as_blob_sink(Sink& sink) noexcept: m_sink(sink) {}
+
+			// chunk must be defined before operator() - otherwise MSVC will not allow it to occur in the return type of operator()
+			template<tc::contiguous_range Rng>
+			auto chunk(Rng&& rng) const& return_decltype_MAYTHROW (
+				tc::for_each(tc::range_as_blob(tc_move_if_owned(rng)), m_sink)
+			)
+
+			template<typename T>
+			auto operator()(T&& t) const& return_decltype_MAYTHROW (
+				chunk(tc::single(/* no std::forward<T> */ t))
+			)
+		};
+	}
+
+	template<typename Rng>
+	[[nodiscard]] auto range_as_blob(Rng&& rng) noexcept {
+		return [rng=tc::make_reference_or_value(tc_move_if_owned(rng))](auto&& sink) MAYTHROW {
+			return tc::for_each(*rng, no_adl::range_as_blob_sink<std::remove_reference_t<decltype(sink)>>(sink));
+		};
+	}
+
+	template<typename T> requires std::is_trivially_copyable<std::remove_reference_t<T>>::value
+	[[nodiscard]] auto as_blob(T&& t) noexcept {
+		return tc::range_as_blob( tc::single( std::forward<T>(t) ) );
+	}
+
+	namespace assert_no_overlap_impl {
+		void assert_no_overlap(auto const& lhs, auto const& rhs) noexcept {
+			_ASSERT(
+				reinterpret_cast<std::size_t>(tc::ptr_end(lhs)) <= reinterpret_cast<std::size_t>(tc::ptr_begin(rhs)) ||
+				reinterpret_cast<std::size_t>(tc::ptr_end(rhs)) <= reinterpret_cast<std::size_t>(tc::ptr_begin(lhs))
+			);
+		}
+	}
+	template< typename Lhs, typename Rhs>
+	void assert_no_overlap(Lhs const& lhs, Rhs const& rhs) noexcept {
+		assert_no_overlap_impl::assert_no_overlap(tc::single(lhs), tc::single(rhs));
+		if constexpr( tc::contiguous_range<Lhs> && tc::contiguous_range<Rhs> ) {
+			assert_no_overlap_impl::assert_no_overlap(lhs, rhs);
+		}
+	}
+
 	/////////////////////////////////////////////
 	// bit_cast
 
+	namespace no_adl {
+		struct any_ptr_ref final: tc::nonmovable {
+		private:
+			void* m_pv;
+		public:
+			explicit any_ptr_ref(void* pv) noexcept: m_pv(pv) {}
+
+			template<typename T> requires std::same_as<std::remove_cvref_t<T>, T> && std::is_trivially_copyable<T>::value
+			operator T() && noexcept {
+				T t;
+				std::memcpy(std::addressof(t), m_pv, sizeof(t));
+				return t;
+			}
+		};
+	}
+
 	namespace any_ptr_adl {
 		struct any_ptr final {
 		private:
@@ -27,6 +137,14 @@ namespace tc {
 			:	m_pv(pv)
 			{}
 
+			explicit operator bool() const& noexcept {
+				return m_pv;
+			}
+
+			auto operator*() const& noexcept {
+				return tc::no_adl::any_ptr_ref(m_pv);
+			}
+
 			template<typename T> requires std::is_pointer<T>::value || std::is_member_pointer<T>::value
 			operator T() const& noexcept {
 				STATICASSERTEQUAL(sizeof(T), sizeof(void*));
@@ -187,4 +305,3 @@ namespace tc {
 		return typename aliasing_ptr<std::remove_pointer_t<Dst>>::type(reinterpret_cast<Dst>(src));
 	}
 }
-
diff --git a/tc/base/casts.h b/tc/base/casts.h
index de80c87..d658527 100644
--- a/tc/base/casts.h
+++ b/tc/base/casts.h
@@ -65,16 +65,29 @@ namespace tc {
 	// derived_cast
 	
 	namespace derived_cast_detail {
+		template<typename To, typename From>
+		constexpr void check_derived_cast(From const& obj) noexcept {
+			if constexpr (!std::is_same<To, From>::value && std::is_polymorphic<From>::value) {
+				_ASSERT(dynamic_cast<To const*>(std::addressof(obj)));
+			}
+		}
+
 		namespace derived_cast_internal_default {
-			template<typename To, typename From>
-			[[nodiscard]] constexpr same_cvref_t< To, From&&> derived_cast_internal_impl( tc::type::identity<To>, From&& t ) noexcept {
+			template<typename To, typename From, bool bChecked>
+			[[nodiscard]] constexpr same_cvref_t< To, From&&> derived_cast_internal_impl(tc::type::identity<To>, From&& t, std::bool_constant<bChecked>) noexcept {
 				static_assert( tc::derived_from<To, std::remove_reference_t<From>>, "derived_cast is for downcasts only.");
+				if constexpr (bChecked) {
+					check_derived_cast<To>(t);
+				}
 				return static_cast< apply_cvref_t< To, From&&> >(t);
 			}
 
-			template<typename To, typename From>
-			[[nodiscard]] constexpr same_cvref_t< To, From>* derived_cast_internal_impl( tc::type::identity<To>, From* pt ) noexcept {
+			template<typename To, typename From, bool bChecked>
+			[[nodiscard]] constexpr same_cvref_t< To, From>* derived_cast_internal_impl(tc::type::identity<To>, From* pt, std::bool_constant<bChecked>) noexcept {
 				static_assert( tc::derived_from<To, std::remove_pointer_t<From>>, "derived_cast is for downcasts only.");
+				if constexpr (bChecked) {
+					if (nullptr != pt) check_derived_cast<To>(*pt);
+				}
 				return static_cast< apply_cvref_t< To, From>* >(pt);
 			}
 		}
@@ -85,7 +98,13 @@ namespace tc {
 	template<typename To, typename From>
 	[[nodiscard]] constexpr decltype(auto) derived_cast(From&& t) noexcept {
 		STATICASSERTSAME(std::remove_reference_t<To>, To);
-		return tc::derived_cast_detail::derived_cast_internal(tc::type::identity<To>(), std::forward<From>(t));
+		return tc::derived_cast_detail::derived_cast_internal(tc::type::identity<To>(), std::forward<From>(t), /*bChecked*/tc::constant<true>());
+	}
+
+	template<typename To, typename From>
+	[[nodiscard]] constexpr decltype(auto) unchecked_derived_cast(From&& t) noexcept {
+		STATICASSERTSAME(std::remove_reference_t<To>, To);
+		return tc::derived_cast_detail::derived_cast_internal(tc::type::identity<To>(), std::forward<From>(t), /*bChecked*/tc::constant<false>());
 	}
 
 	/////////////////////////////////////////////
@@ -259,59 +278,46 @@ MODIFY_WARNINGS_END
 		return std::forward<TSource>(src);
 	}
 
-	/////////////////////////////////////////////
-	// reluctant_static_cast
-	// Returns a reference to its argument whenever possible, otherwise performs an explicit conversion.
-
-	template<typename TTarget, tc::decayed_derived_from<TTarget> TSource>
-	[[nodiscard]] TSource&& reluctant_static_cast(TSource&& src) noexcept {
-		STATICASSERTSAME(std::remove_cvref_t<TTarget>, TTarget);
-		return std::forward<TSource>(src);
-	}
-
-	template<typename TTarget, typename TSource>
-	[[nodiscard]] TTarget reluctant_static_cast(TSource&& src) noexcept {
-		STATICASSERTSAME(std::remove_cvref_t<TTarget>, TTarget);
-		return static_cast<TTarget>(std::forward<TSource>(src));
-	}
-
 	/////////////////////////////////////////////
 	// as_c_str
+	namespace as_c_str_default {
+		template< typename Char, typename Traits, typename Alloc >
+		[[nodiscard]] Char const* as_c_str_impl(std::basic_string< Char, Traits, Alloc > const& str) noexcept
+		{
+			return str.data(); // since C++ 11, performs same function as c_str(). cannot use tc::ptr_begin to avoid circular dependency
+		}
 
-	template< typename Char, typename Traits, typename Alloc >
-	[[nodiscard]] Char const* as_c_str(std::basic_string< Char, Traits, Alloc > const& str) noexcept
-	{
-		return str.data(); // since C++ 11, performs same function as c_str()
-	}
+		template< typename Char, typename Traits, typename Alloc >
+		[[nodiscard]] Char* as_c_str_impl(std::basic_string< Char, Traits, Alloc >& str) noexcept
+		{
+			return str.data(); // since C++ 11, performs same function as c_str(). cannot use tc::ptr_begin to avoid circular dependency
+		}
 
-	template< typename Char, typename Traits, typename Alloc >
-	[[nodiscard]] Char* as_c_str(std::basic_string< Char, Traits, Alloc >& str) noexcept
-	{
-		return str.data(); // since C++ 11, performs same function as c_str()
-	}
+		template< typename Char, typename Traits, typename Alloc >
+		[[nodiscard]] Char* as_c_str_impl(std::basic_string< Char, Traits, Alloc >&& str) noexcept
+		{
+			return str.data(); // since C++ 11, performs same function as c_str(). cannot use tc::ptr_begin to avoid circular dependency
+		}
 
-	template< typename Char, typename Traits, typename Alloc >
-	[[nodiscard]] Char* as_c_str(std::basic_string< Char, Traits, Alloc >&& str) noexcept
-	{
-		return str.data(); // since C++ 11, performs same function as c_str()
-	}
+		template<tc::char_type Char>
+		[[nodiscard]] constexpr Char const* as_c_str_impl(Char const* psz) noexcept {
+			return psz;
+		}
 
-	template<tc::char_type Char>
-	[[nodiscard]] constexpr Char const* as_c_str(Char const* psz) noexcept {
-		return psz;
-	}
+		template<tc::char_type Char>
+		[[nodiscard]] constexpr Char* as_c_str_impl(Char* psz) noexcept {
+			return psz;
+		}
 
-	template<tc::char_type Char>
-	[[nodiscard]] constexpr Char* as_c_str(Char* psz) noexcept {
-		return psz;
+	#ifdef TC_PRIVATE
+		// Prevents implicit conversion from std::vector<wchar_t> to boost::filesystem::path on Windows, which causes a dangling pointer to be returned
+		template<typename T> requires std::is_same<T, boost::filesystem::path>::value
+		[[nodiscard]] inline boost::filesystem::path::value_type const* as_c_str_impl(T const& fspath) noexcept {
+			return fspath.c_str();
+		}
+	#endif
 	}
 
-#ifdef TC_PRIVATE
-	// Prevents implicit conversion from std::vector<wchar_t> to boost::filesystem::path on Windows, which causes a dangling pointer to be returned
-	template<typename T> requires std::is_same<T, boost::filesystem::path>::value
-	[[nodiscard]] inline boost::filesystem::path::value_type const* as_c_str(T const& fspath) noexcept {
-		return fspath.c_str();
-	}
-#endif
+	DEFINE_TMPL_FUNC_WITH_CUSTOMIZATIONS(as_c_str)
 }
 
diff --git a/tc/base/conditional.h b/tc/base/conditional.h
index 8d27bb0..fb8ea5c 100644
--- a/tc/base/conditional.h
+++ b/tc/base/conditional.h
@@ -15,8 +15,8 @@
 #define TYPED_CONDITIONAL(b, type, lhs, rhs) \
 	(tc::explicit_cast<bool>(b) ? static_cast<type>(lhs) : static_cast<type>(rhs)) // static_cast needed for conversion from const& to const&&
 
-#define CONDITIONAL_RVALUE_AS_REF(b, lhs, rhs) \
+#define tc_conditional_rvalue_as_ref(b, lhs, rhs) \
 	TYPED_CONDITIONAL(TC_FWD(b), TC_FWD(tc::common_reference_xvalue_as_ref_t<decltype((lhs))&&, decltype((rhs))&&>), TC_FWD(lhs), TC_FWD(rhs))
 
-#define CONDITIONAL_PRVALUE_AS_VAL(b, lhs, rhs) \
+#define tc_conditional_prvalue_as_val(b, lhs, rhs) \
 	TYPED_CONDITIONAL(TC_FWD(b), TC_FWD(tc::common_reference_prvalue_as_val_t<decltype((lhs)), decltype((rhs))>), TC_FWD(lhs), TC_FWD(rhs))
diff --git a/tc/base/enum.h b/tc/base/enum.h
index c7500c0..ddeeedc 100644
--- a/tc/base/enum.h
+++ b/tc/base/enum.h
@@ -24,15 +24,16 @@
 #include <cstdint>
 
 namespace tc {
-	template <typename Enum>
-	void contiguous_enum_impl(Enum const&) = delete;
+	template<typename T>
+	concept contiguous_enum_type = tc::enum_type<T> && requires(T const& value) {
+		contiguous_enum_impl(value);
+	};
 
 	namespace no_adl {
 		template <typename Enum>
 		struct contiguous_enum : tc::constant<false> {};
 
-		template <typename Enum>
-			requires requires(Enum const& e) { contiguous_enum_impl(e); }
+		template <contiguous_enum_type Enum>
 		struct contiguous_enum<Enum> : tc::constant<true> {
 			using impl = decltype(contiguous_enum_impl(std::declval<Enum>()));
 
@@ -48,9 +49,6 @@ namespace tc {
 	}
 	using no_adl::contiguous_enum;
 
-	template<typename T>
-	concept contiguous_enum_type = tc::enum_type<T> && contiguous_enum<T>::value;
-
 	template<typename Enum, typename Integer>
 	[[nodiscard]] constexpr bool is_enum_value_or_end(Integer const& n) noexcept { // reference to avoid error C4701: potentially uninitialized local variable
 		static_assert( tc::actual_integer<Integer> );
@@ -134,10 +132,10 @@ constexpr Enum& operator^=(Enum& _Left, Enum _Right) \
 \
 [[nodiscard]] constexpr bool HasAllOf(Enum _Left, Enum _Right) \
 {	/* return _Left HasAllOf _Right */\
-	return !(~_Left & _Right); \
+	return !static_cast<bool>(~_Left & _Right); \
 }\
 \
-std::strong_ordering operator<=>(Enum, Enum) = delete; \
+std::weak_ordering operator<=>(Enum, Enum) = delete; \
 bool operator<(Enum, Enum) = delete; \
 bool operator<=(Enum, Enum) = delete; \
 bool operator>=(Enum, Enum) = delete; \
@@ -184,7 +182,7 @@ namespace tc {
 	[[nodiscard]] inline bool check_initialized_impl(Enum const& e) noexcept { /*reference to avoid error C4701: potentially uninitialized local variable*/ \
 		return tc::is_enum_value_or_end<Enum>(tc::to_underlying(e)); \
 	} \
-	[[nodiscard]] constexpr boost::int_max_value_t< tc::enum_count<Enum>::value >::least operator-(Enum e1, Enum e2) noexcept { \
+	[[nodiscard]] constexpr boost::int_max_value_t< tc::enum_count<Enum>::value >::least operator-(Enum const e1, Enum const e2) noexcept { \
 		return static_cast<boost::int_max_value_t< tc::enum_count<Enum>::value >::least>(tc::to_underlying(e1)-tc::to_underlying(e2)); \
 	} \
 	template<ENABLE_SFINAE> \
@@ -260,7 +258,7 @@ namespace tc {
 
 namespace tc::enum_detail {
 	template<typename IntOffset>
-	constexpr auto max_value_for_underlying_type(IntOffset nOffset, int nConstants) noexcept {
+	constexpr auto max_value_for_underlying_type(IntOffset nOffset, int const nConstants) noexcept {
 		static_assert( std::is_signed<IntOffset>::value, "unsigned underlying type not supported" );
 		// Assume two's complement.
 		// -1 - nOffset, like ~nOffset never overflows.
diff --git a/tc/base/fundamental.h b/tc/base/fundamental.h
index bb00530..a7043c8 100644
--- a/tc/base/fundamental.h
+++ b/tc/base/fundamental.h
@@ -81,18 +81,3 @@ namespace tc {
 #else
 	#define MSVC_TEMPLATE_WORKAROUND template
 #endif
-
-#if WCHAR_MAX == 0xFFFF // == 2 bytes unsigned: We want tc::char16 to be unsigned. wchar_t is unsigned on MSVC, but that's implementation-specific.
-namespace tc {
-	using char16 = wchar_t;
-}
-	#define UTF16_(x) L ## x
-#else
-namespace tc {
-	using char16 = char16_t;
-}
-	#define UTF16_(x) u ## x
-#endif
-#define UTF16(x) UTF16_(x)
-
-static_assert(0 == std::numeric_limits<tc::char16>::lowest() && 0xFFFF == std::numeric_limits<tc::char16>::max());
diff --git a/tc/base/inside_unwinding.h b/tc/base/inside_unwinding.h
new file mode 100644
index 0000000..6486edb
--- /dev/null
+++ b/tc/base/inside_unwinding.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "assert_defs.h"
+#include <exception>
+
+namespace tc {
+	namespace no_adl {
+		struct inside_unwinding {
+			inside_unwinding() noexcept
+			: m_nUncaughtExceptions(std::uncaught_exceptions())
+			{}
+			inside_unwinding(inside_unwinding const&) noexcept
+			: inside_unwinding()
+			{}
+			inside_unwinding& operator=(inside_unwinding const&) & noexcept {
+				return *this;
+			}
+			bool inside_stack_unwinding() const& noexcept {
+				int const nUncaughtExceptions = std::uncaught_exceptions();
+				_ASSERT(m_nUncaughtExceptions<=nUncaughtExceptions);
+				return m_nUncaughtExceptions<nUncaughtExceptions;
+			}
+		private:
+			int const m_nUncaughtExceptions;
+		};
+	}
+	using no_adl::inside_unwinding;
+}
diff --git a/tc/base/invoke.h b/tc/base/invoke.h
index a213a93..769e81e 100644
--- a/tc/base/invoke.h
+++ b/tc/base/invoke.h
@@ -11,14 +11,12 @@
 #include "return_decltype.h"
 #include "tag_type.h"
 #include "utility.h"
+#include "explicit_cast_fwd.h"
 
 #include <tuple>
 #include <type_traits>
 
 namespace tc {
-	template<typename T>
-	concept tuple_like = tc::actual_integer<decltype(std::tuple_size<std::remove_reference_t<T>>::value)>;
-
 	namespace invoke_no_adl {
 		//////////////////////////////////////////////////////////////////////////
 		// expanded
@@ -163,14 +161,29 @@ namespace tc {
 	}
 
 	//////////////////////////////////////////////////////////////////////////
-	// is_invocable
-	namespace invoke_no_adl {
-		template <typename, typename Func, typename... Args>
-		struct is_invocable /*final*/ : tc::constant<false> {};
-
-		template <typename Func, typename... Args>
-		struct is_invocable<tc::void_t<decltype(tc::invoke(std::declval<Func>(), std::declval<Args>()...))>, Func, Args...> /*final*/ : tc::constant<true> {};
-	}
+	// concepts
+	template <typename Func, typename... Args>
+	concept invocable = requires(Func&& f, Args&&... args) { tc::invoke(std::forward<Func>(f), std::forward<Args>(args)...); };
 	template <typename Func, typename... Args>
-	using is_invocable = invoke_no_adl::is_invocable<void, Func, Args...>;
+	concept nothrow_invocable = tc::invocable<Func, Args...> && noexcept(tc::invoke(std::declval<Func>(), std::declval<Args>()...));
+
+	template <typename Func, typename T>
+	concept predicate = tc::invocable<Func const&, std::remove_cvref_t<T> const&>
+		&& requires(Func const& f, std::remove_cvref_t<T> const& t) { tc::explicit_cast<bool>(tc::invoke(f, t)); };
+	template <typename Func, typename T>
+	concept nothrow_predicate = tc::predicate<Func, T> && tc::nothrow_invocable<Func const&, std::remove_cvref_t<T> const&>;
+
+	template <typename Func, typename T>
+	concept constant_predicate = tc::predicate<Func, T>
+		&& requires(Func const& f, std::remove_cvref_t<T> const& t) { tc::explicit_cast<bool>(decltype(tc::invoke(f, t))::value); };
+
+	template <typename Func, typename T>
+	concept constant_predicate_true = tc::constant_predicate<Func, T>
+		&& tc::explicit_cast<bool>(decltype(tc::invoke(std::declval<Func const&>(), std::declval<std::remove_cvref_t<T> const&>()))::value);
+	template <typename Func, typename T>
+	concept constant_predicate_false = tc::constant_predicate<Func, T>
+		&& !tc::explicit_cast<bool>(decltype(tc::invoke(std::declval<Func const&>(), std::declval<std::remove_cvref_t<T> const&>()))::value);
+
+	template <typename Func, typename T>
+	concept runtime_predicate = tc::predicate<Func, T> && (!tc::constant_predicate<Func, T>);
 }
diff --git a/tc/base/invoke.t.cpp b/tc/base/invoke.t.cpp
index 7bde1e1..8b5ef9e 100644
--- a/tc/base/invoke.t.cpp
+++ b/tc/base/invoke.t.cpp
@@ -12,8 +12,8 @@
 namespace {
 	[[maybe_unused]] void static_tests() noexcept {
 		auto rvalue_sink = [](int, double&&, char const&) noexcept {};
-		static_assert(!tc::is_invocable<decltype(rvalue_sink), int, double&, char>::value);
-		static_assert(!tc::is_invocable<decltype(rvalue_sink), std::tuple<int, double&, char>>::value);
+		static_assert(!tc::invocable<decltype(rvalue_sink), int, double&, char>);
+		static_assert(!tc::invocable<decltype(rvalue_sink), std::tuple<int, double&, char>>);
 
 		tc::invoke(rvalue_sink, 0, 0., 'a');
 		tc::invoke(rvalue_sink, std::make_tuple(0, 0., 'a'));
@@ -21,9 +21,9 @@ namespace {
 		tc::invoke(rvalue_sink, std::make_tuple(0, std::make_tuple(std::make_tuple(0.), 'a')));
 
 		auto lvalue_sink = [](int, double&, char const&) noexcept {};
-		static_assert(!tc::is_invocable<decltype(lvalue_sink), int, double, char>::value);
-		static_assert(!tc::is_invocable<decltype(lvalue_sink), std::tuple<int, double, char>>::value);
-		static_assert(!tc::is_invocable<decltype(lvalue_sink), std::tuple<int&&, double&&, char&&>>::value);
+		static_assert(!tc::invocable<decltype(lvalue_sink), int, double, char>);
+		static_assert(!tc::invocable<decltype(lvalue_sink), std::tuple<int, double, char>>);
+		static_assert(!tc::invocable<decltype(lvalue_sink), std::tuple<int&&, double&&, char&&>>);
 
 		int a0 = 0;
 		double a1 = 0.;
diff --git a/tc/base/ref.h b/tc/base/ref.h
index 2568668..aa846e3 100644
--- a/tc/base/ref.h
+++ b/tc/base/ref.h
@@ -10,7 +10,6 @@
 
 #include "assert_defs.h"
 #include "as_lvalue.h"
-#include "../range/range_fwd.h"
 #include "../algorithm/for_each.h"
 
 namespace tc {
@@ -89,7 +88,7 @@ namespace tc {
 				
 			template <typename Func> requires
 				(!tc::decayed_derived_from<Func, function_ref_base>)
-				&& tc::is_invocable<std::remove_reference_t<Func>&, Args...>::value
+				&& tc::invocable<std::remove_reference_t<Func>&, Args...>
 				&& (
 					std::convertible_to<decltype(tc::invoke(std::declval<std::remove_reference_t<Func>&>(), std::declval<Args>()...)), Ret>
 					|| std::is_same<Ret, tc::break_or_continue>::value
diff --git a/tc/base/reference_or_value.h b/tc/base/reference_or_value.h
index bdd7074..033a6a4 100644
--- a/tc/base/reference_or_value.h
+++ b/tc/base/reference_or_value.h
@@ -33,15 +33,34 @@ namespace tc {
 				: m_t(std::forward<Rhs>(rhs))
 			{}
 
-			// T may be a proxy with reference behavior (e.g. pair<X&,X&>): operator= may not be equivalent to copy ctor.
+			// reference_or_value<T> is trivially copy assignable if T is trivially copy assignable.
+			constexpr reference_or_value& operator=(reference_or_value const& other) & requires std::is_trivially_copy_assignable<T>::value = default;
+			// T may be a proxy with reference behavior (e.g. pair<X&,X&>): operator= must be non trivial and may not be equivalent to copy ctor.
 			// operator=() with tc::renew for pointer semantics.
-			constexpr reference_or_value& operator=(reference_or_value const& other) & noexcept {
+#ifdef __clang__ // workaround clang bug on trivially copyable: https://github.com/llvm/llvm-project/issues/63352
+			template<ENABLE_SFINAE>
+			constexpr reference_or_value& operator=(reference_or_value<SFINAE_TYPE(T)> const& other) & noexcept requires
+#else
+			constexpr reference_or_value& operator=(reference_or_value const& other) & noexcept requires
+#endif
+				(!std::is_trivially_copy_assignable<T>::value) &&
+				std::is_copy_constructible<T>::value
+			{
 				_ASSERTE(this != std::addressof(other));
 				tc::renew(m_t, other.m_t);
 				return *this;
 			}
 
-			constexpr reference_or_value& operator=(reference_or_value&& other) & noexcept {
+			constexpr reference_or_value& operator=(reference_or_value&& other) & requires std::is_trivially_move_assignable<T>::value = default;
+#ifdef __clang__ // workaround clang bug on trivially copyable: https://github.com/llvm/llvm-project/issues/63352
+			template<ENABLE_SFINAE>
+			constexpr reference_or_value& operator=(reference_or_value<SFINAE_TYPE(T)>&& other) & noexcept requires
+#else
+			constexpr reference_or_value& operator=(reference_or_value&& other) & noexcept requires
+#endif
+				(!std::is_trivially_move_assignable<T>::value) &&
+				std::is_move_constructible<T>::value
+			{
 				_ASSERTE(this != std::addressof(other));
 				tc::renew(m_t, tc_move(other).m_t);
 				return *this;
@@ -146,8 +165,8 @@ namespace tc {
 	}
 	template<typename T>
 	using reference_or_value = std::conditional_t<
-		tc::empty_type<T>,
-		no_adl::empty_value<std::remove_cv_t<T>>,
+		tc::empty_type<std::remove_cvref_t<T>>,
+		no_adl::empty_value<std::remove_cvref_t<T>>,
 		no_adl::reference_or_value<std::remove_cv_t<T>>
 	>;
 	
diff --git a/tc/base/reference_or_value.t.cpp b/tc/base/reference_or_value.t.cpp
new file mode 100644
index 0000000..f30c15e
--- /dev/null
+++ b/tc/base/reference_or_value.t.cpp
@@ -0,0 +1,29 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "reference_or_value.h"
+#include "../tuple.h"
+#include <utility>
+
+static_assert(std::is_trivially_copyable<tc::reference_or_value<int>>::value);
+static_assert(std::is_trivially_copy_assignable<tc::reference_or_value<int>>::value);
+static_assert(std::is_trivially_move_assignable<tc::reference_or_value<int>>::value);
+
+static_assert(!std::is_trivially_copy_assignable<std::pair<int&, int&>>::value);
+static_assert(!std::is_trivially_move_assignable<std::pair<int&, int&>>::value);
+static_assert(!std::is_trivially_copyable<tc::reference_or_value<std::pair<int&, int&>>>::value);
+static_assert(!std::is_trivially_copy_assignable<tc::reference_or_value<std::pair<int&, int&>>>::value);
+static_assert(!std::is_trivially_move_assignable<tc::reference_or_value<std::pair<int&, int&>>>::value);
+
+static_assert(std::is_trivially_copyable<tc::reference_or_value<int&>>::value);
+static_assert(std::is_trivially_copy_assignable<tc::reference_or_value<int&>>::value);
+static_assert(std::is_trivially_move_assignable<tc::reference_or_value<int&>>::value);
+
+static_assert(std::is_trivially_copyable<tc::reference_or_value<tc::tuple<int, double>>>::value);
+static_assert(std::is_trivially_copy_assignable<tc::reference_or_value<tc::tuple<int, double>>>::value);
+static_assert(std::is_trivially_move_assignable<tc::reference_or_value<tc::tuple<int, double>>>::value);
diff --git a/tc/base/safe_comparison.h b/tc/base/safe_comparison.h
new file mode 100644
index 0000000..ebefe83
--- /dev/null
+++ b/tc/base/safe_comparison.h
@@ -0,0 +1,81 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "type_traits.h"
+#include "casts.h"
+#include <concepts>
+
+namespace tc {
+	// By default, a comparison is safe; specialize to mark as unsafe.
+	// (We can't delegate to safely_convertible_to, as we can't tell whether `T == U` is valid because of implicit conversions,
+	// or because of an overloaded operator== that takes those types and handles them safely.)
+	template <typename T, typename U>
+	constexpr bool safe_comparison = true;
+
+	// Comparison between mixed integral types is only safe as long as neither is a char type and they have the same signedness.
+	template <std::integral T, std::integral U>
+		requires (!std::same_as<T, U>)
+	constexpr bool safe_comparison<T, U>
+		= !tc::char_type<T> && !tc::char_type<U>
+		&& std::is_signed<T>::value == std::is_signed<U>::value;
+
+	template <typename T, typename U>
+	concept safely_equality_comparable_with = std::equality_comparable_with<T, U> && safe_comparison<tc::decay_t<T>, tc::decay_t<U>>;
+
+	template <typename T, typename U>
+	concept safely_totally_ordered_with = std::totally_ordered_with<T, U> && safe_comparison<tc::decay_t<T>, tc::decay_t<U>>;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// cmp_equal/cmp_less/cmp_greater...
+
+namespace tc { // TODO c++20: replace these functions with std versions
+	template< tc::actual_integer T, tc::actual_integer U >
+	constexpr bool cmp_equal( T t, U u ) noexcept
+	{
+	    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
+	        return t == u;
+	    else if constexpr (std::is_signed_v<T>)
+	        return t < 0 ? false : static_cast<std::make_unsigned_t<T>>(t) == u;
+	    else
+	        return u < 0 ? false : t == static_cast<std::make_unsigned_t<U>>(u);
+	}
+	 
+	template< typename T, typename U>
+	constexpr auto cmp_not_equal( T t, U u ) return_decltype_noexcept(
+		!cmp_equal(t, u)
+	)
+	 
+	template< tc::actual_integer T, tc::actual_integer U>
+	constexpr bool cmp_less( T t, U u ) noexcept
+	{
+	    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
+	        return t < u;
+	    else if constexpr (std::is_signed_v<T>)
+	        return t < 0 ? true : static_cast<std::make_unsigned_t<T>>(t) < u;
+	    else
+	        return u < 0 ? false : t < static_cast<std::make_unsigned_t<U>>(u);
+	}
+	 
+	template< typename T, typename U>
+	constexpr auto cmp_greater( T t, U u ) return_decltype_noexcept(
+	    cmp_less(u, t)
+	)
+	 
+	template< typename T, typename U >
+	constexpr auto cmp_less_equal( T t, U u ) return_decltype_noexcept(
+	    !cmp_greater(t, u)
+	)
+	 
+	template< typename T, typename U >
+	constexpr auto cmp_greater_equal( T t, U u ) return_decltype_noexcept(
+	    !cmp_less(t, u)
+	)
+}
diff --git a/tc/base/safe_comparison.t.cpp b/tc/base/safe_comparison.t.cpp
new file mode 100644
index 0000000..27b316d
--- /dev/null
+++ b/tc/base/safe_comparison.t.cpp
@@ -0,0 +1,53 @@
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "assert_defs.h"
+#include "safe_comparison.h"
+#include "../unittest.h"
+#include "../string/char.h"
+
+// Same type is safe.
+static_assert(tc::safe_comparison<int, int>);
+static_assert(tc::safe_comparison<unsigned, unsigned>);
+static_assert(tc::safe_comparison<tc::char16, tc::char16>);
+// Mixed signedness is unsafe.
+static_assert(!tc::safe_comparison<int, unsigned>);
+static_assert(!tc::safe_comparison<unsigned, int>);
+// Mixed chars are unsafe.
+static_assert(!tc::safe_comparison<char, char16_t>);
+static_assert(!tc::safe_comparison<char8_t, char32_t>);
+// chars and ints are unsafe.
+static_assert(!tc::safe_comparison<char, short>);
+static_assert(!tc::safe_comparison<char32_t, int>);
+
+UNITTESTDEF(cmp_equal) {
+	// both signed
+	_ASSERT(tc::cmp_equal(static_cast<int>(17), static_cast<long long>(17)));
+	_ASSERT(tc::cmp_equal(static_cast<int>(-42), static_cast<long long>(-42)));
+
+	// left signed
+	_ASSERT(tc::cmp_equal(static_cast<int>(17), static_cast<unsigned>(17)));
+	_ASSERT(!tc::cmp_equal(static_cast<int>(-42), static_cast<unsigned>(42)));
+
+	// right signed
+	_ASSERT(tc::cmp_equal(static_cast<unsigned>(17), static_cast<int>(17)));
+	_ASSERT(!tc::cmp_equal(static_cast<unsigned>(42), static_cast<int>(-42)));
+}
+
+UNITTESTDEF(cmp_less) {
+	// both signed
+	_ASSERT(tc::cmp_less(static_cast<int>(17), static_cast<long long>(42)));
+	_ASSERT(tc::cmp_less(static_cast<int>(-42), static_cast<long long>(-17)));
+
+	// left signed
+	_ASSERT(tc::cmp_less(static_cast<int>(17), static_cast<unsigned>(42)));
+	_ASSERT(tc::cmp_less(static_cast<int>(-42), static_cast<unsigned>(42)));
+
+	// right signed
+	_ASSERT(tc::cmp_less(static_cast<unsigned>(17), static_cast<int>(42)));
+	_ASSERT(!tc::cmp_less(static_cast<unsigned>(42), static_cast<int>(-42)));
+}
diff --git a/tc/base/static_polymorphism.h b/tc/base/static_polymorphism.h
index c8896d4..e6bd247 100644
--- a/tc/base/static_polymorphism.h
+++ b/tc/base/static_polymorphism.h
@@ -10,6 +10,11 @@
 
 #include "assert_defs.h"
 #include <type_traits>
+#include "tag_type.h"
+
+namespace tc {
+	DEFINE_TAG_TYPE(unchecked_derived_cast_tag)
+}
 
 #define STATIC_VIRTUAL_METHOD_NAME( Name ) \
 	Name ## _ImplDoNotCallDirectly
@@ -20,50 +25,42 @@
 #define STATIC_VIRTUAL_FALLBACK_NAME( Name ) \
 	Name ## _FallbackDoNotCallDirectly
 
-#define STATIC_VIRTUAL_FORWARD_IMPL( Mod, Name, Decoration ) \
+#define STATIC_VIRTUAL_FORWARD_IMPL( Name, Decoration, DerivedCast, MaybeUncheckedDerivedCastTagWithComma ) \
 	template<typename Derived_=Derived, typename... Args> \
-	Mod \
-	auto Name(Args&&... args) Decoration return_decltype_xvalue_by_ref_MAYTHROW( \
-		STATIC_VIRTUAL_DISPATCH_IMPL_NAME(Name)(static_cast<Derived_ Decoration>(tc::derived_cast<Derived_>(*MSVC_WORKAROUND_THIS)), std::forward<Args>(args)...) \
+	constexpr auto Name(Args&&... args) Decoration return_decltype_xvalue_by_ref_MAYTHROW( \
+		STATIC_VIRTUAL_DISPATCH_IMPL_NAME(Name)(static_cast<Derived_ Decoration>( DerivedCast<Derived_>(*MSVC_WORKAROUND_THIS)), MaybeUncheckedDerivedCastTagWithComma std::forward<Args>(args)...) \
 	)
 
-#define STATIC_VIRTUAL_FORWARD_ALL_IMPL( Mod, Name ) \
-	using Name ## _derived_type = Derived; \
-	using Name ## _declaring_type = this_type; \
-	STATIC_VIRTUAL_FORWARD_IMPL( Mod, Name, & ) \
-	STATIC_VIRTUAL_FORWARD_IMPL( Mod, Name, const& ) \
-	STATIC_VIRTUAL_FORWARD_IMPL( Mod, Name, && ) \
-	STATIC_VIRTUAL_FORWARD_IMPL( Mod, Name, const&& )
+#define STATIC_VIRTUAL_FORWARD_ALL_IMPL( Name, DerivedCast, MaybeUncheckedDerivedCastTagWithComma ) \
+	STATIC_VIRTUAL_FORWARD_IMPL( Name, &, DerivedCast, TC_FWD(MaybeUncheckedDerivedCastTagWithComma) ) \
+	STATIC_VIRTUAL_FORWARD_IMPL( Name, const&, DerivedCast, TC_FWD(MaybeUncheckedDerivedCastTagWithComma) ) \
+	STATIC_VIRTUAL_FORWARD_IMPL( Name, &&, DerivedCast, TC_FWD(MaybeUncheckedDerivedCastTagWithComma) ) \
+	STATIC_VIRTUAL_FORWARD_IMPL( Name, const&&, DerivedCast, TC_FWD(MaybeUncheckedDerivedCastTagWithComma) )
 
-#define STATIC_VIRTUAL_MOD( Mod, Name ) \
+#define STATIC_VIRTUAL( Name ) \
 	template<typename Derived_, typename... Args> \
 	static \
-	Mod \
-	auto STATIC_VIRTUAL_DISPATCH_IMPL_NAME(Name)(Derived_&& derived, Args&&... args) return_decltype_xvalue_by_ref_MAYTHROW( \
+	constexpr auto STATIC_VIRTUAL_DISPATCH_IMPL_NAME(Name)(Derived_&& derived, Args&&... args) return_decltype_xvalue_by_ref_MAYTHROW( \
 		std::forward<Derived_>(derived).STATIC_VIRTUAL_METHOD_NAME(Name)(std::forward<Args>(args)...) \
 	) \
-	STATIC_VIRTUAL_FORWARD_ALL_IMPL( Mod, Name )
-
-#define STATIC_VIRTUAL( Name ) \
-	STATIC_VIRTUAL_MOD( BOOST_PP_EMPTY(), Name ) 
+	using Name ## _derived_type = Derived; \
+	using Name ## _declaring_type = this_type; \
+	STATIC_VIRTUAL_FORWARD_ALL_IMPL( Name, tc::derived_cast, BOOST_PP_EMPTY() )
 
-#define STATIC_VIRTUAL_CONSTEXPR( Name ) \
-	STATIC_VIRTUAL_MOD( constexpr, Name )
+#define UNCHECKED_STATIC_VIRTUAL( Name ) \
+	STATIC_VIRTUAL( Name ) \
+	STATIC_VIRTUAL_FORWARD_ALL_IMPL( Name, tc::unchecked_derived_cast, TC_FWD(tc::unchecked_derived_cast_tag,) )
 
 // force implementation as static method, using STATIC_FINAL_MOD(static, Name) 
-#define STATIC_STATIC_VIRTUAL_MOD( Mod, Name ) \
+#define STATIC_STATIC_VIRTUAL( Name ) \
 	using Name ## _derived_type = Derived; \
 	using Name ## _declaring_type = this_type; \
 	template<typename Derived_=Derived, typename... Args_> \
-	Mod \
-	static auto Name(Args_&& ...args) return_decltype_xvalue_by_ref_MAYTHROW( \
+	static constexpr auto Name(Args_&& ...args) return_decltype_xvalue_by_ref_MAYTHROW( \
 		Derived_:: STATIC_VIRTUAL_METHOD_NAME(Name) (std::forward<Args_>(args)...) \
 	)
 
-#define STATIC_STATIC_VIRTUAL( Name ) \
-	STATIC_STATIC_VIRTUAL_MOD( BOOST_PP_EMPTY(), Name )
-
-#define STATIC_VIRTUAL_WITH_DEFAULT_IMPL_MOD(Mod, Name) \
+#define STATIC_VIRTUAL_WITH_DEFAULT_IMPL_MOD( Mod, Name ) \
 	STATIC_VIRTUAL( Name ) \
 	Mod \
 	auto STATIC_VIRTUAL_METHOD_NAME( Name )
@@ -94,9 +91,6 @@
 	__VA_ARGS__ \
 	auto STATIC_VIRTUAL_METHOD_NAME( Name )
 
-#define STATIC_OVERRIDE_MOD_BASE(Name, ...) \
-	STATIC_OVERRIDE_MOD_DECLARING_BASE(this_type::Name ## _declaring_type, Name, __VA_ARGS__)
-
 #define STATIC_OVERRIDE_MOD_DECLARING(Mod, Declaring, Name) \
 	STATIC_OVERRIDE_MOD_DECLARING_BASE(TC_FWD(Declaring), Name, \
 		static_assert( \
@@ -117,7 +111,7 @@
 
 #define STATIC_VIRTUAL_WITH_FALLBACK_MOD(Mod, Name) \
 	template<typename Derived_, typename... Args> requires (!requires { std::declval<Derived_>().STATIC_VIRTUAL_METHOD_NAME(Name)( std::declval<Args>()... ); }) \
-	static \
+	static constexpr \
 	auto STATIC_VIRTUAL_DISPATCH_IMPL_NAME(Name)(Derived_&& derived, Args&&... args) return_decltype_xvalue_by_ref_MAYTHROW( \
 		std::forward<Derived_>(derived).STATIC_VIRTUAL_FALLBACK_NAME(Name)(std::forward<Args>(args)...) \
 	) \
diff --git a/tc/base/string_template_param.h b/tc/base/string_template_param.h
index 23ce4b0..8707c81 100644
--- a/tc/base/string_template_param.h
+++ b/tc/base/string_template_param.h
@@ -11,12 +11,25 @@
 #include "type_traits_fwd.h"
 
 namespace tc {
+	namespace literal_range_adl {
+		template <typename T, auto... Ts>
+		struct literal_range;
+	}
+	using literal_range_adl::literal_range;
+
 	namespace no_adl {
-		template<typename Char, std::size_t N> requires tc::char_like<Char> && (!std::is_volatile<Char>::value)
+		template <typename Char, std::size_t N> requires tc::char_like<Char> && (!std::is_volatile<Char>::value)
 		struct string_template_param final {
 			consteval string_template_param(Char const (&str)[N]) noexcept {
 				for(int i=0; i<N; ++i) m_str[i]=str[i]; // avoid using library functions to prevent circular dependency on _ASSERT
 			}
+			template <auto ... Cs>
+			consteval string_template_param(literal_range<Char, Cs...>) noexcept {
+				static_assert(sizeof...(Cs) + 1 == N);
+				std::size_t idx = 0;
+				((m_str[idx++] = Cs), ...); // avoid using library functions to prevent circular dependency on _ASSERT
+				m_str[idx] = Char();
+			}
 
 			constexpr auto begin() const& noexcept {
 				return &m_str[0];
@@ -26,23 +39,23 @@ namespace tc {
 				return &m_str[N-1];
 			}
 
+			static constexpr auto size() noexcept {
+				return tc::least_uint_constant<N-1>{};
+			}
+
 			constexpr operator auto const&() const& noexcept {
 				return m_str;
 			}
 
-			using iterator = Char const*;
-			using const_iterator = iterator;
-			using value_type = Char;
-			using difference_type = std::ptrdiff_t;
-			using size_type = std::size_t;
+			constexpr Char operator[](std::size_t idx) const& noexcept {
+				return m_str[idx];
+			}
 
 			Char m_str[N];
 		};
 
-		template<typename Rng> struct constexpr_size_impl; // prevent circular dependency
-
-		template<typename Char, std::size_t N>
-		struct constexpr_size_impl<string_template_param<Char, N>> : tc::constant<N-1> {};
+		template <typename Char, auto ... Cs>
+		string_template_param(literal_range<Char, Cs...>) -> string_template_param<Char, sizeof...(Cs) + 1>;
 	}
 	using no_adl::string_template_param;
 }
diff --git a/tc/base/tag_type.h b/tc/base/tag_type.h
index 72c36ba..1092537 100644
--- a/tc/base/tag_type.h
+++ b/tc/base/tag_type.h
@@ -54,6 +54,7 @@
 namespace tc {
 	DEFINE_TAG_TYPE(aggregate_tag) // tag to distinguish constructors that aggregate their single argument from templated copy constructors
 	DEFINE_TAG_TYPE(func_tag)
+	DEFINE_TEMPLATE_TAG_TYPE(type_tag)
 
 	// tc_define_fn(func) always defines a function void func(define_fn_dummy_t)
 	// If that function did not exist, -> decltype( func(...) ) would not be
diff --git a/tc/base/track_instance.h b/tc/base/track_instance.h
index d83384a..31b77fb 100644
--- a/tc/base/track_instance.h
+++ b/tc/base/track_instance.h
@@ -23,7 +23,7 @@ namespace tc {
 				_ASSERT(!c_ptib);
 				c_ptib=this;
 			}
-			void reset_instance() const & noexcept {
+			void reset_instance() const& noexcept {
 				_ASSERT(is_instance());
 				c_ptib=nullptr;
 			};
diff --git a/tc/base/trivial_functors.h b/tc/base/trivial_functors.h
index c040650..1877674 100644
--- a/tc/base/trivial_functors.h
+++ b/tc/base/trivial_functors.h
@@ -40,6 +40,7 @@ namespace tc {
 	using no_adl::noop;
 	using no_adl::never_called;
 	using no_adl::constexpr_function;
+	using no_adl::identity;
 }
 
 // MAKE_CONSTEXPR_FUNCTION is guaranteed a constexpr function.
@@ -53,7 +54,7 @@ namespace tc {
 			}; \
 		} else { \
 			return [](auto&& ...) constexpr noexcept -> decltype(auto) { \
-				return as_constexpr(__VA_ARGS__); \
+				return tc_as_constexpr(__VA_ARGS__); \
 			}; \
 		} \
 	}()	
diff --git a/tc/base/trivial_functors.t.cpp b/tc/base/trivial_functors.t.cpp
index 4cd2ac5..e85c14d 100644
--- a/tc/base/trivial_functors.t.cpp
+++ b/tc/base/trivial_functors.t.cpp
@@ -24,7 +24,7 @@ namespace {
 		// Fits in a pointer
 		{
 			constexpr auto fn = tc::constexpr_function<int{}>();
-			auto fnOracle = []() constexpr noexcept {
+			auto const fnOracle = []() constexpr noexcept {
 				constexpr auto _ = int();
 				return _;
 			}; 
@@ -36,7 +36,7 @@ namespace {
 				int m_n;
 			};
 			constexpr auto fn = MAKE_CONSTEXPR_FUNCTION(SFoo{});
-			auto fnOracle = []() constexpr noexcept {
+			auto const fnOracle = []() constexpr noexcept {
 				constexpr auto _ = SFoo{};
 				return _;
 			}; 
@@ -45,7 +45,7 @@ namespace {
 		}
 		{
 			constexpr auto fn = MAKE_CONSTEXPR_FUNCTION(tc::constant<10>());
-			auto fnOracle = []() constexpr noexcept {
+			auto const fnOracle = []() constexpr noexcept {
 				constexpr auto _ = tc::constant<10>();
 				return _;
 			}; 
@@ -54,7 +54,7 @@ namespace {
 		}
 		{
 			constexpr auto fn = MAKE_CONSTEXPR_FUNCTION(tc::constant<tc::break_>());
-			auto fnOracle = []() constexpr noexcept {
+			auto const fnOracle = []() constexpr noexcept {
 				constexpr auto _ = tc::constant<tc::break_>();
 				return _;
 			}; 
@@ -65,7 +65,7 @@ namespace {
 		// Doesn't fit in a pointer
 		{
 			constexpr auto fn = MAKE_CONSTEXPR_FUNCTION(c_typebiggerthanpointer);
-			auto fnOracle = []() constexpr noexcept ->decltype(auto) {
+			auto const fnOracle = []() constexpr noexcept ->decltype(auto) {
 				return (c_typebiggerthanpointer);
 			}; 
 			STATICASSERTSAME(decltype(fnOracle()), TypeBiggerThanPointer const&);
diff --git a/tc/base/type_list.t.cpp b/tc/base/type_list.t.cpp
index e72fc52..6758d0d 100644
--- a/tc/base/type_list.t.cpp
+++ b/tc/base/type_list.t.cpp
@@ -8,6 +8,7 @@
 #include "assert_defs.h"
 #include "type_list.h"
 #include "../range/meta.h"
+#include "../string/char.h"
 
 namespace tc {
 	template<typename Rng>
diff --git a/tc/base/type_traits.t.cpp b/tc/base/type_traits.t.cpp
index 2e44d68..f9847ba 100644
--- a/tc/base/type_traits.t.cpp
+++ b/tc/base/type_traits.t.cpp
@@ -398,14 +398,22 @@ static_assert(
 static_assert(
 	std::is_same<
 		tc::common_reference_xvalue_as_ref_t<tc::vector<char>&, tc::string<char>&>,
-		tc::span<char>
+		std::conditional_t<
+			std::same_as<tc::iterator_t<tc::vector<char>>, tc::iterator_t<tc::string<char>>>,
+			tc::iterator_range<tc::iterator_t<tc::vector<char>>>,
+			tc::span<char>
+		>
 	>::value
 );
 
 static_assert(
 	std::is_same<
 		tc::common_reference_xvalue_as_ref_t<tc::vector<char>&, tc::string<char> const&>,
-		tc::span<char const>
+		std::conditional_t<
+			std::same_as<tc::iterator_t<tc::vector<char>>, tc::iterator_t<tc::string<char>>>,
+			tc::iterator_range<tc::iterator_t<tc::vector<char> const>>,
+			tc::span<char const>
+		>
 	>::value
 );
 
@@ -595,28 +603,28 @@ static_assert(
 
 static_assert(
 	std::is_same<
-		tc::common_reference_xvalue_as_ref_t<tc::vector<int>&, tc::subrange<tc::vector<int>&>>,
-		tc::subrange<tc::vector<int>&>
+		tc::common_reference_xvalue_as_ref_t<tc::static_vector<int, 3>&, tc::subrange<tc::static_vector<int, 3>&>>,
+		tc::subrange<tc::static_vector<int, 3>&>
 	>::value
 );
 
 static_assert(
 	std::is_same <
-		tc::common_reference_xvalue_as_ref_t<tc::vector<int>&, tc::subrange<tc::vector<int>>&>,
-		tc::subrange<tc::vector<int>&>
+		tc::common_reference_xvalue_as_ref_t<tc::static_vector<int, 3>&, tc::subrange<tc::static_vector<int, 3>>&>,
+		tc::subrange<tc::static_vector<int, 3>&>
 	>::value
 );
 
 static_assert(
 	std::is_same<
-		tc::common_reference_xvalue_as_ref_t<tc::subrange<tc::vector<int>&>, tc::subrange<tc::vector<int>>&>,
-		tc::subrange<tc::vector<int>&>
+		tc::common_reference_xvalue_as_ref_t<tc::subrange<tc::static_vector<int, 3>&>, tc::subrange<tc::static_vector<int, 3>>&>,
+		tc::subrange<tc::static_vector<int, 3>&>
 	>::value
 );
 
 static_assert(
 	std::is_same<
-		tc::common_reference_xvalue_as_ref_t<tc::span<int>, tc::subrange<tc::vector<int>&>>,
+		tc::common_reference_xvalue_as_ref_t<tc::span<int>, tc::subrange<tc::static_vector<int, 3>&>>,
 		tc::span<int>
 	>::value
 );
@@ -635,40 +643,66 @@ static_assert(
 
 static_assert(
 	std::is_same<
-		tc::common_reference_prvalue_as_val_t<tc::vector<int>&, tc::subrange<tc::vector<int>&>>,
-		tc::subrange<tc::vector<int>&>
+		tc::common_reference_prvalue_as_val_t<tc::static_vector<int, 3>&, tc::subrange<tc::static_vector<int, 3>&>>,
+		tc::subrange<tc::static_vector<int, 3>&>
 	>::value
 );
 
 static_assert(
 	std::is_same <
-		tc::common_reference_prvalue_as_val_t<tc::vector<int>&, tc::subrange<tc::vector<int>>&>,
-		tc::subrange<tc::vector<int>&>
+		tc::common_reference_prvalue_as_val_t<tc::static_vector<int, 3>&, tc::subrange<tc::static_vector<int, 3>>&>,
+		tc::subrange<tc::static_vector<int, 3>&>
 	>::value
 );
 
 static_assert(
 	std::is_same<
-		tc::common_reference_prvalue_as_val_t<tc::subrange<tc::vector<int>&>, tc::subrange<tc::vector<int>>&>,
-		tc::subrange<tc::vector<int>&>
+		tc::common_reference_prvalue_as_val_t<tc::subrange<tc::static_vector<int, 3>&>, tc::subrange<tc::static_vector<int, 3>>&>,
+		tc::subrange<tc::static_vector<int, 3>&>
 	>::value
 );
 
 static_assert(
-	!tc::has_common_reference_xvalue_as_ref<tc::vector<int>&, tc::subrange<tc::vector<int>>>
+	!tc::has_common_reference_xvalue_as_ref<tc::static_vector<int, 3>&, tc::subrange<tc::static_vector<int, 3>>>
 );
 
 static_assert(
-	!tc::has_common_reference_xvalue_as_ref<tc::vector<int>, tc::subrange<tc::vector<int>&>>
+	!tc::has_common_reference_xvalue_as_ref<tc::static_vector<int, 3>, tc::subrange<tc::static_vector<int, 3>&>>
 );
 
 static_assert(
 	std::is_same<
 		tc::common_reference_prvalue_as_val_t<tc::vector<char>&, tc::string<char>&>,
-		tc::span<char>
+		std::conditional_t<
+			std::same_as<tc::iterator_t<tc::vector<char>>, tc::iterator_t<tc::string<char>>>,
+			tc::iterator_range<tc::iterator_t<tc::vector<char>>>,
+			tc::span<char>
+		>
+	>::value
+);
+
+namespace
+{
+	struct my_vector
+	{
+		tc::vector<int> impl;
+
+		auto begin() & { return tc::begin(impl); }
+		auto end() & { return tc::begin(impl); }
+	};
+}
+
+static_assert(
+	std::is_same<
+		tc::common_reference_prvalue_as_val_t<tc::vector<int>&, my_vector&>,
+		tc::iterator_range<tc::iterator_t<tc::vector<int>>>
 	>::value
 );
 
+static_assert(
+	!tc::has_common_reference_prvalue_as_val<tc::vector<int>&, my_vector>
+);
+
 namespace {
 struct S;
 tc::unordered_set<S const*> g_sets;
@@ -698,11 +732,11 @@ struct S{
 		_ASSERT(tc::end(g_sets) != g_sets.find(this));
 	}
 
-	void foo() const & {
+	void foo() const& {
 		_ASSERT(tc::end(g_sets) != g_sets.find(this));
 	}
 
-	void foo() const && {
+	void foo() const&& {
 		_ASSERT(tc::end(g_sets) != g_sets.find(this));
 	}
 
@@ -846,7 +880,7 @@ UNITTESTDEF(minTest) {
 				tc::transform(
 					tc::transform(
 						tc::iota(0,1),
-						[&](int n) noexcept -> S&& {
+						[&](int const n) noexcept -> S&& {
 							return std::move(s2[n]);
 						}
 					),
@@ -873,7 +907,7 @@ UNITTESTDEF(minTest) {
 		S s2[2];
 		tc::projected(
 			tc::fn_min(),
-			[&](int n) noexcept -> S&& {
+			[&](int const n) noexcept -> S&& {
 				return std::move(s2[n]);
 			}
 		)(0,1).foo();
@@ -976,6 +1010,8 @@ namespace is_instance_or_derived_test {
 	using CInstantiation2 = CTemplate2<bool, void>;
 
 	static_assert(tc::instance_or_derived<CInstantiation1, CTemplate1>);
+	static_assert(!tc::instance_or_derived<CInstantiation1&, CTemplate1>);
+	static_assert(!tc::is_instance_or_derived<CInstantiation1&, CTemplate1>::value);
 	STATICASSERTSAME((CTemplate1<int, bool>), (typename tc::is_instance_or_derived<CInstantiation1, CTemplate1>::base_instance));
 	STATICASSERTSAME((tc::type::list<int, bool>), (typename tc::is_instance_or_derived<CInstantiation1, CTemplate1>::arguments));
 
diff --git a/tc/base/type_traits_fwd.h b/tc/base/type_traits_fwd.h
index 617475d..23f67f6 100644
--- a/tc/base/type_traits_fwd.h
+++ b/tc/base/type_traits_fwd.h
@@ -16,6 +16,7 @@
 #include <boost/preprocessor/facilities/overload.hpp>
 #include <boost/preprocessor/punctuation/remove_parens.hpp>
 #include <boost/preprocessor/seq/cat.hpp>
+#include <boost/integer.hpp>
 
 #include <type_traits>
 #include <limits>
@@ -187,17 +188,14 @@ namespace tc {
 	template<typename T>
 	using remove_rvalue_reference_t=typename tc::remove_rvalue_reference<T>::type;
 
-	//////////////////////////////////////////////////////////////////////////
-	// constant
-
-	template<auto t>
-	using constant = std::integral_constant<decltype(t), t>;
-
 	//////////////////////////
 	// type classification concepts
 
 	template<typename T>
-	concept char_type = tc::type::find_unique<tc::type::list<char, wchar_t, char16_t, char32_t>, std::remove_cv_t<T>>::found;
+	concept char_type = tc::type::find_unique<tc::type::list<char, wchar_t, char8_t, char16_t, char32_t>, std::remove_cv_t<T>>::found;
+
+	template< typename T >
+	concept char_ptr = std::is_pointer<T>::value && tc::char_type<std::remove_pointer_t<T>>;
 
 	namespace char_like_detail {
 		template<typename T>
@@ -208,13 +206,17 @@ namespace tc {
 	concept char_like = char_like_detail::char_like_impl<T>;
 
 	template< typename T >
-	concept decayed=std::same_as< T, tc::decay_t<T> >;
+	concept decayed = std::same_as< T, tc::decay_t<T> >;
 
 	template<typename T>
-	concept actual_integer=std::integral<T> && (!std::same_as<std::remove_cv_t<T>, bool>) && (!tc::char_type<T>);
+	concept actual_integer = std::integral<T> && (!std::same_as<std::remove_cv_t<T>, bool>) && (!tc::char_type<T>);
+	template<typename T>
+	concept actual_unsigned_integer = tc::actual_integer<T> && std::unsigned_integral<T>;
+	template<typename T>
+	concept actual_signed_integer = tc::actual_integer<T> && std::signed_integral<T>;
 
 	template<typename T>
-	concept actual_arithmetic=tc::actual_integer<T> || std::floating_point<T>;
+	concept actual_arithmetic = tc::actual_integer<T> || std::floating_point<T>;
 
 	template<typename T>
 	concept empty_type = std::is_empty<T>::value && std::is_trivial<std::remove_cv_t<T>>::value;
@@ -222,6 +224,15 @@ namespace tc {
 	template<typename T>
 	concept enum_type = std::is_enum<T>::value;
 
+	//////////////////////////////////////////////////////////////////////////
+	// constant
+
+	template<auto t>
+	using constant = std::integral_constant<decltype(t), t>;
+
+	template<tc::actual_integer auto N> requires (N >= 0)
+	using least_uint_constant = tc::constant<static_cast<typename boost::uint_value_t<N>::least>(N)>;
+
 	//////////////////////////
 	// derived_from
 
@@ -304,7 +315,7 @@ template<typename TInstance, template<TC_PP_PARAMS_TYPE_ENUM(seq)> typename Temp
 using BOOST_PP_CAT(is_instance_or_derived, suffix) = \
 	decltype( \
 		no_adl::BOOST_PP_CAT(is_instance_or_derived_detector, suffix)<Template>::detector( \
-			std::declval<std::remove_cvref_t<TInstance>*>() \
+			std::declval<std::conditional_t<std::is_reference<TInstance>::value, /* anything that cannot bind to Template<...>* */ int*, std::remove_cvref_t<TInstance>*>>() \
 		) \
 	); \
 template<typename TInstance, template<TC_PP_PARAMS_TYPE_ENUM(seq)> typename Template> \
@@ -670,7 +681,6 @@ namespace tc {
 	//		d) SFINAE friendly: Yes
 	template<typename... T>
 	using common_type_t = typename tc::common_type_decayed<tc::decay_t<T>...>::type;
-
 	namespace no_adl {
 		template<typename T>
 		struct common_type_decayed<T> {
diff --git a/tc/base/utility.h b/tc/base/utility.h
index 31d89d4..6fc8e1a 100644
--- a/tc/base/utility.h
+++ b/tc/base/utility.h
@@ -52,16 +52,6 @@ namespace tc {
 	template<typename IntSequence>
 	using is_contiguous_integer_sequence = decltype(is_contiguous_integer_sequence_impl::is_contiguous_integer_sequence(std::declval<IntSequence>()));
 
-	//////////////////////////////////////////////////////////////////////////
-	// next
-
-	template<typename T>
-	constexpr auto next(T&& x) noexcept(noexcept(++std::declval<std::decay_t<T&&>&>()) && std::is_nothrow_copy_constructible<T>::value) {
-		auto t = std::forward<T>(x);
-		++t;
-		return t;
-	}
-
 	//////////////////////////////////////////////////////////////////////////
 	// select_nth
 
@@ -86,6 +76,32 @@ namespace tc {
 //////////////////////////////////////////////////////////////////////////
 // get
 
+namespace tc {
+	namespace no_adl {
+		template<typename IndexSequence, typename Tuple>
+		struct tuple_types_impl;
+
+		template<std::size_t... I, typename Tuple>
+		struct tuple_types_impl<std::index_sequence<I...>, Tuple> final {
+			using type = tc::type::list<std::tuple_element_t<I, Tuple>...>;
+		};
+	}
+
+	template<typename Tuple>
+	struct is_tuple_like /*not final*/: tc::constant<false> {};
+
+	template<typename Tuple> requires
+		tc::actual_integer<decltype(std::tuple_size<std::remove_reference_t<Tuple>>::value)> &&
+		requires { typename no_adl::tuple_types_impl<std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>, std::remove_cvref_t<Tuple>>::type; }
+	struct is_tuple_like<Tuple> /*not final*/ : tc::constant<true>
+	{
+		using types = typename no_adl::tuple_types_impl<std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple>>::value>, std::remove_cvref_t<Tuple>>::type;
+	};
+
+	template<typename T>
+	concept tuple_like = tc::is_tuple_like<T>::value;
+}
+
 namespace tc_get_impl_adl { // Outside tc namespace to avoid finding tc::get leading to infinite recursion.
 #ifndef __clang__
 	// Suppress unqualified lookup, because of https://developercommunity.visualstudio.com/t/vc-unqualified-lookup-finds-function-in-unrelated/1570914
@@ -93,13 +109,12 @@ namespace tc_get_impl_adl { // Outside tc namespace to avoid finding tc::get lea
 	template<typename T> void get() = delete;
 	template<std::size_t I> void get() = delete;
 #endif
-
-	template<typename T, typename Tuple>
+	template<typename T, typename Tuple, std::enable_if_t<tc::type::find_unique<typename tc::is_tuple_like<Tuple>::types, T>::found>* = nullptr>
 	constexpr auto get_impl(Tuple&& tpl) return_decltype_xvalue_by_ref_noexcept(
 		/*adl*/get<T>(std::forward<Tuple>(tpl))
 	)
 
-	template<std::size_t I, typename Tuple>
+	template<std::size_t I, typename Tuple, std::enable_if_t<I < std::tuple_size<std::remove_reference_t<Tuple>>::value>* = nullptr>
 	constexpr auto get_impl(Tuple&& tpl) return_decltype_xvalue_by_ref_noexcept(
 		/*adl*/get<I>(std::forward<Tuple>(tpl))
 	)
@@ -115,6 +130,11 @@ namespace tc_get_impl {
 	[[nodiscard]] constexpr auto get(Tuple&& tpl) return_decltype_xvalue_by_ref_noexcept(
 		tc_get_impl_adl::get_impl<I>(std::forward<Tuple>(tpl))
 	)
+
+	template<typename T, typename Src> requires std::same_as<T, std::remove_cvref_t<Src>>
+	[[nodiscard]] constexpr decltype(auto) get(Src&& src) noexcept {
+		return std::forward<Src>(src);
+	}
 }
 
 namespace tc {
@@ -189,7 +209,7 @@ namespace tc
 }
 
 //////////////////////////////////////////////////////////////////////////
-// as_constexpr
+// tc_as_constexpr
 
 namespace tc::as_constexpr_no_adl {
 	namespace {
@@ -205,7 +225,7 @@ namespace tc::as_constexpr_no_adl {
 }
 
 #if defined(__clang__) // https://bugs.llvm.org/show_bug.cgi?id=32766
-#define as_constexpr(...) \
+#define tc_as_constexpr(...) \
 	([]() constexpr noexcept -> auto const& { \
 		struct SConstexprInit final { \
 			static constexpr auto value() noexcept { return []() constexpr noexcept { return __VA_ARGS__; }; } \
@@ -213,7 +233,7 @@ namespace tc::as_constexpr_no_adl {
 		return tc::as_constexpr_no_adl::SValueHolder<SConstexprInit>::value; \
 	}())
 #else
-#define as_constexpr(...) \
+#define tc_as_constexpr(...) \
 	([]() constexpr noexcept -> auto const& { \
 		struct SConstexprInit final { \
 			static constexpr auto value() noexcept { return __VA_ARGS__; } \
@@ -222,53 +242,6 @@ namespace tc::as_constexpr_no_adl {
 	}())
 #endif
 
-//////////////////////////////////////////////////////////////////////////
-// cmp_equal/cmp_less/cmp_greater...
-
-namespace tc { // TODO c++20: replace these functions with std versions
-	template< tc::actual_integer T, tc::actual_integer U >
-	constexpr bool cmp_equal( T t, U u ) noexcept
-	{
-	    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
-	        return t == u;
-	    else if constexpr (std::is_signed_v<T>)
-	        return t < 0 ? false : static_cast<std::make_unsigned_t<T>>(t) == u;
-	    else
-	        return u < 0 ? false : t == static_cast<std::make_unsigned_t<U>>(u);
-	}
-	 
-	template< typename T, typename U>
-	constexpr auto cmp_not_equal( T t, U u ) return_decltype_noexcept(
-		!cmp_equal(t, u)
-	)
-	 
-	template< tc::actual_integer T, tc::actual_integer U>
-	constexpr bool cmp_less( T t, U u ) noexcept
-	{
-	    if constexpr (std::is_signed_v<T> == std::is_signed_v<U>)
-	        return t < u;
-	    else if constexpr (std::is_signed_v<T>)
-	        return t < 0 ? true : static_cast<std::make_unsigned_t<T>>(t) < u;
-	    else
-	        return u < 0 ? false : t < static_cast<std::make_unsigned_t<U>>(u);
-	}
-	 
-	template< typename T, typename U>
-	constexpr auto cmp_greater( T t, U u ) return_decltype_noexcept(
-	    cmp_less(u, t)
-	)
-	 
-	template< typename T, typename U >
-	constexpr auto cmp_less_equal( T t, U u ) return_decltype_noexcept(
-	    !cmp_greater(t, u)
-	)
-	 
-	template< typename T, typename U >
-	constexpr auto cmp_greater_equal( T t, U u ) return_decltype_noexcept(
-	    !cmp_less(t, u)
-	)
-}
-
 namespace tc {
 	// Pass cheaply-copied types by value and others by reference to const.
 	template<typename T>
diff --git a/tc/compat.t.cpp b/tc/compat.t.cpp
index ac6c5db..a96480d 100644
--- a/tc/compat.t.cpp
+++ b/tc/compat.t.cpp
@@ -102,7 +102,7 @@ UNITTESTDEF( boost_iterator_range_compat ) {
 
 	TEST_RANGE_EQUAL(baul_exp, baul_r);
 
-	auto baul_our_r = tc::slice(baul);
+	auto baul_our_r = tc::all(baul);
 	TEST_RANGE_EQUAL(baul_exp, baul_our_r);
 
 }
@@ -111,7 +111,7 @@ UNITTESTDEF( boost_range_traits_compat ) {
 	TEST_init_hack(tc::vector, unsigned long, original, {1,2,3,4,5,6,7,8});
 	TEST_init_hack(tc::vector, unsigned long, exp, {2,4,6,8});
 
-	auto fr = tc::filter(original, [](unsigned long i) noexcept { return i%2==0; });
+	auto fr = tc::filter(original, [](unsigned long const i) noexcept { return i%2==0; });
 
 	STATIC_ASSERT(std::is_same<decltype(std::begin(fr)), decltype(tc::begin(fr))>::value);
 
diff --git a/tc/const.t.cpp b/tc/const.t.cpp
index 395f5ec..43ea612 100644
--- a/tc/const.t.cpp
+++ b/tc/const.t.cpp
@@ -23,7 +23,7 @@ UNITTESTDEF( const_range ) {
 
 	tc::vector<int> v = original;
 
-	auto mutable_range = tc::slice(v); TEST_RANGE_LENGTH(mutable_range, 8);
+	auto mutable_range = tc::all(v); TEST_RANGE_LENGTH(mutable_range, 8);
 
 	TEST_RANGE_EQUAL(original, mutable_range);
 	TEST_RANGE_NOT_EQUAL(modified, mutable_range);
@@ -32,8 +32,7 @@ UNITTESTDEF( const_range ) {
 	TEST_RANGE_NOT_EQUAL(original, mutable_range);
 
 	v = original;
-	auto const_range = tc::const_slice(v); TEST_RANGE_LENGTH(const_range, 8);
-	STATICASSERTSAME(decltype(tc::const_slice(v)), decltype(tc::slice(tc::as_const(v))), "wrong const type");
+	auto const_range = tc::all(tc::as_const(v)); TEST_RANGE_LENGTH(const_range, 8);
 
 	TEST_RANGE_EQUAL(original, const_range);
 	TEST_RANGE_NOT_EQUAL(modified, const_range);
diff --git a/tc/container/cont_assign.h b/tc/container/cont_assign.h
index 67ddb77..30f1887 100644
--- a/tc/container/cont_assign.h
+++ b/tc/container/cont_assign.h
@@ -25,7 +25,9 @@ namespace tc {
 
 	namespace cont_assign_default {
 		namespace detail {
-			template<typename Cont, typename Rng0, tc::appendable<Cont&>... Rng> requires std::same_as<std::remove_cvref_t<Cont>, Rng0> && tc::safely_assignable_from<Cont&, Rng0&&>
+			template<typename Cont, typename Rng0, tc::appendable<Cont&>... Rng>
+				requires (!std::same_as<tc::iterator_t<Cont>, tc::iterator_t<Cont const>>) // we assume "deep const" <=> "assignment assigns elements"
+					&& std::same_as<std::remove_cvref_t<Cont>, Rng0> && tc::safely_assignable_from<Cont&, Rng0&&>
 			constexpr void cont_assign_impl(Cont&& cont, Rng0&& rng0, Rng&&... rng) MAYTHROW {
 				cont=std::forward<Rng0>(rng0);
 				if constexpr(0<sizeof...(Rng)) {
diff --git a/tc/container/cont_assign.t.cpp b/tc/container/cont_assign.t.cpp
new file mode 100644
index 0000000..c8f7a3a
--- /dev/null
+++ b/tc/container/cont_assign.t.cpp
@@ -0,0 +1,45 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "../base/assert_defs.h"
+#include "cont_assign.h"
+#include "container.h"
+#include "../unittest.h"
+#include "../range/empty_range.h"
+#include "../range/literal_range.h"
+
+UNITTESTDEF(cont_assign_vec) {
+	tc::vector<int> vec;
+
+	tc::cont_assign(vec, tc::literal_range_of<1, 2, 3, 4, 5, 6>);
+	TEST_RANGE_EQUAL(vec, (tc::literal_range_of<1, 2, 3, 4, 5, 6>));
+
+	tc::cont_assign(vec, tc::literal_range_of<10, 20, 30>, tc::literal_range_of<40>);
+	TEST_RANGE_EQUAL(vec, (tc::literal_range_of<10, 20, 30, 40>));
+
+	tc::cont_assign(vec);
+	TEST_RANGE_EQUAL(vec, tc::empty_range{});
+}
+
+UNITTESTDEF(cont_assign_slice) {
+	tc::vector<int> vec = {-1, -1, 0, 0, 0, -1, -1};
+
+	tc::cont_assign(tc::slice(vec, tc::begin(vec) + 2, tc::end(vec) - 2), tc::literal_range_of<1, 2, 3>);
+	TEST_RANGE_EQUAL(vec, (tc::literal_range_of<-1, -1, 1, 2, 3, -1, -1>));
+}
+
+UNITTESTDEF(cont_assign_take_drop) {
+	tc::vector<int> vec = {0, 0, 0, -1, 0, 0, 0};
+
+	tc::cont_assign(tc::begin_next<tc::return_take>(vec, 3), tc::literal_range_of<1, 2, 3>);
+	tc::cont_assign(tc::begin_next<tc::return_drop>(vec, 4), tc::literal_range_of<4, 5, 6>);
+	TEST_RANGE_EQUAL(vec, (tc::literal_range_of<1, 2, 3, -1, 4, 5, 6>));
+
+	tc::cont_assign(tc::begin_next<tc::return_take>(vec, 3), tc::begin_next<tc::return_drop>(vec, 4));
+	TEST_RANGE_EQUAL(vec, (tc::literal_range_of<4, 5, 6, -1, 4, 5, 6>));
+}
diff --git a/tc/container/container.h b/tc/container/container.h
index 857dce6..a8db258 100644
--- a/tc/container/container.h
+++ b/tc/container/container.h
@@ -18,6 +18,7 @@
 #include <map>
 #include <unordered_map>
 #include <unordered_set>
+#include <list>
 
 #if defined(TC_PRIVATE) && !defined(__cpp_lib_generic_unordered_lookup)
 	#include <boost/multi_index_container.hpp>
diff --git a/tc/container/container_traits.h b/tc/container/container_traits.h
index 581c399..11e5dba 100644
--- a/tc/container/container_traits.h
+++ b/tc/container/container_traits.h
@@ -30,8 +30,8 @@ namespace tc {
 
 TC_HAS_MEM_FN_XXX_CONCEPT_DEF( sort, &)
 TC_HAS_MEM_FN_XXX_CONCEPT_DEF( reverse, &)
-TC_HAS_MEM_FN_XXX_CONCEPT_DEF( splice, &, std::declval<typename T::const_iterator>(), std::declval<T>() ) // pretty good indication that datastructure is list-like: assume erase(itBegin,itEnd) is cheap and preserves iterators
-TC_HAS_MEM_FN_XXX_CONCEPT_DEF( splice_after, &, std::declval<typename T::const_iterator>(), std::declval<T>() ) // pretty good indication that datastructure is forward_list-like
+TC_HAS_MEM_FN_XXX_CONCEPT_DEF( splice, &, std::declval<tc::iterator_t<T const>>(), std::declval<T>() ) // pretty good indication that datastructure is list-like: assume erase(itBegin,itEnd) is cheap and preserves iterators
+TC_HAS_MEM_FN_XXX_CONCEPT_DEF( splice_after, &, std::declval<tc::iterator_t<T const>>(), std::declval<T>() ) // pretty good indication that datastructure is forward_list-like
 TC_HAS_MEM_FN_XXX_CONCEPT_DEF( lower_bound, const&, std::declval<typename T::key_type const&>() ) // pretty good indication that datastructure is tree-like: assume erase(itBegin,itEnd) is cheap and preserves iterators
 TC_HAS_MEM_FN_XXX_CONCEPT_DEF( assign, &, std::declval<tc::range_value_t<T&> const*>(), std::declval<tc::range_value_t<T&> const*>() )
 TC_HAS_MEM_FN_XXX_CONCEPT_DEF( size, /*not const&, files might flush*/ )
diff --git a/tc/container/insert.h b/tc/container/insert.h
index 4d90364..a82b1e8 100644
--- a/tc/container/insert.h
+++ b/tc/container/insert.h
@@ -155,7 +155,7 @@ namespace tc {
 
 	// std::map::try_emplace enforces eager construction of the key_type object
 	template<typename Key, typename Val, typename Compare, typename Alloc, typename K, typename... Args>
-	auto map_try_emplace(tc::map<Key, Val, Compare, Alloc>& map, K&& key, Args&& ...args) MAYTHROW -> std::pair<typename tc::map<Key, Val, Compare, Alloc>::iterator, bool> {
+	auto map_try_emplace(tc::map<Key, Val, Compare, Alloc>& map, K&& key, Args&& ...args) MAYTHROW -> std::pair<tc::iterator_t<tc::map<Key, Val, Compare, Alloc>>, bool> {
 		if (auto it = map.lower_bound(key); tc::end(map) == it || map.key_comp()(key, it->first)) {
 			// MSVC 19.29 does not correctly parse the following statement, if tc_move is used instead of tc_move_always.
 			return std::make_pair( tc::cont_must_emplace_before(map, tc_move_always(it), std::piecewise_construct, std::forward_as_tuple(std::forward<K>(key)), std::forward_as_tuple(std::forward<Args>(args)...)), true );
diff --git a/tc/container/string.h b/tc/container/string.h
index dc01624..4e6e824 100644
--- a/tc/container/string.h
+++ b/tc/container/string.h
@@ -8,14 +8,16 @@
 
 #pragma once
 #include <string>
+#include <string_view>
 #include "../base/type_traits_fwd.h"
+#include "../base/return_decltype.h"
 
 namespace tc {
 	namespace no_adl {
-		template<typename Char, typename=void>
+		template<typename Char>
 		struct char_traits_selector;
 
-		template<typename Char> requires tc::char_type<Char> && (!(std::is_same<Char, char>::value && std::is_signed<char>::value))
+		template<typename Char> requires tc::char_like<Char> && (!(std::is_same<Char, char>::value && std::is_signed<char>::value))
 		struct char_traits_selector<Char> final {
 			using type = std::char_traits<Char>;
 		};
@@ -53,4 +55,10 @@ namespace tc {
 	// Therefore we introduce tc::string with tc::char_traits as the CharTraits to make comparisons between char ranges consistent.
 	template<typename Char, typename Alloc=std::allocator<Char>>
 	using string = std::basic_string<Char, tc::char_traits<Char>, Alloc>;
+
 }
+
+template <typename Alloc> requires std::is_signed<char>::value
+struct std::hash<std::basic_string<char, tc::char_traits<char>, Alloc>> {
+	auto operator()(std::basic_string<char, tc::char_traits<char>, Alloc> const& str) const& return_decltype_MAYTHROW(std::hash<std::string_view>{}(std::string_view(str.data(), str.size())))
+};
diff --git a/tc/create.t.cpp b/tc/create.t.cpp
index d3c826e..2519aa9 100644
--- a/tc/create.t.cpp
+++ b/tc/create.t.cpp
@@ -32,13 +32,13 @@ UNITTESTDEF( create_range ) {
 
 	tc::string<char> str = "string";
 
-	auto arr_r = tc::make_view(arr); TEST_RANGE_LENGTH(arr_r, 7);
-	auto v_r = tc::slice(v); TEST_RANGE_LENGTH(v_r, 8);
+	auto arr_r = tc::all(arr); TEST_RANGE_LENGTH(arr_r, 7);
+	auto v_r = tc::all(v); TEST_RANGE_LENGTH(v_r, 8);
 
 	auto sub_r = tc::slice_by_interval(v_r, tc::make_interval(2, 5)); TEST_RANGE_LENGTH(sub_r, 3);
 	TEST_RANGE_EQUAL(exp_sub_r, sub_r);
 
-	auto str_r = tc::slice(str); TEST_RANGE_LENGTH(str_r, 6);
+	auto str_r = tc::all(str); TEST_RANGE_LENGTH(str_r, 6);
 
 	auto wchar_ir = tc::slice_by_interval(mwch, tc::make_interval(0, 8)); TEST_RANGE_LENGTH(wchar_ir, 8);
 }
diff --git a/tc/dense_map.h b/tc/dense_map.h
index 6bc09e1..3ecf696 100644
--- a/tc/dense_map.h
+++ b/tc/dense_map.h
@@ -11,7 +11,9 @@
 #include "base/enum.h"
 #include "base/tag_type.h"
 #include "base/as_lvalue.h"
+#include "algorithm/algorithm.h"
 #include "algorithm/compare.h"
+#include "container/cont_assign.h"
 #include "range/iota_range.h"
 #include "range/zip_range.h"
 #include "range/cartesian_product_adaptor.h"
@@ -34,10 +36,11 @@ namespace tc {
 				return tc::end(c_rngsete);
 			}
 
-			using const_iterator = decltype(tc::begin(c_rngsete));
-			using iterator = const_iterator;
+			static constexpr auto size() {
+				return tc::least_uint_constant<2>{};
+			}
 
-			static constexpr std::size_t index_of(bool b) noexcept {
+			static constexpr std::size_t index_of(bool const b) noexcept {
 				return tc::to_underlying(b);
 			}
 #ifdef _MSC_VER
@@ -46,32 +49,6 @@ namespace tc {
 #endif
 		};
 
-		template<>
-		struct constexpr_size_impl<all_values<bool>> : tc::constant<tc::explicit_cast<std::uint8_t>(2)> {};
-
-		template<>
-		struct [[nodiscard]] all_values<std::strong_ordering> final {
-			static auto constexpr c_rngsetorders = tc::make_array(tc::aggregate_tag, std::strong_ordering::less, std::strong_ordering::equal, std::strong_ordering::greater);
-
-		public:
-			static constexpr auto begin() noexcept {
-				return tc::begin(c_rngsetorders);
-			}
-			static constexpr auto end() noexcept {
-				return tc::end(c_rngsetorders);
-			}
-
-			using const_iterator = decltype(tc::begin(c_rngsetorders));
-			using iterator = const_iterator;
-
-			static constexpr std::size_t index_of(std::strong_ordering order) noexcept {
-				return tc::find_unique<tc::return_element_index>(c_rngsetorders, order);
-			}
-		};
-
-		template<>
-		struct constexpr_size_impl<all_values<std::strong_ordering>> : tc::constant<tc::explicit_cast<std::uint8_t>(3)> {};
-
 		template<>
 		struct [[nodiscard]] all_values<std::weak_ordering> final {
 			static auto constexpr c_rngsetorders = tc::make_array(tc::aggregate_tag, std::weak_ordering::less, std::weak_ordering::equivalent, std::weak_ordering::greater);
@@ -84,17 +61,15 @@ namespace tc {
 				return tc::end(c_rngsetorders);
 			}
 
-			using const_iterator = decltype(tc::begin(c_rngsetorders));
-			using iterator = const_iterator;
+			static constexpr auto size() noexcept {
+				return tc::least_uint_constant<3>{};
+			}
 
 			static constexpr std::size_t index_of(std::weak_ordering order) noexcept {
 				return tc::find_unique<tc::return_element_index>(c_rngsetorders, order);
 			}
 		};
 
-		template<>
-		struct constexpr_size_impl<all_values<std::weak_ordering>> : tc::constant<tc::explicit_cast<std::uint8_t>(3)> {};
-
 		template<>
 		struct [[nodiscard]] all_values<std::partial_ordering> final {
 			static auto constexpr c_rngsetorders = tc::make_array(tc::aggregate_tag, std::partial_ordering::less, std::partial_ordering::equivalent, std::partial_ordering::greater, std::partial_ordering::unordered);
@@ -107,16 +82,14 @@ namespace tc {
 				return tc::end(c_rngsetorders);
 			}
 
-			using const_iterator = decltype(tc::begin(c_rngsetorders));
-			using iterator = const_iterator;
+			static constexpr auto size() noexcept {
+				return tc::least_uint_constant<4>{};
+			}
 
 			static constexpr std::size_t index_of(std::partial_ordering order) noexcept {
 				return tc::find_unique<tc::return_element_index>(c_rngsetorders, order);
 			}
 		};
-
-		template<>
-		struct constexpr_size_impl<all_values<std::partial_ordering>> : tc::constant<tc::explicit_cast<std::uint8_t>(4)> {};
 		
 		template<typename... Ts>
 		struct [[nodiscard]] all_values<tc::tuple<Ts...>> final : decltype(tc::cartesian_product(tc::all_values<Ts>()...)) {
@@ -124,9 +97,6 @@ namespace tc {
 				return tc::find_unique<tc::return_element_index>(tc::cartesian_product(tc::all_values<Ts>()...), tpl);
 			}
 		};
-
-		template<typename... Ts>
-		struct constexpr_size_impl<all_values<tc::tuple<Ts...>>> : tc::constant<tc::size_raw(tc::cartesian_product(tc::all_values<Ts>()...))> {};
 	}
 
 	// all_values are views
@@ -192,9 +162,9 @@ namespace tc {
 				: tc_member_init_cast( m_a, tc::aggregate_tag, std::forward<First>(first), std::forward<Second>(second), std::forward<Args>(args)... )
 			{}
 
-			template< typename Func > requires tc::is_invocable<Func&, Key>::value
+			template< typename Func > requires tc::invocable<Func&, Key>
 			constexpr dense_map(tc::func_tag_t, Func func) MAYTHROW
-				: tc_member_init_cast( m_a, tc::func_tag, [&func](std::size_t n) MAYTHROW -> Value { // force return of Value
+				: tc_member_init_cast( m_a, tc::func_tag, [&func](std::size_t const n) MAYTHROW -> Value { // force return of Value
 					//STATICASSERTSAME(decltype(tc_at_nodebug(c_rngkey, n))&&, Key&&); does not hold, if c_rngkey is all_values<tuple<...>>
 					// TODO Remove static_cast<Key> below after we change counting_iterator::operator*() to return small trivial by value.
 					static_assert(
@@ -205,7 +175,7 @@ namespace tc {
 				} )
 			{}
 
-			template< typename Func > requires (!tc::is_invocable<Func&, Key>::value)
+			template< typename Func > requires (!tc::invocable<Func&, Key>)
 			constexpr dense_map(tc::func_tag_t, Func func) MAYTHROW
 				: dense_map(tc::func_tag, [&](auto const key) MAYTHROW -> Value {
 					return {tc::func_tag, [&](auto const... keys) return_decltype_MAYTHROW( tc::invoke(func, key, keys...) )};
@@ -240,8 +210,8 @@ namespace tc {
 			template< typename ValuePri, typename ValueSec >
 			constexpr dense_map(Key keyPri, ValuePri&& valPri, ValueSec&& valSec) MAYTHROW :
 				dense_map(
-					CONDITIONAL_RVALUE_AS_REF(tc_front_nodebug(c_rngkey) == keyPri, std::forward<ValuePri>(valPri), std::forward<ValueSec>(valSec)),
-					CONDITIONAL_RVALUE_AS_REF(tc_front_nodebug(c_rngkey) == keyPri, std::forward<ValueSec>(valSec), std::forward<ValuePri>(valPri))
+					tc_conditional_rvalue_as_ref(tc_front_nodebug(c_rngkey) == keyPri, std::forward<ValuePri>(valPri), std::forward<ValueSec>(valSec)),
+					tc_conditional_rvalue_as_ref(tc_front_nodebug(c_rngkey) == keyPri, std::forward<ValueSec>(valSec), std::forward<ValuePri>(valPri))
 				)
 			{}
 			template <typename Value2>
@@ -304,35 +274,27 @@ namespace tc {
 				return static_cast<Value const&&>((*this)[key]);
 			}
 
-			template<ENABLE_SFINAE>
-			[[nodiscard]] constexpr auto data() & return_decltype_noexcept(
-				SFINAE_VALUE(m_a).data()
-			)
-
-			template<ENABLE_SFINAE>
-			[[nodiscard]] constexpr auto data() const& return_decltype_noexcept(
-				SFINAE_VALUE(m_a).data()
-			)
-
 			// comparison
 			template<typename Key_, typename LHS, typename RHS>
 			friend constexpr bool operator==( dense_map<Key_, LHS> const& lhs, dense_map<Key_, RHS> const& rhs ) noexcept;
 
 			// iterators
-			using iterator = tc::iterator_t< Array >;
-			using const_iterator = tc::iterator_t< Array const >;
-			constexpr const_iterator begin() const& noexcept {
+			constexpr auto begin() const& noexcept {
 				return tc::begin(m_a);
 			}
-			constexpr const_iterator end() const& noexcept {
+			constexpr auto end() const& noexcept {
 				return tc::end(m_a);
 			}
-			constexpr iterator begin() & noexcept {
+			constexpr auto begin() & noexcept {
 				return tc::begin(m_a);
 			}
-			constexpr iterator end() & noexcept {
+			constexpr auto end() & noexcept {
 				return tc::end(m_a);
 			}
+
+			static constexpr auto size() noexcept {
+				return tc::constexpr_size<tc::all_values<Key>>;
+			}
 			
 #ifdef _DEBUG
 			friend void uninitialize_impl(dense_map& dm) noexcept {
@@ -364,13 +326,6 @@ namespace tc {
 	} // namespace dense_map_adl
 	using dense_map_adl::dense_map;
 
-	namespace no_adl {
-		template<tc::instance_or_derived<tc::dense_map> DenseMapOrDerived>
-		struct constexpr_size_impl<DenseMapOrDerived>
-			: constexpr_size<tc::all_values<tc::type::front_t<typename tc::is_instance_or_derived<DenseMapOrDerived, dense_map>::arguments>>>
-		{};
-	} // namespace no_adl
-
 	template <typename Map, typename T>
 	concept indexed_by = std::same_as<typename Map::dense_map_key_type, T>;
 
@@ -443,8 +398,9 @@ namespace tc {
 				return tc::end(c_rngmapkv);
 			}
 
-			using const_iterator = decltype(tc::begin(c_rngmapkv));
-			using iterator = const_iterator;
+			static constexpr auto size() noexcept {
+				return tc::constexpr_size<baserng>;
+			}
 
 			static constexpr std::size_t index_of(tc::dense_map<Key, Value> const& mapkv) noexcept {
 				return c_baserng.index_of(tc::apply([&](auto... key) { return tc::make_tuple(mapkv[key]...); }, tc::all_constants<Key>));
@@ -454,11 +410,6 @@ namespace tc {
 			static auto constexpr _natvis_begin = false; // natvis visualizations cannot call functions even if they are constexpr.
 #endif
 		};
-
-		template<typename Key, typename Value>
-		struct constexpr_size_impl<tc::all_values<tc::dense_map<Key,Value>>>
-			: tc::constant<tc::pow(tc::constexpr_size<tc::all_values<Value>>::value, tc::constexpr_size<tc::all_values<Key>>::value)>
-		{};
 	}
 
 	namespace less_key_adl {
@@ -468,7 +419,9 @@ namespace tc {
 		}
 	}
 
-	template<tc::instance_or_derived<tc::dense_map> DenseMap, tc::instance_or_derived<tc::dense_map>... DenseMaps>
+	template<typename DenseMap, typename... DenseMaps> requires
+		tc::instance_or_derived<std::remove_reference_t<DenseMap>, tc::dense_map> &&
+		(... && tc::instance_or_derived<std::remove_reference_t<DenseMaps>, tc::dense_map>)
 	[[nodiscard]] constexpr auto zip(DenseMap&& dm, DenseMaps&&... dms) noexcept {
 		static_assert((tc::indexed_by<std::remove_reference_t<DenseMaps>, typename std::remove_reference_t<DenseMap>::dense_map_key_type> && ...));
 
@@ -481,11 +434,29 @@ namespace tc {
 		});
 	}
 
-	template<tc::instance_or_derived<tc::dense_map> DenseMap>
+	template<typename DenseMap> requires tc::instance_or_derived<std::remove_reference_t<DenseMap>, tc::dense_map>
 	[[nodiscard]] constexpr auto enumerate(DenseMap&& dm) noexcept {
 		using Key = typename std::remove_reference_t<DenseMap>::dense_map_key_type;
 		return tc::zip(tc::dense_map<Key, Key>(tc::func_tag, tc::identity()), std::forward<DenseMap>(dm));
 	}
+
+	namespace dense_map_adl {
+		template<
+			typename NestedDenseMap,
+			typename FirstKey = typename std::remove_reference_t<NestedDenseMap>::dense_map_key_type,
+			typename SecondKey = typename std::remove_reference_t<tc::range_value_t<NestedDenseMap>>::dense_map_key_type
+		>
+		auto join_impl(NestedDenseMap&& dm) noexcept
+			-> tc::dense_map<
+				tc::tuple<FirstKey, SecondKey>,
+				tc::xvalue_decay_t<decltype(std::declval<NestedDenseMap>()[std::declval<FirstKey>()][std::declval<SecondKey>()])>
+			>
+		{
+			return {tc::func_tag, [&](auto const key0, auto const key1) return_decltype_xvalue_by_ref_noexcept(
+				std::forward<NestedDenseMap>(dm)[key0][key1]
+			)};
+		}
+	}
 }
 
 #define TC_DENSE_MAP_SUPPORT_1(class_name) \
diff --git a/tc/dense_map.t.cpp b/tc/dense_map.t.cpp
index 1fab013..5d66d1d 100644
--- a/tc/dense_map.t.cpp
+++ b/tc/dense_map.t.cpp
@@ -52,7 +52,7 @@ UNITTESTDEF(dense_map_with_non_moveable_type) {
 
 #ifndef _MSC_VER // MSVC support for guaranteed copy elision seems to be incomplete.
 	// https://developercommunity.visualstudio.com/t/chained-copy-elision-with-function-resul/1404507
-	[[maybe_unused]] auto anoncopyFromTransform = tc::make_dense_map<MyEnum>(47, 11).transform([](int n) {
+	[[maybe_unused]] auto anoncopyFromTransform = tc::make_dense_map<MyEnum>(47, 11).transform([](int const n) {
 		return NonCopyNonMoveable(n);
 	});
 #endif
@@ -82,7 +82,7 @@ namespace {
 }
 
 UNITTESTDEF(test_dense_map_recursive_func_tag) {
-	tc::dense_map<MyEnum, tc::dense_map<MyEnum, tc::dense_map<bool, int>>> aaan(tc::func_tag, [n = 0](auto e1, auto e2, bool b3) mutable noexcept {
+	tc::dense_map<MyEnum, tc::dense_map<MyEnum, tc::dense_map<bool, int>>> aaan(tc::func_tag, [n = 0](auto e1, auto e2, bool const b3) mutable noexcept {
 		return n++ | tc::to_underlying(e1) << 6 | tc::to_underlying(e2) << 5 | tc::to_underlying(b3) << 4;
 	});
 
@@ -127,11 +127,11 @@ UNITTESTDEF(test_make_array_from_range) {
 }
 
 UNITTESTDEF(test_dense_map_with_ordering_key) {
-	constexpr tc::dense_map<std::strong_ordering, int> dm1(1,2,3);
-	static_assert(dm1[std::strong_ordering::less] == 1);
-	static_assert(dm1[std::strong_ordering::equivalent] == 2);
-	static_assert(dm1[std::strong_ordering::equal] == 2);
-	static_assert(dm1[std::strong_ordering::greater] == 3);
+	constexpr tc::dense_map<std::weak_ordering, int> dm1(1,2,3);
+	static_assert(dm1[std::weak_ordering::less] == 1);
+	static_assert(dm1[std::weak_ordering::equivalent] == 2);
+	static_assert(dm1[std::weak_ordering::equivalent] == 2);
+	static_assert(dm1[std::weak_ordering::greater] == 3);
 	static_assert(tc::equal(dm1, tc::iota(1, 4)));
 
 	constexpr tc::dense_map<std::weak_ordering, int> dm2(1,2,3);
diff --git a/tc/enumset.h b/tc/enumset.h
index f97eab1..f6e2fa3 100644
--- a/tc/enumset.h
+++ b/tc/enumset.h
@@ -47,7 +47,7 @@ namespace tc {
 		template< typename Enum >
 		struct enumset /*final*/
 			: tc::setlike<>
-			, tc::range_iterator_from_index< enumset<Enum>, typename tc::all_values<Enum>::const_iterator >
+			, tc::range_iterator_from_index< enumset<Enum>, tc::iterator_t<tc::all_values<Enum> const> >
 		{
 		private:
 			using this_type = enumset;
@@ -227,12 +227,15 @@ namespace tc {
 	namespace no_adl {
 		template<typename Enum>
 		struct [[nodiscard]] all_values<tc::enumset<Enum>> final {
+		public:
+			static constexpr auto size() noexcept {
+				constexpr auto size_all_values_enum = tc::constexpr_size<tc::all_values<Enum>>();
+				static_assert(size_all_values_enum < std::size_t(std::numeric_limits<std::size_t>::digits));
+				return tc::least_uint_constant<std::size_t(1) << size_all_values_enum>{};
+			}
+
 		private:
-			static_assert(tc::constexpr_size<tc::all_values<Enum>>::value < std::numeric_limits<std::size_t>::digits);
-			using storage_type = typename tc::integer<tc::constexpr_size<tc::all_values<Enum>>::value + 1>::unsigned_;
-			friend constexpr_size_impl<all_values<tc::enumset<Enum>>>;
-			static storage_type constexpr c_nSize = tc::explicit_cast<storage_type>(1) << tc::constexpr_size<tc::all_values<Enum>>::value;
-			static auto constexpr c_rngsete = tc::transform(tc::iota_range_constant<tc::explicit_cast<storage_type>(0), c_nSize>(), [](auto n) noexcept {
+			static auto constexpr c_rngsete = tc::transform(tc::iota_range_constant<static_cast<decltype(size().value)>(0), size().value>(), [](auto const n) noexcept {
 				return tc::enumset<Enum>(tc::enumset_from_underlying_tag, n);
 			});
 
@@ -244,16 +247,10 @@ namespace tc {
 				return tc::end(c_rngsete);
 			}
 
-			using const_iterator = decltype(all_values::begin());
-			using iterator = const_iterator;
-
 			static constexpr std::size_t index_of(tc::enumset<Enum> const& sete) noexcept {
 				return sete.m_bitset_();
 			}
 		};
-
-		template<typename Enum>
-		struct constexpr_size_impl<all_values<tc::enumset<Enum>>> : tc::constant<tc::all_values<tc::enumset<Enum>>::c_nSize> {};
 	}
 
 	namespace explicit_convert_adl {
diff --git a/tc/interval.h b/tc/interval.h
index eea36c6..5d830f9 100644
--- a/tc/interval.h
+++ b/tc/interval.h
@@ -155,7 +155,7 @@ namespace tc {
 
 		private:
 			template< typename TPos, typename TExtent >
-			static constexpr interval<T> from_extent_impl( TPos&& pos, TExtent&& extent, tc::lohi lohi ) noexcept {
+			static constexpr interval<T> from_extent_impl( TPos&& pos, TExtent&& extent, tc::lohi const lohi ) noexcept {
 				switch_no_default(lohi) {
 					case tc::lo: {
 						auto end = pos + std::forward<TExtent>(extent);
@@ -183,7 +183,7 @@ namespace tc {
 
 		public:
 			template< typename TPos, typename TExtent >
-			[[nodiscard]] static constexpr interval<T> from_extent( TPos&& pos, TExtent&& extent, tc::lohi lohi ) noexcept
+			[[nodiscard]] static constexpr interval<T> from_extent( TPos&& pos, TExtent&& extent, tc::lohi const lohi ) noexcept
 			{
 				return from_extent_impl(std::forward<TPos>(pos), std::forward<TExtent>(extent), lohi);
 			}
@@ -195,7 +195,7 @@ namespace tc {
 			}
 
 			template< typename TPos, typename TExtent >
-			[[nodiscard]] static constexpr interval<T> from_extent( TPos&& pos, TExtent&& extent, EAlign ealign ) noexcept
+			[[nodiscard]] static constexpr interval<T> from_extent( TPos&& pos, TExtent&& extent, EAlign const ealign ) noexcept
 			{
 				switch_no_default(ealign) {
 					case ealignLOW: {
@@ -389,7 +389,7 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 				);
 			}
 
-			[[nodiscard]] constexpr newT Val(EAlign ealign) const& noexcept {
+			[[nodiscard]] constexpr newT Val(EAlign const ealign) const& noexcept {
 				switch_no_default(ealign) {
 					case ealignLOW:
 						return (*this)[tc::lo];
@@ -460,7 +460,7 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 				return !(intvl[tc::hi]<(*this)[tc::lo]) && !((*this)[tc::hi]<intvl[tc::lo]);
 			}
 
-			template<tc::instance_or_derived<tc::interval> Rhs>
+			template<typename Rhs> requires tc::instance_or_derived<std::remove_reference_t<Rhs>, tc::interval>
 			constexpr interval<T>& operator&=(Rhs&& rhs) & noexcept {
 				static_assert(
 					std::is_same<newT, tc::range_value_t<Rhs>>::value,
@@ -496,7 +496,7 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 				tc::assign_max( (*this)[tc::hi], std::forward<U>(u) );
 			}
 
-			template<tc::instance_or_derived<tc::interval> Rhs>
+			template<typename Rhs> requires tc::instance_or_derived<std::remove_reference_t<Rhs>, tc::interval>
 			constexpr interval<T>& operator|=(Rhs&& rhs) & noexcept {
 				static_assert(
 					std::is_same<newT, tc::range_value_t<Rhs>>::value,
@@ -653,12 +653,10 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 		return interval<tc::decay_t<T>>(std::forward<T>(value), tc_modified(value, tc::nextafter_inplace(_)));
 	}
 
-	template<typename T>
-	[[nodiscard]] constexpr auto make_empty_interval(T&& value)
-		return_decltype_MAYTHROW(tc::make_interval(std::forward<T>(value), tc::decay_copy(value)))
-
 	namespace interval_adl {
-		template<tc::instance_or_derived<tc::interval> Lhs, tc::instance_or_derived<tc::interval> Rhs>
+		template<typename Lhs, typename Rhs> requires
+			tc::instance_or_derived<std::remove_reference_t<Lhs>, tc::interval> &&
+			tc::instance_or_derived<std::remove_reference_t<Rhs>, tc::interval>
 		[[nodiscard]] constexpr auto operator&(Lhs&& lhs, Rhs&& rhs) noexcept {
 			static_assert(
 				std::is_same<tc::range_value_t<Lhs>, tc::range_value_t<Rhs>>::value,
@@ -672,7 +670,9 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 			);
 		}
 
-		template<tc::instance_or_derived<tc::interval> Lhs, tc::instance_or_derived<tc::interval> Rhs>
+		template<typename Lhs, typename Rhs> requires
+			tc::instance_or_derived<std::remove_reference_t<Lhs>, tc::interval> &&
+			tc::instance_or_derived<std::remove_reference_t<Rhs>, tc::interval>
 		[[nodiscard]] constexpr auto operator|(Lhs&& lhs, Rhs&& rhs) noexcept {
 			static_assert(
 				std::is_same<tc::range_value_t<Lhs>, tc::range_value_t<Rhs>>::value,
@@ -966,7 +966,7 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 						itintervalAdd = m_cont.emplace_hint(itinterval, interval);
 					}
 
-					for (; itinterval != tc::end(m_cont) && !(interval[tc::hi] < (*itinterval)[tc::hi]); ) {
+					while (itinterval != tc::end(m_cont) && !(interval[tc::hi] < (*itinterval)[tc::hi])) {
 						itinterval = m_cont.erase(itinterval);
 					}
 
@@ -1133,7 +1133,7 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 				return closest_missing(t, tc::lo);
 			}
 
-			T const& closest_missing(T const& t, tc::lohi lohi) const& noexcept {
+			T const& closest_missing(T const& t, tc::lohi const lohi) const& noexcept {
 				if (tc_auto_cref(itinterval, upper_bound<tc::return_element_before_or_null>(t))) {
 					if( t < (*itinterval)[tc::hi] ) {
 						return (*itinterval)[lohi];
@@ -1308,6 +1308,10 @@ MODIFY_WARNINGS(((suppress)(4552))) // '-': operator has no effect; expected ope
 				return m_cont;
 			}
 
+			void filter_inplace(auto func) & noexcept {
+				tc::filter_inplace(m_cont, func);
+			}
+
 			template<typename OtherSetOrVectorImpl, typename Func>
 			auto for_each_intersecting_interval(interval_set<T, TInterval, OtherSetOrVectorImpl> const& intvlset, Func func) const& MAYTHROW  -> tc::common_type_t<
 				decltype(tc::continue_if_not_break(func, *tc::begin(m_cont), *tc::begin(intvlset.m_cont), std::declval<TInterval&>())),
diff --git a/tc/interval.t.cpp b/tc/interval.t.cpp
index 3650b6e..40b35b0 100644
--- a/tc/interval.t.cpp
+++ b/tc/interval.t.cpp
@@ -50,7 +50,7 @@ UNITTESTDEF(interval_center) {
 #if TC_PRIVATE
 	tc::chrono::sys_days const tp = tc::chrono::year_month_day(2000,1,1).time_point();
 
-	auto AddDays=[](tc::chrono::sys_days const& tpBase, int nDays) noexcept {
+	auto AddDays=[](tc::chrono::sys_days const& tpBase, int const nDays) noexcept {
 		return tpBase + tc::chrono::days(nDays);
 	};
 #endif
@@ -161,7 +161,7 @@ UNITTESTDEF(minmax_interval) {
 }
 
 UNITTESTDEF(linear_interval_transform) {
-	auto const Test = [](auto srcLo, auto srcHi, auto dstLo, auto dstHi, auto... pairsrcdst) noexcept {
+	static auto constexpr Test = [](auto srcLo, auto srcHi, auto dstLo, auto dstHi, auto... pairsrcdst) noexcept {
 		tc::linear_interval_transform const intvltrans(tc::interval(srcLo, srcHi), tc::interval(dstLo, dstHi));
 		tc::for_each(
 			tc::forward_as_tuple(
diff --git a/tc/interval_types.h b/tc/interval_types.h
index e490af6..290d003 100644
--- a/tc/interval_types.h
+++ b/tc/interval_types.h
@@ -23,7 +23,7 @@ TC_DEFINE_ENUM_WITH_OFFSET(EAlign, ealign, -1,
 )
 
 namespace EAlign_adl {
-	[[nodiscard]] constexpr EAlign operator-(EAlign ealign) noexcept {
+	[[nodiscard]] constexpr EAlign operator-(EAlign const ealign) noexcept {
 		return ealignLOW+(ealignHIGH-ealign);
 	}
 }
diff --git a/tc/optional.h b/tc/optional.h
index ba48785..27be82a 100644
--- a/tc/optional.h
+++ b/tc/optional.h
@@ -114,16 +114,71 @@ namespace tc {
 			template<typename... Args>
 			void construct(Args&& ... args) & noexcept(noexcept(std::declval<storage_for<T>&>().ctor(std::forward<Args>(args)...))) {
 				_ASSERT(m_bValue); // allow querying the flag to prevent double-construction
-				try {
-					_ASSERT(!m_bInsideDtor);
+				_ASSERT(!m_bInsideDtor);
+				if constexpr (noexcept(m_oValue.ctor(std::forward<Args>(args)...))) {
 					m_oValue.ctor(std::forward<Args>(args)...);
-				} catch( ... ) {
-					m_bValue = false;
-					throw;
+				} else {
+					try {	
+						m_oValue.ctor(std::forward<Args>(args)...); // MAYTHROW
+					} catch( ... ) {
+						m_bValue = false;
+						throw; // MSVC and gcc: throw in catch block of a noexcept function triggers warning even if try block never throws
+					}
 				}
 			}
 		};
 
+		template<tc::empty_type TEmpty>
+		struct optional<TEmpty> {
+			constexpr optional() noexcept = default;
+			constexpr optional(std::nullopt_t) noexcept {}
+
+			template<typename... Args>
+			constexpr optional(std::in_place_t, Args&& ... args) noexcept(std::is_nothrow_constructible_v<TEmpty, Args&&...>) : m_bValue(true) {
+				tc::discard(TEmpty(tc_move_if_owned(args)...));
+			}
+
+			constexpr void reset() & noexcept {
+				m_bValue = false;
+			}
+			template<typename... Args>
+			constexpr TEmpty emplace(Args&& ... args) & noexcept(std::is_nothrow_constructible_v<TEmpty, Args&&...>) {
+				TEmpty result(tc_move_if_owned(args)...);
+				m_bValue = true;
+				return result;
+			}
+	
+			constexpr optional& operator=(std::nullopt_t) & noexcept {
+				reset();
+				return *this;
+			}
+	
+			constexpr bool has_value() const& noexcept {
+				return m_bValue;
+			}
+			constexpr explicit operator bool() const& noexcept {
+				return has_value();
+			}
+	
+		private:
+			struct pointer final {
+				TEmpty m_t;
+				constexpr TEmpty* operator->() && noexcept { return std::addressof(m_t); }
+			};
+		public:
+			constexpr auto operator->() const& noexcept {
+				_ASSERT(*this);
+				return pointer();
+			}
+			constexpr TEmpty operator*() const& noexcept {
+				_ASSERT(*this);
+				return TEmpty();
+			}
+
+		private:
+			bool m_bValue = false;
+		};
+
 		template<typename TRef> requires std::is_reference<TRef>::value
 		struct optional<TRef> {
 			template<typename U>
@@ -133,25 +188,15 @@ namespace tc {
 			constexpr optional(std::nullopt_t) noexcept {}
 
 			template<typename U> requires tc::safely_constructible_from<TRef, U&&>
-			explicit(!tc::safely_convertible_to<U&&, TRef>) constexpr optional(U&& u) noexcept(noexcept(static_cast<TRef>(std::forward<U>(u))))
+			constexpr optional(U&& u) noexcept(noexcept(static_cast<TRef>(std::forward<U>(u))))
 				: m_pt(std::addressof(tc::as_lvalue(static_cast<TRef>(std::forward<U>(u))))) // tc::safely_constructible_from makes sure no reference to temporary is created
 			{}
 
 			template<typename TOptional> requires
-				tc::safely_constructible_from<TRef, tc::apply_cvref_t<tc::type::only_t<typename tc::is_instance<std::remove_reference_t<TOptional>, tc::no_adl::optional>::arguments>, TOptional&&>>
-			explicit(!tc::safely_convertible_to<tc::apply_cvref_t<tc::type::only_t<typename tc::is_instance<std::remove_reference_t<TOptional>, tc::no_adl::optional>::arguments>, TOptional&&>, TRef>)
+				tc::safely_constructible_from<TRef, decltype(*std::declval<TOptional>()) >
 			constexpr optional(TOptional&& rhs) noexcept
 				: m_pt([&]() noexcept {
-					return rhs ? rhs.m_pt : nullptr;
-				}())
-			{}
-
-			template<typename TOptional> requires
-				tc::safely_constructible_from<TRef, tc::apply_cvref_t<tc::type::only_t<typename tc::is_instance<std::remove_reference_t<TOptional>, std::optional>::arguments>, TOptional&&>>
-			explicit(!tc::safely_convertible_to<tc::apply_cvref_t<tc::type::only_t<typename tc::is_instance<std::remove_reference_t<TOptional>, std::optional>::arguments>, TOptional&&>, TRef>)
-			constexpr optional(TOptional&& rhs) noexcept
-				: m_pt([&]() noexcept {
-					return rhs ? std::addressof(*rhs) : nullptr;
+					return rhs ? std::addressof(tc::as_lvalue(*tc_move_if_owned(rhs))) : nullptr;
 				}())
 			{}
 
@@ -197,16 +242,32 @@ namespace tc {
 		};
 	}
 	using no_adl::optional;
+
+	template <typename T>
+	using optional_reference_or_value = std::conditional_t<
+		tc::empty_type<std::remove_cvref_t<T>> || std::is_rvalue_reference<T&&>::value,
+		tc::optional<std::remove_cvref_t<T>>,
+		tc::optional<T>
+	>;
+
+	template <typename T> requires (!tc::empty_type<T>)
+	[[nodiscard]] constexpr optional_reference_or_value<T&> make_optional_reference_or_value(T& ref) noexcept {
+		return ref;
+	}
+	template <typename T> requires tc::empty_type<std::remove_cvref_t<T>> || std::is_rvalue_reference<T&&>::value
+	[[nodiscard]] constexpr optional_reference_or_value<T> make_optional_reference_or_value(T&& ref) noexcept {
+		return {std::in_place, std::forward<T>(ref)};
+	}
 }
 
 namespace tc {
 	template<typename Optional, typename T>
 	[[nodiscard]] constexpr decltype(auto) value_or( Optional&& optional, T&& t ) MAYTHROW {
-		if constexpr( tc::instance_or_derived<T, tc::make_lazy> ) {
+		if constexpr( tc::instance_or_derived<std::remove_reference_t<T>, tc::make_lazy> ) {
 			static_assert( !tc::has_actual_common_reference<decltype(*std::declval<Optional>()), T&&> ); // Should value_or(std::optional<make_lazy<T>>(), make_lazy<T>()) return make_lazy<T>&& or T?
-			return CONDITIONAL_PRVALUE_AS_VAL(optional, *std::forward<Optional>(optional), std::forward<T>(t)());
+			return tc_conditional_prvalue_as_val(optional, *std::forward<Optional>(optional), std::forward<T>(t)());
 		} else {
-			return CONDITIONAL_RVALUE_AS_REF(optional, *std::forward<Optional>(optional), std::forward<T>(t));
+			return tc_conditional_rvalue_as_ref(optional, *std::forward<Optional>(optional), std::forward<T>(t));
 		}
 	}
 
@@ -313,17 +374,6 @@ namespace tc {
 	DEFINE_FN2(std::make_optional, fn_make_optional);
 }
 
-namespace boost {
-	template<typename T>
-	struct range_mutable_iterator<std::optional<T>> {
-		using type = T*;
-	};
-	template<typename T>
-	struct range_const_iterator<std::optional<T>> {
-		using type = T const*;
-	};
-}
-
 namespace tc::begin_end_adl {
 	template<typename T>
 	constexpr T* begin(begin_end_tag_t, std::optional<T>& ot) noexcept {
diff --git a/tc/optional.t.cpp b/tc/optional.t.cpp
index de0fa36..3b68601 100644
--- a/tc/optional.t.cpp
+++ b/tc/optional.t.cpp
@@ -11,6 +11,33 @@
 #include "optional.h"
 #include "array.h"
 
+UNITTESTDEF(make_optional_reference_or_value) {
+	int obj = 42;
+	int const cobj = 42;
+
+	std::same_as<tc::optional<int&>> auto opt_obj = tc::make_optional_reference_or_value(obj);
+	_ASSERTEQUAL(&*opt_obj, &obj);
+
+	std::same_as<tc::optional<int const&>> auto opt_cobj = tc::make_optional_reference_or_value(cobj);
+	_ASSERTEQUAL(&*opt_cobj, &cobj);
+
+	std::same_as<tc::optional<int>> auto opt_rvalue = tc::make_optional_reference_or_value(42);
+	_ASSERTEQUAL(*opt_rvalue, 42);
+
+	struct empty {};
+	empty empty_obj;
+	empty const empty_cobj;
+
+	std::same_as<tc::optional<empty>> auto opt_empty_obj = tc::make_optional_reference_or_value(empty_obj);
+	_ASSERT(opt_empty_obj);
+
+	std::same_as<tc::optional<empty>> auto opt_empty_cobj = tc::make_optional_reference_or_value(empty_cobj);
+	_ASSERT(opt_empty_cobj);
+
+	std::same_as<tc::optional<empty>> auto opt_empty_rvalue = tc::make_optional_reference_or_value(empty());
+	_ASSERT(opt_empty_rvalue);
+}
+
 UNITTESTDEF(optional_as_range) {
 	std::optional<int> on;
 	_ASSERT(tc::empty(on));
diff --git a/tc/range/adjacent_adaptor.h b/tc/range/adjacent_adaptor.h
index b8483d0..47e639d 100644
--- a/tc/range/adjacent_adaptor.h
+++ b/tc/range/adjacent_adaptor.h
@@ -34,21 +34,21 @@ namespace tc {
 				);
 			}
 
-			template<ENABLE_SFINAE>
-			[[nodiscard]] constexpr auto size() const& noexcept -> decltype(tc::size_raw(SFINAE_VALUE(this)->base_range())) {
-				auto n = tc::size_raw(this->base_range());
-				if( n < N ) {
-					return 0;
-				} else {
-					return n - (N - 1);
-				}
+			[[nodiscard]] constexpr auto size() const& MAYTHROW requires tc::has_size<Rng> {
+				return tc::compute_range_adaptor_size<[]<typename SizeT>(SizeT const n) noexcept {
+					if( n < N ) {
+						return tc::explicit_cast<SizeT>(0);
+					} else {
+						return tc::explicit_cast<SizeT>(n - (N - 1));
+					}
+				}>(this->base_range());
 			}
 
 		private:
 			template<typename Self, typename Sink, std::size_t... i /*=0,1,...,N-2*/>
 			static constexpr auto internal_for_each(Self&& self, Sink const sink, std::index_sequence<i...>) MAYTHROW {
 				if constexpr (tc::range_with_iterators<Rng>) {
-					auto GenerateAdjacentTuples = [&]() MAYTHROW {
+					auto const GenerateAdjacentTuples = [&]() MAYTHROW {
 						auto const itEnd = tc::end(self.base_range());
 						auto it = tc::begin(self.base_range());
 						auto ait=tc::explicit_cast<std::array<
@@ -67,7 +67,7 @@ namespace tc {
 							}
 						}
 					};
-					return CONDITIONAL_PRVALUE_AS_VAL(
+					return tc_conditional_prvalue_as_val(
 						tc::size_bounded(self.base_range(), N)<N,
 						tc::constant<tc::continue_>(),
 						GenerateAdjacentTuples() // MAYTHROW
@@ -78,7 +78,7 @@ namespace tc {
 					tc_scope_exit { tc::for_each(tc::begin_next<tc::return_take>(aoval, tc::min(n, N - 1)), tc_mem_fn(.dtor)); };
 
 					return tc::for_each(std::forward<Self>(self).base_range(), [&](auto&& u) MAYTHROW {
-						auto CallSink = [&]() MAYTHROW {
+						auto const CallSink = [&]() MAYTHROW {
 							return tc::continue_if_not_break( // MAYTHROW
 								sink,
 								tc::forward_as_tuple(
@@ -246,17 +246,8 @@ namespace tc {
 		};
 	}
 
-	namespace no_adl {
-		template<tc::has_constexpr_size Rng, std::size_t N>
-		struct constexpr_size_impl<adjacent_adaptor_adl::adjacent_adaptor<Rng, N>>
-			: tc::constant<tc::constexpr_size<Rng>::value < N ? 0 : tc::constexpr_size<Rng>::value - (N - 1)>
-		{};
-
-		template<typename Rng, std::size_t N>
-		struct is_index_valid_for_move_constructed_range<adjacent_adaptor_adl::adjacent_adaptor<Rng, N, true>>
-			: tc::is_index_valid_for_move_constructed_range<Rng>
-		{};
-	}
+	template<typename Rng, std::size_t N>
+	constexpr auto enable_stable_index_on_move<adjacent_adaptor_adl::adjacent_adaptor<Rng, N, true>> = tc::stable_index_on_move<Rng>;
 
 	template<std::size_t N, typename Rng>
 	constexpr adjacent_adaptor_adl::adjacent_adaptor<Rng, N> adjacent(Rng&& rng) noexcept {
diff --git a/tc/range/cartesian_product_adaptor.h b/tc/range/cartesian_product_adaptor.h
index 0e0fc38..6167aa1 100644
--- a/tc/range/cartesian_product_adaptor.h
+++ b/tc/range/cartesian_product_adaptor.h
@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include "reverse_adaptor.h"
 #include "../array.h"
 #include "../algorithm/accumulate.h"
 
@@ -108,15 +109,12 @@ namespace tc {
 				>...
 			>> {} // unevaluated
 
-			// Use variadic tc::mul and boost::multiprecision::number?
-			constexpr std::size_t size() const& noexcept requires (... && requires { {tc::size_raw(std::declval<Rng const&>())} -> std::convertible_to<std::size_t>; }) {
-				return tc::accumulate(
-					m_tupleadaptbaserng,
-					tc::explicit_cast<std::size_t>(1),
-					[](std::size_t& nAccu, auto const& adaptbaserng) noexcept {
-						tc::assign_mul(nAccu, tc::explicit_cast<std::size_t>(tc::size_raw(adaptbaserng.base_range())));
-					}
-				);
+			constexpr auto size() const& MAYTHROW requires (... && tc::has_size<Rng>) {
+				return tc::apply([](auto const& ... rng) MAYTHROW {
+					return tc::compute_range_adaptor_size<[](auto const ... n) noexcept {
+						return tc::as_unsigned((... * n));
+					}>(rng.base_range()...);
+				}, m_tupleadaptbaserng);
 			}
 		};
 
@@ -304,7 +302,7 @@ namespace tc {
 				requires
 					(tc::has_middle_point<std::remove_reference_t<Rng0>> && ... && tc::has_middle_point<std::remove_reference_t<Rng>>)
 			{
-				bool const bAdvanced = false;
+				bool bAdvanced = false;
 				tc::for_each(
 					tc::zip(this->m_tupleadaptbaserng, idx, idxEnd),
 					[&](auto const& adaptbaserng, auto& baseidx, auto const& baseidxEnd) MAYTHROW {
@@ -321,17 +319,9 @@ namespace tc {
 		};
 	}
 
-	namespace no_adl {
-		template<bool HasIterator, tc::has_constexpr_size... Rng>
-		struct constexpr_size_impl<cartesian_product_adaptor_adl::cartesian_product_adaptor<HasIterator, Rng...>>
-			: tc::constant<(... * tc::constexpr_size<Rng>::value)>
-		{};
-
-		template<typename... Rng>
-		struct is_index_valid_for_move_constructed_range<cartesian_product_adaptor_adl::cartesian_product_adaptor</*HasIterator*/true, Rng...>>
-			: std::conjunction<tc::is_index_valid_for_move_constructed_range<Rng>...>
-		{};
-	}
+	template<typename... Rng>
+	constexpr auto enable_stable_index_on_move<cartesian_product_adaptor_adl::cartesian_product_adaptor</*HasIterator*/true, Rng...>>
+		= (tc::stable_index_on_move<Rng> && ...);
 
 	template<typename... Rng>
 	constexpr decltype(auto) cartesian_product(Rng&&... rng) noexcept {
diff --git a/tc/range/concat_adaptor.h b/tc/range/concat_adaptor.h
index 35e7ead..fd2b933 100644
--- a/tc/range/concat_adaptor.h
+++ b/tc/range/concat_adaptor.h
@@ -19,25 +19,21 @@
 #include "../algorithm/empty.h"
 #include "../tuple.h"
 
-#include "range_fwd.h"
 #include "range_adaptor.h"
 #include "index_range.h"
 #include "meta.h"
 #include "transform.h"
 #include "iota_range.h"
 #include "transform_adaptor.h"
+#include "reverse_adaptor.h"
 
 namespace tc {
 	namespace concat_adaptor_adl {
 		template<bool HasIterator, typename... Rng>
 		struct concat_adaptor_impl;
 	}
-
-	template<typename... Rng>
-	concept concatenable_with_iterators = tc::has_common_reference_prvalue_as_val<std::iter_reference_t<tc::iterator_t<Rng>>...>;
-
 	template<typename... Rng>
-	using concat_adaptor = concat_adaptor_adl::concat_adaptor_impl<concatenable_with_iterators<Rng...>, Rng...>;
+	using concat_adaptor = concat_adaptor_adl::concat_adaptor_impl<tc::ranges_with_common_reference<Rng...>, Rng...>;
 
 	namespace no_adl {
 		template<typename Rng>
@@ -103,16 +99,12 @@ namespace tc {
 				return tc::size_raw(tc::get<nconstIndex()>(m_tupleadaptbaserng).base_range());
 			}
 		public:
-			constexpr auto size() const& noexcept requires (... && tc::has_size<Rng>) {
-				return 
-					tc::accumulate(
-						tc::transform(
-							std::index_sequence_for<Rng...>(),
-							[&](auto nconstIndex) noexcept { return BaseRangeSize(nconstIndex); }
-						),
-						tc::explicit_cast<tc::common_type_t<decltype(tc::size_raw(std::declval<Rng>()))...>>(0),
-						tc::fn_assign_plus()
-					);
+			constexpr auto size() const& MAYTHROW requires (... && tc::has_size<Rng>) {
+				return tc::apply([](auto const& ... rng) MAYTHROW {
+					return tc::compute_range_adaptor_size<[](auto const ... n) noexcept {
+						return tc::as_unsigned((... + n));
+					}>(rng.base_range()...);
+				}, m_tupleadaptbaserng);
 			}
 
 			constexpr bool empty() const& noexcept {
@@ -202,7 +194,7 @@ namespace tc {
 			constexpr void correct_index(tc_index& idx) const& noexcept {
 				tc::for_each(
 					tc::make_integer_sequence<std::size_t, IndexFrom, sizeof...(Rng)>(),
-					[&](auto nconstIndex) noexcept {
+					[&](auto const nconstIndex) noexcept {
 						if (tc::at_end_index( tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range(), tc::get<nconstIndex()>(idx))) {
 							idx = create_begin_index(tc::constant<nconstIndex() + 1>());
 							return tc::continue_;
@@ -232,7 +224,7 @@ namespace tc {
 				_ASSERT(!this->at_end_index(idx));
 
 				tc::invoke_with_constant<std::index_sequence_for<Rng...>>(
-					[&](auto nconstIndex) noexcept { 
+					[&](auto const nconstIndex) noexcept { 
 						tc::increment_index(tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range(), tc::get<nconstIndex()>(idx));
 						correct_index<nconstIndex()>(idx);
 					},
@@ -248,10 +240,10 @@ namespace tc {
 					tc::is_equality_comparable<tc_index>::value
 			{
 				tc::invoke_with_constant<std::make_index_sequence<sizeof...(Rng)+1>>(
-					[&](auto nconstIndexStart) noexcept {
+					[&](auto const nconstIndexStart) noexcept {
 						tc::for_each(
 							tc::make_reverse_integer_sequence<int, 0, nconstIndexStart() + 1>(),
-							[&](auto nconstIndex) noexcept {
+							[&](auto const nconstIndex) noexcept {
 								if constexpr (sizeof...(Rng) == nconstIndex()) {
 									 idx = create_end_index(tc::constant<nconstIndex() - 1>());
 									 return tc::continue_;
@@ -277,7 +269,7 @@ namespace tc {
 MODIFY_WARNINGS(((suppress)(4544))) // 'Func2': default template argument ignored on this template declaration
 			STATIC_FINAL_MOD(constexpr, dereference_index)(tc_index const& idx) const& noexcept -> decltype(auto) {
 				return tc::invoke_with_constant<std::index_sequence_for<Rng...>>(
-					[&](auto nconstIndex) constexpr noexcept -> decltype(auto) { // return_decltype leads to ICE
+					[&](auto const nconstIndex) constexpr noexcept -> decltype(auto) { // return_decltype leads to ICE
 						return tc::dereference_index(tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range(), tc::get<nconstIndex()>(idx));
 					},
 					idx.index()
@@ -286,7 +278,7 @@ MODIFY_WARNINGS(((suppress)(4544))) // 'Func2': default template argument ignore
 
 			STATIC_FINAL_MOD(constexpr, dereference_index)(tc_index const& idx) & noexcept -> decltype(auto) {
 				return tc::invoke_with_constant<std::index_sequence_for<Rng...>>(
-					[&](auto nconstIndex) constexpr noexcept -> decltype(auto) { // return_decltype leads to ICE
+					[&](auto const nconstIndex) constexpr noexcept -> decltype(auto) { // return_decltype leads to ICE
 						return tc::dereference_index(tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range(), tc::get<nconstIndex()>(idx));
 					},
 					idx.index()
@@ -300,11 +292,11 @@ MODIFY_WARNINGS(((suppress)(4544))) // 'Func2': default template argument ignore
 					(... && tc::has_advance_index<std::remove_reference_t<Rng>>)
 			{
 				tc::invoke_with_constant<std::make_index_sequence<sizeof...(Rng)+1>>(
-					[&](auto nconstIndexStart) noexcept {
+					[&](auto const nconstIndexStart) noexcept {
 						if (d < 0) {
 							tc::for_each(
 								tc::make_reverse_integer_sequence<int, 0, nconstIndexStart() + 1>(),
-								[&](auto nconstIndex) noexcept {
+								[&](auto const nconstIndex) noexcept {
 									if constexpr (sizeof...(Rng) == nconstIndex()) {
 										idx = create_end_index(tc::constant<nconstIndex() - 1>());
 										return tc::continue_;
@@ -346,7 +338,7 @@ MODIFY_WARNINGS(((suppress)(4544))) // 'Func2': default template argument ignore
 						} else {
 							tc::for_each(
 								tc::make_integer_sequence<std::size_t, nconstIndexStart(), sizeof...(Rng)>(),
-								[&](auto nconstIndex) noexcept {
+								[&](auto const nconstIndex) noexcept {
 									using range_difference_t = typename boost::range_difference<decltype(tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range())>::type;
 									if constexpr (nconstIndex() == sizeof...(Rng)-1) {
 										tc::advance_index(tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range(),
@@ -387,7 +379,7 @@ MODIFY_WARNINGS(((suppress)(4544))) // 'Func2': default template argument ignore
 			{
 				if (idxLhs.index() == idxRhs.index()) {
 					return tc::invoke_with_constant<std::make_index_sequence<sizeof...(Rng)+1>>(
-						[&](auto nconstIndex) noexcept -> difference_type {
+						[&](auto const nconstIndex) noexcept -> difference_type {
 							if constexpr (nconstIndex() == sizeof...(Rng)) {
 								return 0;
 							} else {
@@ -401,21 +393,21 @@ MODIFY_WARNINGS(((suppress)(4544))) // 'Func2': default template argument ignore
 						return tc::accumulate(
 							tc::transform(
 								tc::iota(lhs.index() + 1, rhs.index()),
-								[&](auto nIndex) noexcept {
+								[&](auto const nIndex) noexcept {
 									return tc::invoke_with_constant<std::index_sequence_for<Rng...>>(
-										[&](auto nconstIndex) noexcept { return tc::explicit_cast<difference_type>(this->BaseRangeSize(nconstIndex)); },
+										[&](auto const nconstIndex) noexcept { return tc::explicit_cast<difference_type>(this->BaseRangeSize(nconstIndex)); },
 										nIndex
 									);
 								}
 							),
 							tc::invoke_with_constant<std::index_sequence_for<Rng...>>(
-								[&](auto nconstIndex) noexcept -> difference_type {
+								[&](auto const nconstIndex) noexcept -> difference_type {
 									return tc::distance_to_index(tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range(), tc::get<nconstIndex()>(lhs), tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_end_index());
 								},
 								lhs.index()
 							) + 
 							tc::invoke_with_constant<std::make_index_sequence<sizeof...(Rng)+1>>(
-								[&](auto nconstIndex) noexcept -> difference_type {
+								[&](auto const nconstIndex) noexcept -> difference_type {
 									if constexpr(nconstIndex() == sizeof...(Rng)) {
 										return 0;
 									} else {
@@ -438,17 +430,9 @@ MODIFY_WARNINGS(((suppress)(4544))) // 'Func2': default template argument ignore
 		};
 	}
 
-	namespace no_adl {
-		template<bool HasIterator, tc::has_constexpr_size... Rng>
-		struct constexpr_size_impl<tc::concat_adaptor_adl::concat_adaptor_impl<HasIterator, Rng...>>
-			: tc::constant<(... + tc::constexpr_size<Rng>::value)>
-		{};
-
-		template<typename... Rng>
-		struct is_index_valid_for_move_constructed_range<tc::concat_adaptor_adl::concat_adaptor_impl<true, Rng...>>
-			: std::conjunction<tc::is_index_valid_for_move_constructed_range<Rng>...>
-		{};
-	}
+	template<typename... Rng>
+	constexpr auto enable_stable_index_on_move<tc::concat_adaptor_adl::concat_adaptor_impl<true, Rng...>>
+		= (tc::stable_index_on_move<Rng> && ...);
 
 	namespace no_adl {
 		struct fn_concat_impl final {
diff --git a/tc/range/concat_adaptor.t.cpp b/tc/range/concat_adaptor.t.cpp
index 8baac05..eb92ceb 100644
--- a/tc/range/concat_adaptor.t.cpp
+++ b/tc/range/concat_adaptor.t.cpp
@@ -29,36 +29,36 @@ UNITTESTDEF(concat_void_generator_test) {
 	);
 
 	tc::vector<int> vecn;
-	auto PushBack = [&](int n) noexcept { tc::cont_emplace_back(vecn, n); };
+	auto const PushBack = [&](int const n) noexcept { tc::cont_emplace_back(vecn, n); };
 
 	tc::for_each(rng, PushBack);
 	tc::for_each(tc::as_const(rng), PushBack);
 	tc::for_each(tc_move(rng), PushBack);
 
-	TEST_RANGE_EQUAL(vecn, as_constexpr(tc::make_array(tc::aggregate_tag, 1, 5, 1, 5, 1, 5)));
+	TEST_RANGE_EQUAL(vecn, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1, 5, 1, 5, 1, 5)));
 }
 
 UNITTESTDEF(concat_break_or_continue_generator_test) {
 	auto rng = tc::concat(
 		tc::single(2),
-		tc::make_generator_range(tc::make_vector(as_constexpr(tc::make_array(tc::aggregate_tag, 1, 3)))),
+		tc::make_generator_range(tc::make_vector(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1, 3)))),
 		tc::single(5)
 	);
 
 	tc::vector<int> vecn;
-	auto PushBack = [&](int n) noexcept { tc::cont_emplace_back(vecn, n); return tc::continue_if(1 != n); };
+	auto const PushBack = [&](int const n) noexcept { tc::cont_emplace_back(vecn, n); return tc::continue_if(1 != n); };
 
 	tc::for_each(rng, PushBack);
 	tc::for_each(tc::as_const(rng), PushBack);
 	tc::for_each(tc_move(rng), PushBack);
 
-	TEST_RANGE_EQUAL(vecn, as_constexpr(tc::make_array(tc::aggregate_tag, 2, 1, 2, 1, 2, 1)));
+	TEST_RANGE_EQUAL(vecn, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 2, 1, 2, 1, 2, 1)));
 }
 
 UNITTESTDEF(concat_index_test) {
 	auto rng =
 		tc::concat(
-			as_constexpr(tc::make_array(tc::aggregate_tag, 2, 3, 4)),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 2, 3, 4)),
 			tc::single(1),
 			tc::single(5)
 		);
@@ -80,16 +80,16 @@ UNITTESTDEF(concat_index_test) {
 		tc::filter(
 			tc::reverse(
 				tc::concat(
-					as_constexpr(tc::make_array(tc::aggregate_tag, 1, 3, 4)),
+					tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1, 3, 4)),
 					tc::single(1),
 					tc::single(5)
 				)),
-			[](int i) noexcept { return i % 2 == 1; }
+			[](int const i) noexcept { return i % 2 == 1; }
 		),
-		[&](int i) noexcept { tc::cont_emplace_back(vecn, i); return 3 == i ? tc::break_ : tc::continue_; }
+		[&](int const i) noexcept { tc::cont_emplace_back(vecn, i); return 3 == i ? tc::break_ : tc::continue_; }
 	));
 
-	TEST_RANGE_EQUAL(vecn, as_constexpr(tc::make_array(tc::aggregate_tag, 5, 1, 3)));
+	TEST_RANGE_EQUAL(vecn, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 5, 1, 3)));
 	TEST_RANGE_LENGTH(rng, 5);
 }
 
@@ -118,20 +118,20 @@ UNITTESTDEF(concat_different_value_types_test) {
 	auto rng =
 		tc::concat(
 			tc::single(1),
-			as_constexpr(tc::make_array(tc::aggregate_tag, S{2}, S{3}, S{4})),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, S{2}, S{3}, S{4})),
 			tc::single(5)
 		);
 
 	struct SFunctor {
 		tc::vector<int> m_vec;
 
-		void operator()(int i) & noexcept { tc::cont_emplace_back(m_vec, i); }
+		void operator()(int const i) & noexcept { tc::cont_emplace_back(m_vec, i); }
 		void operator()(S s) & noexcept { tc::cont_emplace_back(m_vec, s.m_i); }
 	} functor;
 
 	tc::for_each(rng, std::ref(functor));
 
-	TEST_RANGE_EQUAL(functor.m_vec, as_constexpr(tc::make_array(tc::aggregate_tag, 1, 2, 3, 4, 5)));
+	TEST_RANGE_EQUAL(functor.m_vec, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1, 2, 3, 4, 5)));
 }
 
 UNITTESTDEF(concat_empty_test) {
@@ -145,7 +145,7 @@ UNITTESTDEF(concat_shallow_const_test) {
 	STATICASSERTSAME(decltype(*tc::begin(rng)), int&);
 
 	*tc::begin(rng) = 2;
-	TEST_RANGE_EQUAL(rng, as_constexpr(tc::make_array(tc::aggregate_tag, 2, 2)));
+	TEST_RANGE_EQUAL(rng, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 2, 2)));
 }
 
 UNITTESTDEF(concat_deep_const_test) {
@@ -259,11 +259,11 @@ STATICASSERTSAME(char, tc::range_value_t<decltype(tc::concat("abc", "def"))>);
 STATICASSERTSAME(char, tc::range_value_t<decltype(tc::concat("abc", tc::as_dec(10)))>);
 STATICASSERTSAME(char, tc::range_value_t<decltype(tc::concat(tc::as_dec(10), "abc", tc::string<char>("de")))>);
 STATICASSERTSAME(char, tc::range_value_t<decltype(tc::concat(tc::as_dec(10), "abc", tc::concat("xy", tc::as_dec(5)), tc::string<char>("de")))>);
-STATICASSERTSAME(int, tc::range_value_t<decltype(tc::transform(tc::concat("ab", UTF16("cd")), tc::fn_static_cast<int>()))>);
+STATICASSERTSAME(int, tc::range_value_t<decltype(tc::transform(tc::concat("ab", tc_utf16("cd")), tc::fn_static_cast<int>()))>);
 static_assert(!tc::has_range_value<decltype(tc::concat("xy", tc::as_dec(5), L"a"))>::value);
 static_assert(!tc::has_range_value<decltype(tc::concat("abc", tc::as_dec(10), tc::concat("xy", tc::as_dec(5), L"a"), tc::string<char>("de")))>::value);
 static_assert(tc::has_range_value<decltype(tc::concat(tc::as_dec(5), tc::as_dec(10)))>::value);
-static_assert(!tc::has_range_value<decltype(tc::transform(tc::concat("ab", UTF16("cd")), tc::fn_increment()))>::value);
+static_assert(!tc::has_range_value<decltype(tc::transform(tc::concat("ab", tc_utf16("cd")), tc::fn_increment()))>::value);
 static_assert(tc::is_concat_range<decltype(tc::concat(tc::as_dec(5), "abc"))>::value);
 static_assert(tc::is_concat_range<decltype(tc::concat("abc", L"def"))>::value);
 static_assert(tc::is_concat_range<decltype(tc::concat("abc", tc::string<char>("def")))>::value);
diff --git a/tc/range/conditional_range.h b/tc/range/conditional_range.h
index 76b03d3..decc256 100644
--- a/tc/range/conditional_range.h
+++ b/tc/range/conditional_range.h
@@ -10,30 +10,37 @@
 
 #include "../base/assert_defs.h"
 #include "../base/type_list.h"
+#include "../base/invoke_with_constant.h"
 
 #include "../algorithm/size.h"
 #include "../variant.h"
 #include "../interval.h"
 
-#include "range_fwd.h"
 #include "range_adaptor.h"
 #include "index_range.h"
 #include "meta.h"
+#include "subrange.h"
 
 #include <boost/preprocessor/punctuation/comma_if.hpp>
 
 namespace tc {
 	namespace select_range_adaptor_adl {
-		template<typename... Rng>
-		struct select_range_adaptor {
+		template <bool HasIterator, typename... Rng>
+		struct select_range_adaptor;
+
+		template <typename... Rng>
+		struct select_range_adaptor<false, Rng...> {
 			static_assert( (!std::is_rvalue_reference<Rng>::value && ...) );
-		//private: // public because for_each_impl is non-friend for _MSC_VER
+			friend select_range_adaptor<true, Rng...>;
+
+		private:
 			std::variant<tc::reference_or_value<Rng>...> m_ubaserng;
 
+		public:
 			template<typename... FuncRng>
-			explicit select_range_adaptor(aggregate_tag_t, int n, FuncRng&&... funcrng) MAYTHROW
+			constexpr explicit select_range_adaptor(aggregate_tag_t, int n, FuncRng&&... funcrng) MAYTHROW
 				: m_ubaserng(tc::invoke_with_constant<std::index_sequence_for<FuncRng...>>(
-					[&](auto nconstIndex) MAYTHROW {
+					[&](auto const nconstIndex) MAYTHROW {
 						STATICASSERTEQUAL(sizeof...(Rng), sizeof...(FuncRng));
 						return decltype(m_ubaserng)(
 							std::in_place_index<nconstIndex()>, tc::aggregate_tag, tc::select_nth<nconstIndex()>(std::forward<FuncRng>(funcrng)...)()
@@ -43,12 +50,37 @@ namespace tc {
 				))
 			{}
 
-			template<ENABLE_SFINAE>
-			auto size() const& return_decltype_NOEXCEPT(
-				tc::fn_visit(tc::projected(tc::fn_size_raw(), fn_indirection()))(SFINAE_VALUE(m_ubaserng))
-			)
+		private:
+			static constexpr auto same_constexpr_size() noexcept requires (... && tc::has_constexpr_size<Rng>){
+#if 0
+				// Ideally, but doesn't compile under MSVC - bogus read of uninitialized symbol in constexpr context.
+				return tc::all_same_element<tc::return_value_or_none>(tc::make_tuple(tc::constexpr_size<Rng>()...));
+#endif
 
-			bool empty() const& noexcept {
+				std::optional<std::size_t> result;
+				auto const all_same = ((result ? *result == tc::constexpr_size<Rng>() : (result = tc::constexpr_size<Rng>(), true)) && ...);
+				return all_same ? result : std::nullopt;
+			}
+
+		public:
+			constexpr auto size() const& MAYTHROW requires (... && tc::has_size<Rng>) {
+				auto const runtime_size = [&]() MAYTHROW {
+					return tc::fn_visit(tc::projected(tc::fn_size_raw(), fn_indirection()))(m_ubaserng);
+				};
+
+				if constexpr (( ... && tc::has_constexpr_size<Rng>)) {
+					auto constexpr same_size = same_constexpr_size();
+					if constexpr (same_size) {
+						return tc::least_uint_constant<*same_size>{};
+					} else {
+						return runtime_size();
+					}
+				} else {
+					return runtime_size();
+				}
+			}
+
+			constexpr bool empty() const& noexcept {
 				return tc::fn_visit([](auto const& baserng) noexcept {
 					return tc::empty(*baserng);
 				})(m_ubaserng);
@@ -58,27 +90,129 @@ namespace tc {
 			friend auto range_output_t_impl(Self&&) -> tc::type::unique_t<tc::type::concat_t<
 				tc::range_output_t<decltype(*std::declval<tc::apply_cvref_t<tc::reference_or_value<Rng>, Self>>())>...
 			>> {} // unevaluated
+
+			template<typename Self, typename Sink> requires tc::decayed_derived_from<Self, select_range_adaptor>
+			friend constexpr auto for_each_impl(Self&& self, Sink&& sink) MAYTHROW {
+				return tc::fn_visit([&](auto&& rng) MAYTHROW {
+					return tc::for_each(*tc_move_if_owned(rng), sink);
+				})(std::forward<Self>(self).m_ubaserng);
+			}
+
+			template<typename Self, typename Sink> requires tc::decayed_derived_from<Self, select_range_adaptor>
+			friend constexpr auto for_each_reverse_impl(Self&& self, Sink&& sink) MAYTHROW {
+				return tc::fn_visit([&](auto&& rng) MAYTHROW {
+					return tc::for_each(tc::reverse(*tc_move_if_owned(rng)), sink);
+				})(std::forward<Self>(self).m_ubaserng);
+			}
 		};
 
-		// Must be non-friend for MSVC 15.8, but should be a hidden friend 
-		template<typename Self, typename Sink> requires tc::instance<std::remove_reference_t<Self>, select_range_adaptor>
-		auto for_each_impl(Self&& self, Sink&& sink) MAYTHROW {
-			return tc::fn_visit([&](auto&& rng) MAYTHROW {
-				return tc::for_each(*tc_move_if_owned(rng), sink);
-			})(std::forward<Self>(self).m_ubaserng);
-		}
+		template <typename ... Rng>
+		using select_range_adaptor_index = tc::type::apply_t<std::variant, tc::type::unique_t<tc::type::list<tc::index_t<Rng>...>>>;
 
-		template<typename Self, typename Sink> requires tc::instance<std::remove_reference_t<Self>, select_range_adaptor>
-		auto for_each_reverse_impl(Self&& self, Sink&& sink) MAYTHROW {
-			return tc::fn_visit([&](auto&& rng) MAYTHROW {
-				return tc::for_each(tc::reverse(*tc_move_if_owned(rng)), sink);
-			})(std::forward<Self>(self).m_ubaserng);
-		}
+		template <typename... Rng>
+		struct select_range_adaptor<true, Rng...>
+			: select_range_adaptor<false, Rng...>
+			, tc::range_iterator_from_index< select_range_adaptor<true, Rng...>, select_range_adaptor_index<Rng...>>
+		{
+		private:
+			using this_type = select_range_adaptor;
+
+		public:
+			using typename this_type::range_iterator_from_index::tc_index;
+			static constexpr bool c_bHasStashingIndex = (... || tc::has_stashing_index<std::remove_reference_t<Rng>>::value);
+
+			using difference_type = tc::common_type_t<typename boost::range_difference<Rng>::type...>;
+
+			using select_range_adaptor<false, Rng...>::select_range_adaptor;
+
+		private:
+#pragma push_macro("forward_to_active")
+#define forward_to_active(...) \
+	tc::fn_visit([&](auto& base_rng) MAYTHROW { \
+		auto&& rng = base_rng.best_access(); \
+		using index_t = tc::index_t<decltype(rng)>; \
+		return __VA_ARGS__; \
+	})(this->m_ubaserng)
+
+			STATIC_FINAL_MOD(constexpr, begin_index)() const& MAYTHROW {
+				return forward_to_active(tc_index(tc::begin_index(rng)));
+			}
+
+			STATIC_FINAL_MOD(constexpr, end_index)() const& MAYTHROW
+				requires (... && tc::has_end_index<Rng>)
+			{
+				return forward_to_active(tc_index(tc::end_index(rng)));
+			}
+			STATIC_FINAL_MOD(constexpr, at_end_index)(tc_index const& idx) const& MAYTHROW {
+				return forward_to_active(tc::at_end_index(rng, tc::get<index_t>(idx)));
+			}
+
+			STATIC_FINAL_MOD(constexpr, dereference_index)(tc_index const& idx) & MAYTHROW -> decltype(auto) {
+				return forward_to_active(tc::dereference_index(rng, tc::get<index_t>(idx)));
+			}
+			STATIC_FINAL_MOD(constexpr,dereference_index)(tc_index const& idx) const& MAYTHROW -> decltype(auto) {
+				return forward_to_active(tc::dereference_index(rng, tc::get<index_t>(idx)));
+			}
+
+			STATIC_FINAL_MOD(constexpr, increment_index)(tc_index& idx) const& MAYTHROW {
+				forward_to_active(tc::increment_index(rng, tc::get<index_t>(idx)));
+			}
+			STATIC_FINAL_MOD(constexpr, decrement_index)(tc_index& idx) const& MAYTHROW
+				requires (... && tc::has_decrement_index<Rng>)
+			{
+				forward_to_active(tc::decrement_index(rng, tc::get<index_t>(idx)));
+			}
+			STATIC_FINAL_MOD(constexpr, advance_index)(tc_index& idx, difference_type d) const& MAYTHROW
+				requires (... && tc::has_advance_index<Rng>)
+			{
+				forward_to_active(tc::advance_index(rng, tc::get<index_t>(idx), tc::explicit_cast<typename boost::range_difference<std::remove_cvref_t<decltype(rng)>>::type>(d)));
+			}
+			STATIC_FINAL_MOD(constexpr, distance_to_index)(tc_index const& idxLhs, tc_index const& idxRhs) const& MAYTHROW
+				requires (... && tc::has_distance_to_index<Rng>)
+			{
+				return forward_to_active(tc::distance_to_index(rng, tc::get<index_t>(idxLhs), tc::get<index_t>(idxRhs)));
+			}
+			STATIC_FINAL_MOD(constexpr, middle_point)( tc_index& idxBegin, tc_index const& idxEnd ) const& MAYTHROW
+				requires (... && tc::has_middle_point<Rng>)
+			{
+				forward_to_active(tc::middle_point(rng, tc::get<index_t>(idxBegin), tc::get<index_t>(idxEnd)));
+			}
+
+#pragma pop_macro("forward_to_active")
+		};
+
+		// While we normally try to use `tc::subrange` in the case of all ranges having the same iterator type,
+		// we can't do that if we have rvalues that we need to aggregate.
+		template <typename... Rng>
+			requires (1 == tc::type::size<tc::type::unique_t<tc::type::list<tc::iterator_t<Rng>...>>>::value)
+		struct select_range_adaptor<true, Rng...>
+			: select_range_adaptor<false, Rng...>
+		{
+		public:
+			static constexpr bool c_bHasStashingIndex = (... || tc::has_stashing_index<std::remove_reference_t<Rng>>::value);
+
+			using select_range_adaptor<false, Rng...>::select_range_adaptor;
+
+			auto begin() & MAYTHROW {
+				return tc::fn_visit([](auto& refrng) MAYTHROW { return tc::begin(*refrng); })(this->m_ubaserng);
+			}
+			auto begin() const& MAYTHROW {
+				return tc::fn_visit([](auto& refrng) MAYTHROW { return tc::begin(*refrng); })(this->m_ubaserng);
+			}
+
+			auto end() & MAYTHROW {
+				return tc::fn_visit([](auto& refrng) MAYTHROW { return tc::end(*refrng); })(this->m_ubaserng);
+			}
+			auto end() const& MAYTHROW {
+				return tc::fn_visit([](auto& refrng) MAYTHROW { return tc::end(*refrng); })(this->m_ubaserng);
+			}
+		};
 	}
-	using select_range_adaptor_adl::select_range_adaptor;
+	template <typename ... Rng>
+	using select_range_adaptor = select_range_adaptor_adl::select_range_adaptor<tc::ranges_with_common_reference<Rng...>, Rng...>;
 
-	template<typename... FuncRng>
-	auto select_range_impl(tc::constant<true>, int n, FuncRng&&... funcrng) MAYTHROW -> tc::common_reference_xvalue_as_ref_t<decltype(std::declval<FuncRng>()())...> {
+	template<typename... FuncRng> requires tc::has_common_reference_xvalue_as_ref<decltype(std::declval<FuncRng>()())...>
+	constexpr auto select_range(int n, FuncRng&&... funcrng) MAYTHROW -> tc::common_reference_xvalue_as_ref_t<decltype(std::declval<FuncRng>()())...> {
 #ifdef _MSC_VER
 		// The following assert must not hold: A function pointer to a function that returns a fixed size array by reference must also return a fixed size array by reference, not by value!
 		// If MSVC fixed that bug, please unify select_range.
@@ -95,7 +229,7 @@ namespace tc {
 		tc_scope_exit { result.dtor(); };
 
 		tc::invoke_with_constant<std::index_sequence_for<FuncRng...>>(
-			[&](auto nconstIndex) MAYTHROW {
+			[&](auto const nconstIndex) MAYTHROW {
 				result.ctor(tc::select_nth<nconstIndex()>(std::forward<FuncRng>(funcrng)...)());
 			},
 			n
@@ -112,32 +246,23 @@ namespace tc {
 		);
 
 		return tc::invoke_with_constant<std::index_sequence_for<FuncRng...>>(
-			[&](auto nconstIndex) MAYTHROW -> tc::common_reference_xvalue_as_ref_t<decltype(std::declval<FuncRng>()())...> {
+			[&](auto const nconstIndex) MAYTHROW -> tc::common_reference_xvalue_as_ref_t<decltype(std::declval<FuncRng>()())...> {
 				return tc::select_nth<nconstIndex()>(std::forward<FuncRng>(funcrng)...)();
 			},
 			n
 		);
 #endif
 	}
-
 	template<typename... FuncRng>
-	auto select_range_impl(tc::constant<false>, int n, FuncRng&&... funcrng) return_ctor_MAYTHROW(
+	constexpr auto select_range(int n, FuncRng&&... funcrng) return_ctor_MAYTHROW(
 		select_range_adaptor<tc::remove_rvalue_reference_t<decltype(std::declval<FuncRng>()())>...>,
 		(aggregate_tag, n, std::forward<FuncRng>(funcrng)...)
 	)
 
-#if defined(__clang__) || defined(_MSC_VER) // gcc internal compiler error
-	template<typename... FuncRng>
-	auto select_range(int n, FuncRng&&... funcrng) return_decltype_xvalue_by_ref_MAYTHROW(
-		tc::select_range_impl(tc::constant<tc::has_common_reference_xvalue_as_ref<decltype(std::forward<FuncRng>(funcrng)())...>>(), n, std::forward<FuncRng>(funcrng)...)
-	)
-
 	template<typename FuncRngTrue, typename FuncRngFalse>
-	auto conditional_range(tc::bool_context b, FuncRngTrue&& funcrngTrue, FuncRngFalse&& funcrngFalse) return_decltype_xvalue_by_ref_MAYTHROW(
+	constexpr auto conditional_range(tc::bool_context b, FuncRngTrue&& funcrngTrue, FuncRngFalse&& funcrngFalse) return_decltype_xvalue_by_ref_MAYTHROW(
 		tc::select_range(b ? 0 : 1, std::forward<FuncRngTrue>(funcrngTrue), std::forward<FuncRngFalse>(funcrngFalse))
 	)
-#endif
-
 	template<typename FuncRngTrue, typename FuncRngFalse>
 	constexpr auto conditional_range(tc::constant<true>, FuncRngTrue funcrngTrue, FuncRngFalse&& /*funcrngFalse*/) return_decltype_xvalue_by_ref_MAYTHROW(
 		funcrngTrue()
@@ -177,7 +302,7 @@ namespace tc {
 #if defined(__clang__) || defined(_MSC_VER) // gcc internal compiler error
 	namespace switch_range_detail {
 		template<typename Enum, typename FuncRng, std::size_t... I>
-		auto switch_range_impl(Enum const& e, FuncRng&& funcRng, std::index_sequence<I...>) noexcept {
+		constexpr auto switch_range_impl(Enum const& e, FuncRng&& funcRng, std::index_sequence<I...>) noexcept {
 			return tc::select_range(
 				tc::explicit_cast<int>(tc::all_values<Enum>::index_of(e)),
 				(I, [&]() noexcept -> decltype(auto) {
@@ -188,8 +313,11 @@ namespace tc {
 	}
 
 	template<typename Enum, typename... FuncRng>
-	auto switch_range(Enum const& e, FuncRng&&... funcrng) noexcept {
-		return switch_range_detail::switch_range_impl(e, tc::make_overload(std::forward<FuncRng>(funcrng)...), std::make_index_sequence<tc::constexpr_size<tc::all_values<Enum>>::value>());
+	constexpr auto switch_range(Enum const& e, FuncRng&&... funcrng) noexcept {
+		return switch_range_detail::switch_range_impl(
+			e, tc::make_overload(std::forward<FuncRng>(funcrng)...),
+			std::make_index_sequence<tc::constexpr_size<tc::all_values<Enum>>()>()
+		);
 	}
 #endif
 }
diff --git a/tc/range/conditional_range.t.cpp b/tc/range/conditional_range.t.cpp
new file mode 100644
index 0000000..474a4c4
--- /dev/null
+++ b/tc/range/conditional_range.t.cpp
@@ -0,0 +1,61 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "../base/assert_defs.h"
+#include "../unittest.h"
+#include "conditional_range.h"
+#include "literal_range.h"
+#include "subrange.h"
+#include "transform_adaptor.h"
+#include "../algorithm/find.h"
+
+#include <algorithm>
+#include <list>
+#include <vector>
+
+namespace {
+	// For testing purposes, we unconditionally want to create a select_range_adaptor, and not have the common reference.
+	template<typename... FuncRng>
+	constexpr auto make_select_range(int n, FuncRng&&... funcrng) return_ctor_MAYTHROW(
+		tc::select_range_adaptor<tc::remove_rvalue_reference_t<decltype(std::declval<FuncRng>()())>...>,
+		(tc::aggregate_tag, n, std::forward<FuncRng>(funcrng)...)
+	)
+
+	template <typename Lhs, typename Rhs>
+	bool iterator_range_equal(Lhs const& lhs, Rhs const& rhs) {
+		return std::equal(tc::begin(lhs), tc::end(lhs), tc::begin(rhs), tc::end(rhs));
+	}
+}
+
+UNITTESTDEF(conditional_range) {
+	static auto constexpr verify = [](auto&& rng1, auto&& rng2) {
+		auto const select_first = make_select_range(0, tc_lazy(rng1), tc_lazy(rng2));
+		TEST_RANGE_EQUAL(select_first, rng1); // generator
+		_ASSERT(iterator_range_equal(select_first, rng1)); // iterator
+
+		auto const select_second = make_select_range(1, tc_lazy(rng1), tc_lazy(rng2));
+		TEST_RANGE_EQUAL(select_second, rng2); // generator
+		_ASSERT(iterator_range_equal(select_second, rng2)); // iterator
+
+		auto const find_null = tc::find_first<tc::return_element_or_null>(tc::take(select_first, tc_modified(tc::begin(select_first), ++_)), tc::front(rng2));
+		_ASSERT(!find_null);
+		auto const find_elem = tc::find_first<tc::return_element_or_null>(tc::take(select_second, tc_modified(tc::begin(select_second), ++_)), tc::front(rng2));
+		_ASSERTEQUAL(find_elem, tc::begin(select_second));
+
+		return select_first;
+	};
+
+	auto different_indices = verify(std::vector{1, 2, 3}, std::list{4, 5});
+	static_assert(std::same_as<tc::index_t<decltype(different_indices)>, std::variant<tc::index_t<std::vector<int>>, tc::index_t<std::list<int>>>>);
+
+	[[maybe_unused]] auto same_index = verify(std::vector{1, 2, 3}, tc::transform(std::vector{4, 5}, tc::identity{}));
+	// TODO, size optimization: STATICASSERTEQUAL(sizeof(tc::index_t<decltype(same_index)>), sizeof(tc::index_t<std::vector<int>>));
+
+	auto same_iterator = verify(std::vector{1, 2, 3}, std::vector{4, 5});
+	static_assert(std::same_as<tc::iterator_t<decltype(same_iterator)>, tc::iterator_t<std::vector<int>>>);
+}
diff --git a/tc/range/empty_range.h b/tc/range/empty_range.h
index 6a57004..1f6bf3f 100644
--- a/tc/range/empty_range.h
+++ b/tc/range/empty_range.h
@@ -14,6 +14,10 @@
 namespace tc {
 	namespace empty_range_adl {
 		struct TC_EMPTY_BASES empty_range {
+			static constexpr auto size() noexcept {
+				return tc::least_uint_constant<0>{};
+			}
+
 			constexpr auto operator()(tc::unused /*sink*/) const& noexcept {
 				return tc::constant<tc::continue_>();
 			}
@@ -25,9 +29,5 @@ namespace tc {
 
 		auto range_output_t_impl(empty_range const&) noexcept -> tc::type::list<>; // declaration only
 	}
-
-	namespace no_adl {
-		template<>
-		struct constexpr_size_impl<empty_range> : tc::constant<tc::explicit_cast<std::uint8_t>(0)> {};
-	}
+	using empty_range_adl::empty_range;
 }
diff --git a/tc/range/filter_adaptor.h b/tc/range/filter_adaptor.h
index a29a618..67b94d9 100644
--- a/tc/range/filter_adaptor.h
+++ b/tc/range/filter_adaptor.h
@@ -12,10 +12,10 @@
 #include "../base/tc_move.h" 
 #include "../base/conditional.h"
 #include "../base/invoke.h"
+#include "../base/trivial_functors.h"
 
 #include "range_adaptor.h"
 #include "meta.h"
-#include "range_fwd.h"
 
 namespace tc {
 	namespace no_adl {
@@ -30,14 +30,28 @@ namespace tc {
 			Pred const& m_pred;
 			Sink m_sink;
 
-			template<typename T>
-			constexpr auto operator()(T&& t) const& return_decltype_MAYTHROW(
-				tc::explicit_cast<bool>(tc::invoke(m_pred, tc::as_const(t)))
-					? tc::continue_if_not_break(m_sink, std::forward<T>(t))
-					: tc::constant<tc::continue_>()
-			)
+			template<typename T> requires tc::runtime_predicate<Pred, T> && tc::sinkable<Sink, T>
+			constexpr auto operator()(T&& t) const& noexcept(tc::nothrow_predicate<Pred, T> && tc::nothrow_sinkable<Sink, T>) {
+				return tc::explicit_cast<bool>(tc::invoke(m_pred, tc::as_const(t)))
+							? tc::continue_if_not_break(m_sink, std::forward<T>(t))
+							: tc::constant<tc::continue_>();
+			}
+
+			template<typename T> requires tc::constant_predicate_true<Pred, T>  && tc::sinkable<Sink, T>
+			constexpr auto operator()(T&& t) const& noexcept(tc::nothrow_predicate<Pred, T> && tc::nothrow_sinkable<Sink, T>) {
+				tc::discard(tc::invoke(m_pred, tc::as_const(t)));
+				return tc::continue_if_not_break(m_sink, std::forward<T>(t));
+			}
+			template<typename T> requires tc::constant_predicate_false<Pred, T>
+			constexpr auto operator()(T&& t) const& noexcept(tc::nothrow_predicate<Pred, T>) {
+				tc::discard(tc::invoke(m_pred, tc::as_const(t)));
+				return tc::constant<tc::continue_>();
+			}
 		};
 
+		template< typename Pred, typename Rng, bool HasIterator=tc::range_with_iterators< Rng > >
+		struct filter_adaptor;
+
 		template< typename Pred, typename Rng >
 		struct [[nodiscard]] filter_adaptor<Pred, Rng, false> : tc::generator_range_adaptor<Rng>, tc::range_output_from_base_range {
 		protected:
@@ -62,9 +76,8 @@ namespace tc {
 		struct [[nodiscard]] filter_adaptor<Pred, Rng, true>
 			: tc::index_range_adaptor<
 				filter_adaptor<Pred, Rng, true>,
-				Rng,
-				filter_adaptor<Pred, Rng, false>,
-				boost::iterators::bidirectional_traversal_tag // filter_adaptor is bidirectional at best
+				Rng, tc::index_range_adaptor_flags::inherit_end | tc::index_range_adaptor_flags::inherit_dereference,
+				filter_adaptor<Pred, Rng, false>
 			>
 		{
 		private:
@@ -80,36 +93,40 @@ namespace tc {
 		private:
 			void increment_until_kept(tc_index& idx) const& MAYTHROW {
 				// always call operator() const, which is assumed to be thread-safe
-				while(!this->template at_end_index<base_>(idx) && !tc::explicit_cast<bool>(tc::invoke(this->m_pred, tc::as_const(this->template dereference_index<base_>(idx))))) {
-					this->template increment_index<base_>(idx);
+				while(!this->at_end_index(idx) && !tc::explicit_cast<bool>(tc::invoke(this->m_pred, tc::as_const(this->dereference_index(idx))))) {
+					tc::increment_index(this->base_range(), idx);
 				}
 			}
 
 			STATIC_FINAL(begin_index)() const& MAYTHROW -> tc_index {
-				tc_index idx=this->template begin_index<base_>();
+				tc_index idx=this->base_begin_index();
 				increment_until_kept(idx);
 				return idx;
 			}
 
 			STATIC_FINAL(increment_index)(tc_index& idx) const& MAYTHROW -> void {
-				this->template increment_index<base_>(idx);
+				tc::increment_index(this->base_range(), idx);
 				increment_until_kept(idx);
 			}
 
-			STATIC_FINAL(decrement_index)(tc_index& idx) const& MAYTHROW -> void {
+			STATIC_FINAL(decrement_index)(tc_index& idx) const& MAYTHROW -> void
+				requires tc::has_decrement_index<Rng>
+			{
 				do {
-					this->template decrement_index<base_>(idx);
+					tc::decrement_index(this->base_range(), idx);
 					// always call operator() const, which is assumed to be thread-safe
-				} while(!tc::explicit_cast<bool>(tc::invoke(this->m_pred, tc::as_const(this->template dereference_index<base_>(idx)))));
+				} while(!tc::explicit_cast<bool>(tc::invoke(this->m_pred, tc::as_const(this->dereference_index(idx)))));
 			}
 
-			STATIC_FINAL(middle_point)( tc_index & idx, tc_index const& idxEnd ) const& MAYTHROW -> void {
+			STATIC_FINAL(middle_point)( tc_index & idx, tc_index const& idxEnd ) const& MAYTHROW -> void
+				requires tc::has_middle_point<Rng> && tc::has_decrement_index<Rng>
+			{
 				tc_index const idxBegin = idx;
-				this->template middle_point<base_>(idx,idxEnd);
+				tc::middle_point(this->base_range(), idx, idxEnd);
 			
 				// always call operator() const, which is assumed to be thread-safe
-				while(idxBegin != idx && !tc::explicit_cast<bool>(tc::invoke(this->m_pred, tc::as_const(this->template dereference_index<base_>(idx))))) {
-					this->template decrement_index<base_>(idx);
+				while(idxBegin != idx && !tc::explicit_cast<bool>(tc::invoke(this->m_pred, tc::as_const(this->dereference_index(idx))))) {
+					tc::decrement_index(this->base_range(), idx);
 				}
 			}
 		public:
@@ -119,19 +136,15 @@ namespace tc {
 			static constexpr decltype(auto) element_base_index(tc_index&& idx) noexcept {
 				return tc_move(idx);
 			}
-
-			constexpr decltype(auto) dereference_untransform(tc_index const& idx) const& noexcept {
-				return this->base_range().dereference_untransform(idx);
-			}
 		};
 	}
+	using no_adl::filter_adaptor;
+
+	template<typename Pred, typename Rng>
+	constexpr auto enable_stable_index_on_move<tc::filter_adaptor<Pred, Rng, true>> = tc::stable_index_on_move<Rng>;
 
 	template<typename Rng, typename Pred = tc::identity>
 	constexpr auto filter(Rng&& rng, Pred&& pred = Pred())
-		return_ctor_noexcept( TC_FWD(filter_adaptor<tc::decay_t<Pred>, Rng>), (std::forward<Rng>(rng),std::forward<Pred>(pred)) )
-
-	namespace no_adl {
-		template<typename Pred, typename Rng>
-		struct is_index_valid_for_move_constructed_range<tc::filter_adaptor<Pred, Rng, true>>: tc::is_index_valid_for_move_constructed_range<Rng> {};
-	}
+		return_ctor_noexcept( TC_FWD(tc::filter_adaptor<tc::decay_t<Pred>, Rng>), (std::forward<Rng>(rng),std::forward<Pred>(pred)) )
 }
+
diff --git a/tc/range/index_iterator.h b/tc/range/index_iterator.h
index 3591205..4c857b6 100644
--- a/tc/range/index_iterator.h
+++ b/tc/range/index_iterator.h
@@ -10,6 +10,7 @@
 #include "../base/assert_defs.h"
 #include "index_range.h"
 #include "iterator_facade.h"
+#include "../optional.h"
 
 #include <boost/iterator/detail/facade_iterator_category.hpp>
 
@@ -81,8 +82,7 @@ namespace tc {
 				using base_::base_;
 				using base_::operator=;
 
-				template <typename It_ = It>
-				constexpr auto element_base() const& noexcept {
+				constexpr auto element_base() const& noexcept requires requires(It const& it) { it.element_base(); } {
 					using ItBase = typename nullable_iterator<decltype(tc::base_cast<It>(*this).element_base())>::element_type;
 					return this->m_bValid ? ItBase{ tc::base_cast<It>(*this).element_base() } : ItBase{};
 				}
@@ -93,8 +93,7 @@ namespace tc {
 				using base_::base_;
 				using base_::operator=;
 
-				template <typename It_ = It>
-				constexpr auto border_base() const& noexcept {
+				constexpr auto border_base() const& noexcept requires requires(It const& it) { it.border_base(); } {
 					using ItBase = typename nullable_iterator<decltype(tc::base_cast<It>(*this).border_base())>::border_type;
 					return this->m_bValid ? ItBase{ tc::base_cast<It>(*this).border_base() } : ItBase{};
 				}
@@ -229,7 +228,7 @@ namespace tc {
 			friend class boost::iterator_core_access;
 			friend struct index_iterator<IndexRange,!bConst>;
 
-			conditional_const_t<IndexRange, bConst>* m_pidxrng;
+			tc::optional_reference_or_value<tc::conditional_const_t<IndexRange, bConst>&> m_oidxrng;
 
 		public: // TODO private
 			using tc_index = index_t<IndexRange>;
@@ -240,33 +239,36 @@ namespace tc {
 
 		public:
 			constexpr index_iterator() noexcept
-				: m_pidxrng(nullptr)
+				: m_oidxrng()
 				, m_idx()
 			{}
 
 			template<bool bConstOther> requires bConst || (!bConstOther)
 			constexpr index_iterator(index_iterator<IndexRange,bConstOther> const& other) noexcept
-				: m_pidxrng(other.m_pidxrng)
+				: m_oidxrng(other.m_oidxrng)
 				, m_idx(other.m_idx)
 			{}
 
-			constexpr index_iterator(conditional_const_t<IndexRange, bConst>* pidxrng, tc_index idx) noexcept
-				: m_pidxrng(pidxrng)
+			constexpr index_iterator(conditional_const_t<IndexRange, bConst>& idxrng, tc_index idx) noexcept
+				: m_oidxrng(tc::make_optional_reference_or_value(idxrng))
 				, m_idx(tc_move(idx))
 			{}
 
-			constexpr auto& get_range() const& noexcept {
-				return *VERIFY(m_pidxrng);
+			constexpr decltype(auto) get_range() const& noexcept {
+				return *m_oidxrng;
 			}
 			constexpr tc_index const& get_index() const& noexcept {
 				return m_idx;
 			}
+			constexpr tc_index&& get_index() && noexcept {
+				return tc_move(m_idx);
+			}
 
 			friend index_iterator middle_point( index_iterator const& itBegin, index_iterator const& itEnd ) noexcept requires tc::has_mem_fn_middle_point<IndexRange> {
 				index_iterator it=itBegin;
-				_ASSERTE(itBegin.m_pidxrng);
-				_ASSERTE(itBegin.m_pidxrng == itEnd.m_pidxrng);
-				tc::as_const(*itBegin.m_pidxrng).middle_point(it.m_idx,itEnd.m_idx);
+				_ASSERTE(itBegin.m_oidxrng);
+				if constexpr (!tc::empty_type<IndexRange>) _ASSERTE(std::addressof(*itBegin.m_oidxrng) == std::addressof(*itEnd.m_oidxrng));
+				tc::as_const(*itBegin.m_oidxrng).middle_point(it.m_idx,itEnd.m_idx);
 				return it;
 			}
 
@@ -278,65 +280,56 @@ namespace tc {
 			constexpr auto border_base() const& noexcept requires
 				tc::has_mem_fn_base_range<IndexRange> && tc::has_mem_fn_border_base_index<IndexRange>
 			{
-				return tc::make_iterator( VERIFY(m_pidxrng)->base_range(), tc::as_const(*m_pidxrng).border_base_index(m_idx));
+				return tc::make_iterator( m_oidxrng->base_range(), tc::as_const(*m_oidxrng).border_base_index(m_idx));
 			}
 
 			constexpr auto element_base() const& noexcept requires
 				tc::has_mem_fn_base_range<IndexRange> && tc::has_mem_fn_element_base_index<IndexRange>
 			{
-				using It = tc::element_t<tc::decay_t<decltype(tc::make_iterator(m_pidxrng->base_range(), tc::as_const(*m_pidxrng).element_base_index(m_idx)))>>;
-				if(m_pidxrng) {
-					return It(tc::make_iterator(m_pidxrng->base_range(), tc::as_const(*m_pidxrng).element_base_index(m_idx)));
+				using It = tc::element_t<tc::decay_t<decltype(tc::make_iterator(m_oidxrng->base_range(), tc::as_const(*m_oidxrng).element_base_index(m_idx)))>>;
+				if(m_oidxrng) {
+					return It(tc::make_iterator(m_oidxrng->base_range(), tc::as_const(*m_oidxrng).element_base_index(m_idx)));
 				} else {
 					return It();
 				}
 			}
 
-			constexpr decltype(auto) operator*() const noexcept(noexcept(m_pidxrng->dereference_index(m_idx))) {
-				return VERIFY(m_pidxrng)->dereference_index(m_idx);
+			constexpr decltype(auto) operator*() const noexcept(noexcept(m_oidxrng->dereference_index(m_idx))) {
+				return m_oidxrng->dereference_index(m_idx);
 			}
 
-			constexpr this_type& operator++() noexcept(noexcept(m_pidxrng->increment_index(m_idx))) {
-				tc::as_const(*VERIFY(m_pidxrng)).increment_index(m_idx);
+			constexpr this_type& operator++() noexcept(noexcept(m_oidxrng->increment_index(m_idx))) {
+				tc::as_const(*m_oidxrng).increment_index(m_idx);
 				return *this;
 			}
 
-			constexpr this_type& operator--() noexcept(noexcept(m_pidxrng->decrement_index(m_idx))) requires tc::has_mem_fn_decrement_index<IndexRange> {
-				tc::as_const(*VERIFY(m_pidxrng)).decrement_index(m_idx);
+			constexpr this_type& operator--() noexcept(noexcept(m_oidxrng->decrement_index(m_idx))) requires tc::has_mem_fn_decrement_index<IndexRange> {
+				tc::as_const(*m_oidxrng).decrement_index(m_idx);
 				return *this;
 			}
 
-			// subrange from iterator pair
-			template<typename IndexRange_, bool bConst_>
-			friend constexpr tc::make_subrange_result_t< conditional_const_t<IndexRange_,bConst_> & > make_iterator_range_impl( index_iterator<IndexRange_, bConst_> itBegin, index_iterator<IndexRange_, bConst_> itEnd ) noexcept;
-
 			explicit constexpr operator bool() const& noexcept {
-				return tc::explicit_cast<bool>(m_pidxrng);
+				return tc::explicit_cast<bool>(m_oidxrng);
 			}
 
 			friend constexpr bool operator==(index_iterator const& it, end_sentinel) noexcept {
-				return tc::as_const(*VERIFY(it.m_pidxrng)).at_end_index(it.m_idx);
+				return tc::as_const(*it.m_oidxrng).at_end_index(it.m_idx);
 			}
 
 			// For iterator_facade.
 			template<typename N> requires tc::has_mem_fn_advance_index<IndexRange>
-			constexpr void advance(N&& n) noexcept(noexcept(m_pidxrng->advance_index(m_idx, n))) {
-				tc::as_const(*VERIFY(m_pidxrng)).advance_index(m_idx, std::forward<N>(n));
+			constexpr void advance(N&& n) noexcept(noexcept(m_oidxrng->advance_index(m_idx, n))) {
+				tc::as_const(*m_oidxrng).advance_index(m_idx, std::forward<N>(n));
 			}
 
 			template< typename IndexRange_, bool bConst1, bool bConst2> requires tc::is_equality_comparable<tc::index_t<IndexRange_>>::value
 			friend constexpr bool operator==(index_iterator<IndexRange_, bConst1> const& itLhs, index_iterator<IndexRange_, bConst2> const& itRhs) noexcept;
 		};
 
-		template<typename IndexRange, bool bConst>
-		constexpr tc::make_subrange_result_t< conditional_const_t<IndexRange,bConst> & > make_iterator_range_impl( index_iterator<IndexRange, bConst> itBegin, index_iterator<IndexRange, bConst> itEnd ) noexcept {
-			return tc::make_subrange_result_t< conditional_const_t<IndexRange,bConst> & >( *VERIFYEQUALNOPRINT(VERIFY(itBegin.m_pidxrng),itEnd.m_pidxrng), tc_move(itBegin).m_idx, tc_move(itEnd).m_idx );
-		}
-
 		template< typename IndexRange_, bool bConst1, bool bConst2> requires tc::is_equality_comparable<tc::index_t<IndexRange_>>::value
 		constexpr bool operator==(index_iterator<IndexRange_, bConst1> const& itLhs, index_iterator<IndexRange_, bConst2> const& itRhs) noexcept {
-			_ASSERTE(itLhs.m_pidxrng == itRhs.m_pidxrng);
-			_ASSERTDEBUG( itLhs.m_pidxrng || itLhs.m_idx == itRhs.m_idx );
+			if constexpr (!tc::empty_type<IndexRange_>) _ASSERTE(std::addressof(*itLhs.m_oidxrng) == std::addressof(*itRhs.m_oidxrng));
+			_ASSERTDEBUG( itLhs.m_oidxrng || itLhs.m_idx == itRhs.m_idx );
 			return itLhs.m_idx == itRhs.m_idx;
 		}
 
@@ -344,14 +337,21 @@ namespace tc {
 		constexpr auto operator -(
 			index_iterator<IndexRange_, bConst1> const& itLhs,
 			index_iterator<IndexRange_, bConst2> const& itRhs) noexcept {
-			_ASSERTE(itLhs.m_pidxrng);
-			_ASSERTE(itLhs.m_pidxrng == itRhs.m_pidxrng);
-			return tc::as_const(*itLhs.m_pidxrng).distance_to_index(itRhs.m_idx, itLhs.m_idx);
+			_ASSERTE(itLhs.m_oidxrng);
+			if constexpr (!tc::empty_type<IndexRange_>) _ASSERTE(std::addressof(*itLhs.m_oidxrng) == std::addressof(*itRhs.m_oidxrng));
+			return tc::as_const(*itLhs.m_oidxrng).distance_to_index(itRhs.m_idx, itLhs.m_idx);
 		}
-
 	}
 	using index_iterator_impl::index_iterator;
 
+	template <typename It>
+	constexpr auto is_index_iterator = false;
+	template<typename IndexRange, bool bConst>
+	constexpr auto is_index_iterator<index_iterator<IndexRange, bConst>> = true;
+
+	template <typename Rng> requires tc::empty_type<Rng> && is_index_iterator<tc::iterator_t<Rng>>
+	constexpr auto enable_borrowed_range<Rng> = true;
+
 	namespace no_adl {
 		template <typename IndexRange, bool b>
 		struct is_stashing_element<tc::index_iterator<IndexRange,b>> : tc::constant<IndexRange::c_bHasStashingIndex> {};
@@ -366,12 +366,7 @@ namespace tc {
 	template<typename Rng, typename It>
 	constexpr decltype(auto) iterator2index(It&& it) noexcept {
 		if constexpr(tc::has_index<std::remove_reference_t<Rng>>) {
-			if constexpr(std::same_as<tc::index_t<std::remove_reference_t<Rng>>, std::remove_cvref_t<It>>) {
-				return std::forward<It>(it);
-			} else {
-				static_assert(iterator2index_detail::iterator_of<It, Rng>);
-				return (std::forward<It>(it).m_idx);
-			}
+			return std::remove_reference_t<Rng>::iterator2index(std::forward<It>(it));
 		} else {
 			static_assert(iterator2index_detail::iterator_of<It, Rng>);
 			return std::forward<It>(it);
diff --git a/tc/range/index_range.h b/tc/range/index_range.h
index edb55bc..b6057c0 100644
--- a/tc/range/index_range.h
+++ b/tc/range/index_range.h
@@ -49,31 +49,35 @@ namespace tc {
 		};
 
 		template<typename Rng>
-		using index_t=typename index<Rng>::type;
+		using index_t=typename index<std::remove_reference_t<Rng>>::type;
 		
 	}
 	using no_adl::index_t;
 
 	template<typename Rng>
-		requires (!tc::has_index<Rng>)
+		requires (!tc::has_index<Rng>) && tc::borrowed_range<Rng>
 	constexpr auto begin_index(Rng&& rng) return_decltype_MAYTHROW(
-		tc::begin(std::forward<Rng>(rng))
+		tc::begin(rng)
 	)
 
 	template<tc::has_index Rng>
 	constexpr auto begin_index(Rng&& rng) return_decltype_MAYTHROW(
-		std::forward<Rng>(rng).begin_index()
+		rng.begin_index()
 	)
 
+	template <typename Rng>
+	concept index_range
+		= tc::range_with_iterators<Rng> || (tc::has_index<Rng> && requires(Rng&& rng) { tc::begin_index(std::forward<Rng>(rng)); });
+
 	template<tc::common_range Rng>
-		requires (!tc::has_index<Rng>)
+		requires (!tc::has_index<Rng>) && tc::borrowed_range<Rng>
 	constexpr auto end_index(Rng&& rng) return_decltype_MAYTHROW(
-		tc::end(std::forward<Rng>(rng))
+		tc::end(rng)
 	)
 
 	template<tc::has_index Rng>
 	constexpr auto end_index(Rng&& rng) return_decltype_MAYTHROW(
-		std::forward<Rng>(rng).end_index()
+		rng.end_index()
 	)
 
 	template<typename Rng, typename It>
@@ -140,23 +144,29 @@ namespace tc {
 		template<tc::has_index Rng>
 		struct has_stashing_index<Rng> : tc::constant<Rng::c_bHasStashingIndex>  {
 			static_assert( !std::is_reference<Rng>::value );
-		};		
-
-		template<typename Rng>
-		struct is_index_valid_for_move_constructed_range : std::is_lvalue_reference<Rng> {};
-
-		template<typename It>
-		struct is_index_valid_for_move_constructed_range<tc::iterator_base<It>> : tc::constant<true> {};
-
-		template<tc::char_type Char>
-		struct is_index_valid_for_move_constructed_range<Char*> : tc::constant<true> {};
-
-		template<typename T, typename Alloc>
-		struct is_index_valid_for_move_constructed_range<std::vector<T, Alloc>> : tc::constant<true> {}; // end iterator is not guaranteed by the standard but we assume it's still valid
+		};
 	}
 	using no_adl::is_stashing_element;
 	using no_adl::has_stashing_index;
-	using no_adl::is_index_valid_for_move_constructed_range;
+
+	/////////////////////////////////////////////
+	// stable index range
+	// If `tc::stable_index_on_move<Rng>`, `Rng` has indices and an index is not invalidated when the `Rng` object is moved.
+	// This is true for:
+	// * borrowed ranges, where the iterator indices are completely decoupled from `Rng` anyway
+	// * `std::vector` (but not `std::string` due to SSO)
+	// * ...
+	template <typename Rng>
+	constexpr auto enable_stable_index_on_move = false;
+
+	template <typename Rng>
+	concept stable_index_on_move
+		= tc::index_range<Rng> && (std::is_lvalue_reference<Rng>::value || enable_stable_index_on_move<std::remove_cvref_t<Rng>>);
+
+	template <typename Rng> requires tc::borrowed_range<Rng>
+	constexpr auto enable_stable_index_on_move<Rng> = true;
+	template <typename T, typename Alloc>
+	constexpr auto enable_stable_index_on_move<std::vector<T, Alloc>> = true; // end iterator is not guaranteed by the standard but we assume it's still valid
 
 	/////////////////////////////////////////////
 	// bidirectional index ranges
@@ -202,13 +212,14 @@ namespace tc {
 	}
 
 	template<tc::has_index Rng, typename Index, typename Difference>
-	constexpr void advance_index(Rng const& rng, Index& idx, Difference&& d) MAYTHROW {
-		rng.advance_index(idx, std::forward<Difference>(d));
-	}
+	constexpr auto advance_index(Rng const& rng, Index& idx, Difference&& d) return_decltype_MAYTHROW(
+		rng.advance_index(idx, std::forward<Difference>(d))
+	)
 
 	TC_HAS_MEM_FN_XXX_CONCEPT_DEF(advance_index, const&, std::declval<typename T::tc_index &>(), std::declval<T const&>().distance_to_index(std::declval<typename T::tc_index const&>(), std::declval<typename T::tc_index const&>()))
 	TC_HAS_EXPR(advance_index, (Rng), tc::advance_index(std::declval<Rng const&>(), std::declval<index_t<Rng> &>(), tc::distance_to_index(std::declval<Rng const&>(), std::declval<index_t<Rng> const&>(), std::declval<index_t<Rng> const&>())));
 
+
 	/////////////////////////////////////////////
 	// contiguous index ranges
 
@@ -233,7 +244,15 @@ namespace tc {
 	/////////////////////////////////////////////
 	// index ranges with middle point
 	namespace iterator {
+		#ifdef __clang__
+			#pragma clang diagnostic push
+			#pragma clang diagnostic ignored "-Wundefined-inline"
+			#pragma clang diagnostic ignored "-Wundefined-internal"
+		#endif
 		template<typename It> constexpr It middle_point(It const&, It const&) noexcept;
+		#ifdef __clang__
+			#pragma clang diagnostic pop
+		#endif
 	}
 
 	template<typename Rng, typename ItLhs, typename ItRhs>
@@ -243,66 +262,15 @@ namespace tc {
 	}
 
 	template<tc::has_index Rng, typename IndexLhs, typename IndexRhs >
-	constexpr void middle_point(Rng const& rng, IndexLhs& idxLhs, IndexRhs const& idxRhs) MAYTHROW {
-		rng.middle_point(idxLhs,idxRhs);
-	}
+	constexpr auto middle_point(Rng const& rng, IndexLhs& idxLhs, IndexRhs const& idxRhs) return_decltype_MAYTHROW(
+		rng.middle_point(idxLhs,idxRhs)
+	)
 
 	TC_HAS_MEM_FN_XXX_CONCEPT_DEF(middle_point, const&, std::declval<typename T::tc_index &>(), std::declval<typename T::tc_index const&>());
 	TC_HAS_EXPR(middle_point, (Rng), tc::middle_point(std::declval<Rng const&>(), std::declval<index_t<Rng> &>(), std::declval<index_t<Rng> const&>()));
 
 	/////////////////////////////////////////////
 	// make_iterator
-	namespace no_adl {
-		template< typename It >
-		struct TC_EMPTY_BASES iterator_base {
-			using iterator = It;
-			using const_iterator = It;
-			using tc_index = It;
-
-			static constexpr bool c_bHasStashingIndex=tc::is_stashing_element<It>::value;
-
-			static constexpr typename std::iterator_traits<iterator>::reference dereference_index(tc_index const& idx) noexcept {
-				return *idx;
-			}
-
-			static constexpr void increment_index(tc_index& idx) noexcept {
-				++idx;
-			}
-
-			static constexpr void decrement_index(tc_index& idx) noexcept {
-				--idx;
-			}
-
-			static constexpr void advance_index(tc_index& idx, typename std::iterator_traits<iterator>::difference_type d) noexcept {
-				idx+=d;
-			}
-
-			template <ENABLE_SFINAE>
-#ifdef _LIBCPP_VERSION
-				requires tc::contiguous_range_detail::contiguous_iterator<It>
-#else
-				requires std::contiguous_iterator<It>
-#endif
-			static constexpr auto index_to_address(SFINAE_TYPE(tc_index) const& idx) MAYTHROW {
-				return std::to_address(idx);
-			}
-
-			template<ENABLE_SFINAE>
-			static constexpr auto distance_to_index(SFINAE_TYPE(tc_index) const& idxLhs, tc_index const& idxRhs) return_decltype_NOEXCEPT(
-				idxRhs - idxLhs
-			)
-
-			static constexpr void middle_point( tc_index & idxBegin, tc_index const& idxEnd ) noexcept {
-				idxBegin=tc::iterator::middle_point( idxBegin, idxEnd );
-			}
-
-			static constexpr iterator make_iterator( tc_index idx ) noexcept {
-				return idx;
-			}
-		};
-	}
-	using no_adl::iterator_base;
-
 	template<typename Rng, typename It > requires (!tc::has_index< std::remove_reference_t<Rng> >)
 	constexpr decltype(auto) make_iterator(Rng&&, It&& it) noexcept {
 		return std::forward<It>(it);
diff --git a/tc/range/intersection_adaptor.h b/tc/range/intersection_adaptor.h
index 3bd0259..ca6f1aa 100644
--- a/tc/range/intersection_adaptor.h
+++ b/tc/range/intersection_adaptor.h
@@ -11,13 +11,13 @@
 #include "../base/assert_defs.h"
 #include "../algorithm/compare.h"
 #include "../algorithm/algorithm.h"
-#include "range_fwd.h"
 #include "filter_adaptor.h"
 
 namespace tc {
 	namespace intersection_difference_adaptor_adl {
 		template<
 			bool bIntersection,
+			bool bSubset,
 			typename Comp,
 			typename Rng0,
 			typename Rng1
@@ -60,16 +60,18 @@ namespace tc {
 			};
 
 		public:
-			template<tc::decayed_derived_from<intersection_difference_adaptor> Self, typename Sink> requires
-				tc::range_with_iterators<Rng1>
+			template<tc::decayed_derived_from<intersection_difference_adaptor> Self, typename Sink>
 			friend constexpr auto for_each_impl(Self&& self, Sink&& sink) MAYTHROW {
+				auto const NotInRng0 = [](tc::unused) noexcept {
+					_ASSERT(!bSubset);
+				};
 				if constexpr (bIntersection) {
 					return tc::interleave_2(
 						*tc::get<0>(std::forward<Self>(self).m_tplbaserng),
 						*tc::get<1>(std::forward<Self>(self).m_tplbaserng),
 						std::forward<Self>(self).m_comp,
 						tc::noop(),
-						tc::noop(),
+						NotInRng0,
 						FForwardFirstArgOnly<tc::decay_t<Sink>>{std::forward<Sink>(sink)}
 					);
 				} else {
@@ -78,34 +80,7 @@ namespace tc {
 						*tc::get<1>(std::forward<Self>(self).m_tplbaserng),
 						std::forward<Self>(self).m_comp,
 						std::forward<Sink>(sink),
-						tc::noop(),
-						tc::noop()
-					);
-				}
-			}
-
-			template<tc::decayed_derived_from<intersection_difference_adaptor> Self, typename Sink> requires
-				tc::range_with_iterators<Rng0> && (!tc::range_with_iterators<Rng1>)
-			friend constexpr auto for_each_impl(Self&& self, Sink&& sink) MAYTHROW {
-				auto const predReverse = [pred=tc::decay_copy(std::forward<Self>(self).m_comp)](auto const& lhs, auto const& rhs) noexcept {
-					return tc::negate(pred(rhs, lhs));
-				};
-				if constexpr (bIntersection) {
-					return tc::interleave_2(
-						*tc::get<1>(std::forward<Self>(self).m_tplbaserng),
-						*tc::get<0>(std::forward<Self>(self).m_tplbaserng),
-						predReverse,
-						tc::noop(),
-						tc::noop(),
-						FForwardFirstArgOnly<tc::decay_t<Sink>>{std::forward<Sink>(sink)}
-					);
-				} else {
-					return tc::interleave_2(
-						*tc::get<1>(std::forward<Self>(self).m_tplbaserng),
-						*tc::get<0>(std::forward<Self>(self).m_tplbaserng),
-						predReverse,
-						tc::noop(),
-						std::forward<Sink>(sink),
+						NotInRng0,
 						tc::noop()
 					);
 				}
@@ -142,26 +117,17 @@ namespace tc {
 		return set_intersect_or_difference<false>(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1));
 	}
 
-	template<typename Rng0, typename Rng1, typename Comp>
-	auto intersect(Rng0&& rng0, Rng1&& rng1, Comp&& comp) return_ctor_noexcept(
-		TC_FWD(intersection_difference_adaptor<true, tc::decay_t<Comp>, Rng0, Rng1>),
-		(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1), std::forward<Comp>(comp))
-	)
-
-	template<typename Rng0, typename Rng1>
-	auto intersect(Rng0&& rng0, Rng1&& rng1) return_decltype_noexcept(
-		intersect(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1), tc::fn_compare())
-	)
-
-	template<typename Rng0, typename Rng1, typename Comp>
-	auto difference(Rng0&& rng0, Rng1&& rng1, Comp&& comp) return_ctor_noexcept(
-		TC_FWD(intersection_difference_adaptor<false, tc::decay_t<Comp>, Rng0, Rng1>),
-		(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1), std::forward<Comp>(comp))
-	)
-
-	template<typename Rng0, typename Rng1>
-	auto difference(Rng0&& rng0, Rng1&& rng1) return_decltype_noexcept(
-		difference(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1), tc::fn_compare())
+#pragma push_macro("DEFINE_INTERSECT_DIFFERENCE")
+#define DEFINE_INTERSECT_DIFFERENCE(name, bIntersect, bSubset) \
+	template<typename Rng0, typename Rng1, typename Comp = tc::fn_compare> \
+	auto name(Rng0&& rng0, Rng1&& rng1, Comp&& comp = Comp()) return_ctor_noexcept( \
+		TC_FWD(intersection_difference_adaptor<bIntersect, bSubset, tc::decay_t<Comp>, Rng0, Rng1>), \
+		(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1), std::forward<Comp>(comp)) \
 	)
 
+	DEFINE_INTERSECT_DIFFERENCE(intersect, true, false)
+	DEFINE_INTERSECT_DIFFERENCE(subset_intersect, true, true)
+	DEFINE_INTERSECT_DIFFERENCE(difference, false, false)
+	DEFINE_INTERSECT_DIFFERENCE(subset_difference, false, true)
+#pragma pop_macro("DEFINE_INTERSECT_DIFFERENCE")
 }
diff --git a/tc/range/intersection_adaptor.t.cpp b/tc/range/intersection_adaptor.t.cpp
index ec6a2cb..f45cff3 100644
--- a/tc/range/intersection_adaptor.t.cpp
+++ b/tc/range/intersection_adaptor.t.cpp
@@ -41,7 +41,7 @@ UNITTESTDEF(intersection_difference) {
 		})
 	);
 
-	tc::for_each(rngndiff3, [](auto n) noexcept {
+	tc::for_each(rngndiff3, [](auto const n) noexcept {
 	});
 	_ASSERT(tc::equal(rngndiff3, tc::make_array(tc::aggregate_tag,0,5)));
 
diff --git a/tc/range/iota_range.h b/tc/range/iota_range.h
index 11247bb..01129fd 100644
--- a/tc/range/iota_range.h
+++ b/tc/range/iota_range.h
@@ -114,7 +114,7 @@ MODIFY_WARNINGS_END
 		};
 
 		template<typename T, std::enable_if_t<!std::is_unsigned<T>::value>* = nullptr>
-		constexpr auto operator -(counting_iterator<T> const& a, counting_iterator<T> const& b) return_decltype_NOEXCEPT( // NOEXCEPT() for e.g. counting_iterator<tc::vector<T>::iterator>
+		constexpr auto operator -(counting_iterator<T> const& a, counting_iterator<T> const& b) return_decltype_NOEXCEPT( // NOEXCEPT() for e.g. counting_iterator<tc::iterator_t<tc::vector<T>>>
 			tc::as_signed(*a - *b)
 		)
 
@@ -131,6 +131,9 @@ MODIFY_WARNINGS_END
 		struct is_stashing_element<tc::counting_iterator<T>> : tc::constant<true> {};
 	}
 
+	template <typename Rng> requires tc::instance<tc::iterator_t<Rng>, tc::counting_iterator>
+	constexpr auto enable_borrowed_range<Rng> = true;
+
 	template<typename TBegin, typename TEnd>
 	[[nodiscard]] constexpr auto iota(TBegin const& tBegin, TEnd const& tEnd) noexcept {
 		using T = tc::counting_iterator<tc::common_type_t<TBegin, TEnd> >;
@@ -145,8 +148,8 @@ MODIFY_WARNINGS_END
 		struct is_iota_range_impl final: tc::constant<false> {};
 
 		template<typename T>
-		struct is_iota_range_impl<tc::subrange<tc::iterator_base<tc::counting_iterator<T>>>> final: tc::constant<true> {
-			STATICASSERTSAME(decltype(tc::iota(std::declval<T>(), std::declval<T>())), tc::subrange<tc::iterator_base<tc::counting_iterator<T>>>);
+		struct is_iota_range_impl<tc::subrange<tc::universal_range<tc::counting_iterator<T>>>> final: tc::constant<true> {
+			STATICASSERTSAME(decltype(tc::iota(std::declval<T>(), std::declval<T>())), tc::subrange<tc::universal_range<tc::counting_iterator<T>>>);
 		};
 	}
 
@@ -156,10 +159,6 @@ MODIFY_WARNINGS_END
 	namespace no_adl {
 		template<typename Rng>
 		struct [[nodiscard]] range_of_elements {
-			// iterator and const_iterator for compatibility with boost::range
-			using const_iterator=tc::counting_iterator< decltype(tc::begin(*std::declval<tc::reference_or_value<Rng> const&>())) >;
-			using iterator=tc::counting_iterator< decltype(tc::begin(*std::declval<tc::reference_or_value<Rng>&>())) >;
-
 			template<typename Rhs>
 			constexpr range_of_elements(aggregate_tag_t, Rhs&& rhs) noexcept
 				: m_rng(aggregate_tag, std::forward<Rhs>(rhs))
@@ -186,19 +185,21 @@ MODIFY_WARNINGS_END
 		return_ctor_noexcept( no_adl::range_of_elements< Rng >, (aggregate_tag, std::forward<Rng>(rng)) )
 
 	namespace no_adl {
-		template<auto first, decltype(first) last
+		template<auto Begin, decltype(Begin) End
 #ifdef _MSC_VER // MSVC 19.31 sometimes incorrectly folds iota_range_constant<EnumUnrelated(0), EnumUnrelated(7)> and iota_range_constant<Enum(0), Enum(7)>. I don't have a concise repro for this behavior.
-			, typename MsvcWorkaround = decltype(first)
+			, typename MsvcWorkaround = decltype(Begin)
 #endif
 		>
 		struct [[nodiscard]] iota_range_constant {
-			using const_iterator = tc::counting_iterator<decltype(first)>;
-			using iterator = const_iterator;
-			static constexpr iterator begin() noexcept {
-				return iterator(first);
+			static constexpr auto begin() noexcept {
+				return tc::counting_iterator(Begin);
 			}
-			static constexpr iterator end() noexcept {
-				return iterator(last);
+			static constexpr auto end() noexcept {
+				return tc::counting_iterator(End);
+			}
+
+			static constexpr auto size() noexcept {
+				return tc::least_uint_constant<tc::as_unsigned(End - Begin)>{};
 			}
 		};
 
@@ -222,16 +223,13 @@ MODIFY_WARNINGS_END
 				return RangeReturn::template pack_element<all_values>(e);
 			}
 		}
-
-		template<typename Enum>
-		struct constexpr_size_impl<all_values<Enum>> : tc::constant<enum_count<Enum>::value> {};
-
-		template<typename Enum>
-		struct is_index_valid_for_move_constructed_range<all_values<Enum>> : tc::constant<true> {};
 	}
 	using no_adl::iota_range_constant;
 	using no_adl::all_values;
 
+	template <typename Enum>
+	constexpr auto enable_borrowed_range<tc::all_values<Enum>> = true;
+
 	template<typename Enum>
 	inline auto constexpr all_constants = tc::tuple_transform(
 		tc::index_sequence_as_tuple(std::make_index_sequence<tc::size(tc::all_values<Enum>())>()),
diff --git a/tc/range/iterator_cache.h b/tc/range/iterator_cache.h
index 3517ac2..2152744 100644
--- a/tc/range/iterator_cache.h
+++ b/tc/range/iterator_cache.h
@@ -32,10 +32,10 @@ namespace tc {
 				return *this;
 			}
 
-			constexpr auto operator*() const & return_decltype_noexcept( *m_ref )
+			constexpr auto operator*() const& return_decltype_noexcept( *m_ref )
 			constexpr auto operator*() && return_decltype_xvalue_by_ref_noexcept( *tc_move(m_ref) )
-			constexpr auto operator*() const && noexcept = delete;
+			constexpr auto operator*() const&& noexcept = delete;
 		};
 	}
 	using no_adl::iterator_cache;
-}
\ No newline at end of file
+}
diff --git a/tc/range/join_adaptor.h b/tc/range/join_adaptor.h
index ccd8421..81a474b 100644
--- a/tc/range/join_adaptor.h
+++ b/tc/range/join_adaptor.h
@@ -14,6 +14,7 @@
 #include "../algorithm/size_linear.h"
 #include "range_adaptor.h"
 #include "transform_adaptor.h"
+#include "reverse_adaptor.h"
 
 namespace tc {
 	void join();
@@ -31,14 +32,15 @@ namespace tc {
 				std::is_lvalue_reference<std::iter_reference_t<tc::iterator_t<RngRng>>>::value
 			> {};
 
-			template<typename RngRng>
-			using rng_constexpr_size = tc::constexpr_size<tc::type::apply_t<
+			template <typename RngRng, typename CommonOutput = tc::type::apply_t<
 				tc::common_reference_xvalue_as_ref_t,
 				tc::type::transform_t<
 					tc::range_output_t<RngRng>,
 					std::add_rvalue_reference_t
-				>
-			>>;
+				>>
+			>
+				requires tc::has_constexpr_size<CommonOutput>
+			auto constexpr rng_constexpr_size = tc::constexpr_size<CommonOutput>;
 		}
 
 		template<typename RngRng, bool bHasIterator = join_adaptor_detail::is_joinable_with_iterators<RngRng>::value>
@@ -84,11 +86,12 @@ namespace tc {
 				return join_sink<tc::decay_t<Sink>, bReverse>{std::forward<Sink>(sink)};
 			}
 
-			template<ENABLE_SFINAE>
-			constexpr auto size() const& return_decltype_noexcept(
-				// Use tc::mul and boost::multiprecision::number?
-				tc::size_raw(SFINAE_VALUE(this)->base_range()) * join_adaptor_detail::rng_constexpr_size<decltype(SFINAE_VALUE(this)->base_range())>::value
-			)
+			constexpr auto size() const& MAYTHROW
+				requires tc::has_size<RngRng> && requires(join_adaptor const& join) { join_adaptor_detail::rng_constexpr_size<decltype(join.base_range())>; } {
+				return tc::compute_range_adaptor_size<[](auto const n) noexcept {
+					return tc::as_unsigned(n * join_adaptor_detail::rng_constexpr_size<decltype(std::declval<join_adaptor>().base_range())>());
+				}>(this->base_range());
+			}
 
 			template<ENABLE_SFINAE>
 			constexpr auto size_linear() const& return_decltype_noexcept(
@@ -197,15 +200,12 @@ namespace tc {
 				return tc::get<0>(idx);
 			}
 		};
-
-		template<tc::has_constexpr_size RngRng> requires requires {	join_adaptor_detail::rng_constexpr_size<decltype(std::declval<join_adaptor<RngRng> const&>().base_range())>::value; }
-		struct constexpr_size_impl<join_adaptor<RngRng>>
-			: tc::constant<tc::constexpr_size<RngRng>::value * join_adaptor_detail::rng_constexpr_size<decltype(std::declval<join_adaptor<RngRng> const&>().base_range())>::value
-			>
-		{};
 	}
 	using no_adl::join_adaptor;
 
+	template<typename RngRng>
+	constexpr auto enable_stable_index_on_move<join_adaptor<RngRng, true>> = tc::stable_index_on_move<RngRng>;
+
 	namespace join_default {
 		template<typename RngRng>
 		constexpr join_adaptor<RngRng> join_impl(RngRng&& rngrng) noexcept {
@@ -214,9 +214,4 @@ namespace tc {
 	}
 
 	DEFINE_TMPL_FUNC_WITH_CUSTOMIZATIONS(join)
-
-	namespace no_adl {
-		template<typename RngRng>
-		struct is_index_valid_for_move_constructed_range<join_adaptor<RngRng, true>> : tc::is_index_valid_for_move_constructed_range<RngRng> {};
-	}
 }
diff --git a/tc/range/join_framed_adaptor.h b/tc/range/join_framed_adaptor.h
index 949c12e..eb450bb 100644
--- a/tc/range/join_framed_adaptor.h
+++ b/tc/range/join_framed_adaptor.h
@@ -21,14 +21,14 @@ namespace tc {
 			(tc::for_each(std::forward<Rng>(rng), [&](auto&& t) MAYTHROW {
 				using T = decltype(t);
 				return tc_break_or_continue_sequence(
-					(CONDITIONAL_PRVALUE_AS_VAL(tc::change(bEmpty, false),
+					(tc_conditional_prvalue_as_val(tc::change(bEmpty, false),
 						tc_internal_continue_if_not_break(funcBegin()),
 						tc_internal_continue_if_not_break(funcSeparator())
 					))
 					(tc::continue_if_not_break(funcElement, std::forward<T>(t)))
 				);
 			}))
-			(CONDITIONAL_PRVALUE_AS_VAL(!bEmpty,
+			(tc_conditional_prvalue_as_val(!bEmpty,
 				tc_internal_continue_if_not_break(funcEnd()),
 				tc::constant<tc::continue_>()
 			))
diff --git a/tc/range/literal_range.h b/tc/range/literal_range.h
new file mode 100644
index 0000000..66a4d36
--- /dev/null
+++ b/tc/range/literal_range.h
@@ -0,0 +1,82 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "meta.h"
+#include "../base/casts.h"
+
+namespace tc {
+	namespace literal_range_detail {
+		template <typename T, auto ... Ts>
+		inline constexpr T const array[] = {T(Ts)...};
+
+		// We make it static, so it matches a string literal.
+		// That way, compilers are able to de-duplicate it: https://godbolt.org/z/4bbYK5E95
+		template <tc::char_like T, auto ... Ts>
+		static constexpr T const str[] = {T(Ts)..., T()};
+	}
+
+	namespace literal_range_adl {
+		// Note that Ts... does not have the type of T but can be some other type, that can be used to construct T in the array initializer.
+		// This keeps the instantiated name of the type small - for example, a value of tc::char_ascii is something like `tc::char_ascii<template-params>{tc::additive<>{}, value}`,
+		// but if passed as `char` it is just `value`.
+		template <typename T, auto... Ts>
+		struct literal_range final {
+			// The return type should be an array reference so we don't lose type information.
+			// However, there is a bug in the current MSVC version, that doesn't allow decltype(auto): https://developercommunity.visualstudio.com/t/decltypeauto-strips-reference-of-array-types/218527
+			static constexpr auto as_array() noexcept -> T const (&)[sizeof...(Ts) + (tc::char_like<T> ? 1 : 0)]{
+				if constexpr (tc::char_like<T>) {
+					return literal_range_detail::str<T, Ts...>;
+				} else {
+					return literal_range_detail::array<T, Ts...>;
+				}
+			}
+
+			// Implicit conversion to C string, if it's a C string.
+			template <std::same_as<T const*> Target>
+			constexpr operator Target() const& noexcept
+				requires tc::char_like<T> && (tc::strlen(literal_range::as_array()) == sizeof...(Ts))
+			{
+				return as_array(); // decays to pointer
+			}
+
+			constexpr T const* begin() const& noexcept {
+				return as_array();
+			}
+			constexpr T const* end() const& noexcept {
+				return as_array() + sizeof...(Ts);
+			}
+
+			static constexpr auto size() noexcept {
+				return tc::least_uint_constant<sizeof...(Ts)>{};
+			}
+		};
+
+		template <tc::char_like T, auto ... Ts>
+		[[nodiscard]] constexpr auto as_c_str_impl(literal_range<T, Ts...> rng) return_decltype_noexcept(
+			tc::implicit_cast<T const*>(rng)
+		)
+	}
+	using literal_range_adl::literal_range;
+
+	template <typename T, auto ... Ts>
+	inline constexpr auto enable_borrowed_range<tc::literal_range<T, Ts...>> = true;
+
+	template <auto ... Ts>
+	constexpr literal_range<tc::common_type_t<decltype(Ts)...>, Ts...> literal_range_of = {};
+
+	namespace literal_range_detail {
+		template <typename T>
+		constexpr auto is_literal_range = false;
+		template <typename T, auto ... Ts>
+		constexpr auto is_literal_range<literal_range<T, Ts...>> = true;
+	}
+	template <typename T>
+	concept is_literal_range = literal_range_detail::is_literal_range<tc::decay_t<T>>;
+}
diff --git a/tc/range/literal_range.t.cpp b/tc/range/literal_range.t.cpp
new file mode 100644
index 0000000..fa4a6a6
--- /dev/null
+++ b/tc/range/literal_range.t.cpp
@@ -0,0 +1,36 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "../base/assert_defs.h"
+#include "../unittest.h"
+#include "literal_range.h"
+#include "../string/make_c_str.h"
+#include "../array.h"
+
+UNITTESTDEF(literal_range) {
+	std::same_as<tc::literal_range<int, 1, 2, 3>> auto rng = tc::literal_range_of<1, 2, 3>;
+	TEST_RANGE_EQUAL(rng, (std::array<int, 3>{1, 2, 3}));
+	_ASSERTEQUAL(tc::make_array(rng), (std::array<int, 3>{1, 2, 3}));
+}
+
+UNITTESTDEF(literal_range_string) {
+	std::same_as<tc::literal_range<char, 'a', 'b', 'c'>> auto rng = tc::literal_range_of<'a', 'b', 'c'>;
+	TEST_RANGE_EQUAL(rng, (std::array<char, 3>{'a', 'b', 'c'}));
+	_ASSERTEQUAL(tc::make_array(rng), (std::array<char, 3>{'a', 'b', 'c'}));
+
+	char const* implicit_str = rng;
+	_ASSERTEQUAL(implicit_str[0], 'a');
+	_ASSERTEQUAL(implicit_str[1], 'b');
+	_ASSERTEQUAL(implicit_str[2], 'c');
+	_ASSERTEQUAL(implicit_str[3], '\0');
+
+	_ASSERTEQUAL(tc::as_c_str(rng), implicit_str);
+	// GCC doesn't like it without the implicit cast.
+	_ASSERTEQUAL(tc::implicit_cast<char const*>(tc::make_c_str(rng)), implicit_str);
+	_ASSERTEQUAL(tc::make_str(rng), "abc");
+}
diff --git a/tc/range/merge_range.h b/tc/range/merge_range.h
index 2fdf0a7..7518e77 100644
--- a/tc/range/merge_range.h
+++ b/tc/range/merge_range.h
@@ -8,30 +8,17 @@
 
 #pragma once
 
-#include "../base/assert_defs.h"
-#include "../algorithm/compare.h"
-#include "../algorithm/algorithm.h"
-#include "range_fwd.h"
-#include "range_adaptor.h"
+#include "union_adaptor.h"
 
 namespace tc {
 	template<typename Rng0, typename Rng1, typename Less = tc::fn_less>
 	[[nodiscard]] auto merge_range(Rng0&& rng0, Rng1&& rng1, Less&& less = Less()) noexcept {
-		return [
-			rng0 = tc::make_reference_or_value(std::forward<Rng0>(rng0)),
-			rng1 = tc::make_reference_or_value(std::forward<Rng1>(rng1)),
-			less = std::forward<Less>(less)
-		](auto&& sink) MAYTHROW {
-			return tc::interleave_2(
-				*rng0,
-				*rng1,
-				[&](auto const& lhs, auto const& rhs) noexcept {
-					return less(rhs, lhs) ? std::weak_ordering::greater : std::weak_ordering::less;
-				},
-				sink,
-				sink,
-				tc::never_called()
-			);
-		};
+		return tc::disjoint_union_range(
+			std::forward<Rng0>(rng0),
+			std::forward<Rng1>(rng1),
+			[less=tc::decay_copy(std::forward<Less>(less))](auto const& lhs, auto const& rhs) noexcept {
+				return less(rhs, lhs) ? std::weak_ordering::greater : std::weak_ordering::less;
+			}
+		);
 	}
 }
diff --git a/tc/range/merge_ranges.h b/tc/range/merge_ranges.h
index 4d6f0a2..1393406 100644
--- a/tc/range/merge_ranges.h
+++ b/tc/range/merge_ranges.h
@@ -19,7 +19,7 @@ namespace tc {
 				tc::filter(
 					tc::transform(
 						std::forward<RngRng>(rngrng),
-						tc_fn(tc::make_view)
+						tc_fn(tc::all)
 					),
 					tc_fn(!tc::empty)
 				),
diff --git a/tc/range/merge_ranges.t.cpp b/tc/range/merge_ranges.t.cpp
index f3c1814..d71256f 100644
--- a/tc/range/merge_ranges.t.cpp
+++ b/tc/range/merge_ranges.t.cpp
@@ -96,11 +96,11 @@ UNITTESTDEF(merge_ranges_with_unique_range_2) {
 		tc::merge_many(
 			tc::transform(
 				tc::iota(0,5),
-				[&](int n) noexcept {
+				[&](int const n) noexcept {
 					return tc::ordered_unique_range(
 						tc::zip(
-							tc::make_view(vecvecn[n]),
-							tc::make_view(vecvecn2[n])
+							tc::all(vecvecn[n]),
+							tc::all(vecvecn2[n])
 						),
 						lesspred
 					);
diff --git a/tc/range/meta.h b/tc/range/meta.h
index 6028ac9..ee424f1 100644
--- a/tc/range/meta.h
+++ b/tc/range/meta.h
@@ -12,39 +12,46 @@
 #include "../base/type_traits_fwd.h"
 #include "../base/functors.h"
 #include "../base/tag_type.h"
+#include "../base/casts.h"
 #include "../container/string.h"
-#include "range_fwd.h"
+#include "../tuple.h"
 
+#include <boost/range/has_range_iterator.hpp>
 #include <type_traits>
 #include <iterator>
+#include <ranges>
+#include <boost/range/traversal.hpp>
 
 namespace tc {
 	namespace begin_end_adl {
 		DEFINE_ADL_TAG_TYPE(begin_end_tag);
 	}
 
-	template<typename Rng>
+	template <typename Rng>
+	concept borrowed_range_impl = (std::is_lvalue_reference<Rng>::value || std::ranges::enable_borrowed_range<std::remove_cvref_t<Rng>>);
+
+	template<tc::borrowed_range_impl Rng>
 	[[nodiscard]] constexpr auto begin(Rng&& rng) return_decltype_MAYTHROW(
 		// Rng has member begin
-		std::forward<Rng>(rng).begin()
+		rng.begin()
 	)
 
-	template<typename Rng>
+	template<tc::borrowed_range_impl Rng>
 	[[nodiscard]] constexpr auto begin(Rng&& rng) return_decltype_MAYTHROW(
 		// Rng has free begin found by tag
-		begin(begin_end_adl::begin_end_tag, std::forward<Rng>(rng))
+		begin(begin_end_adl::begin_end_tag, rng)
 	)
 
-	template<typename Rng>
+	template<tc::borrowed_range_impl Rng>
 	[[nodiscard]] constexpr auto end(Rng&& rng) return_decltype_MAYTHROW(
 		// Rng has member end
-		std::forward<Rng>(rng).end()
+		rng.end()
 	)
 
-	template<typename Rng>
+	template<tc::borrowed_range_impl Rng>
 	[[nodiscard]] constexpr auto end(Rng&& rng) return_decltype_MAYTHROW(
 		// Rng has free end found by tag
-		end(begin_end_adl::begin_end_tag, std::forward<Rng>(rng))
+		end(begin_end_adl::begin_end_tag, rng)
 	)
 
 	template<typename Rng>
@@ -53,7 +60,35 @@ namespace tc {
 	using sentinel_t = decltype(tc::end(std::declval<Rng&>()));
 
 	template<typename Rng>
-	concept common_range = std::same_as<tc::iterator_t<Rng>, tc::sentinel_t<Rng>>;
+	concept range_with_iterators = requires {
+		typename tc::iterator_t<Rng>;
+		typename tc::sentinel_t<Rng>;
+	};
+
+	template<typename Rng>
+	concept common_range = tc::range_with_iterators<Rng> && std::same_as<tc::iterator_t<Rng>, tc::sentinel_t<Rng>>;
+
+	// `Rng` models `tc::borrowed_range` iff the validity of iterators of `Rng` is not tied to the lifetime of the `Rng` object:
+	// * references to containers (not containers themselves)
+	// * tc::span
+	// * ...
+	template<typename Rng>
+	concept borrowed_range = tc::range_with_iterators<Rng> && tc::borrowed_range_impl<Rng>;
+
+	// For convenience, you can specialize `tc::enable_borrowed_range` instead of `std::ranges::enable_borrowed_range` which doesn't require opening up a separate namespace.
+	// (There is a specialization of `std::ranges::enable_borrowed_range` at the end of the file.)
+	template<typename Rng>
+	constexpr auto enable_borrowed_range = nullptr; // primary is "disabled"
+
+	namespace detail {
+		template<typename Rng, typename Required>
+		concept has_traversal = tc::range_with_iterators<Rng> && std::convertible_to<typename boost::range_traversal<Rng>::type, Required>;
+	}
+
+	template<typename Rng>
+	concept bidirectional_range = detail::has_traversal<Rng, boost::iterators::bidirectional_traversal_tag>;
+	template<typename Rng>
+	concept random_access_range = detail::has_traversal<Rng, boost::iterators::random_access_traversal_tag>;
 
 	// Note that we cannot use std::contiguous_iterator yet as it is broken on our version of libcxx.
 	// So instead we just check the iterator category as a proxy.
@@ -83,12 +118,16 @@ namespace tc {
 		concept contiguous_iterator = std::is_pointer_v<It> || std::is_base_of_v<std::contiguous_iterator_tag, iterator_concept<It>>;
 	}
 	template <typename Rng>
-	concept contiguous_range = contiguous_range_detail::contiguous_iterator<tc::iterator_t<Rng>>;
+	concept contiguous_range = tc::range_with_iterators<Rng> && contiguous_range_detail::contiguous_iterator<tc::iterator_t<Rng>>;
 #else
 	template <typename Rng>
-	concept contiguous_range = std::contiguous_iterator<tc::iterator_t<Rng>>;
+	concept contiguous_range = tc::range_with_iterators<Rng> && std::contiguous_iterator<tc::iterator_t<Rng>>;
 #endif
 
+	template <typename ... Rng>
+	concept ranges_with_common_reference
+		= (... && tc::range_with_iterators<Rng>) && tc::has_common_reference_prvalue_as_val<std::iter_reference_t<tc::iterator_t<Rng>>...>;
+
 	namespace range_output_t_adl {
 		DEFINE_ADL_TAG_TYPE(adl_tag);
 
@@ -192,22 +231,10 @@ namespace tc {
 
 	namespace no_adl {
 		template<typename Rng>
-		struct constexpr_size_impl {};
-
-		template<typename T, std::size_t N>
-		struct constexpr_size_impl<T[N]> : tc::constant<N - (tc::char_type<T> ? 1 : 0)> {};
-
-		template<typename T, T... t>
-		struct constexpr_size_impl<std::integer_sequence<T, t...>> : tc::constant<sizeof...(t)> {};
-
-		template<typename Tuple> requires requires { std::tuple_size<Tuple>::value; } && (!requires { tc::begin(std::declval<Tuple>()); })
-		struct constexpr_size_impl<Tuple>: tc::constant<std::tuple_size<Tuple>::value> {};
+		struct constexpr_size_impl;
 	}
 	template<typename Rng>
-	using constexpr_size = no_adl::constexpr_size_impl<std::remove_cvref_t<Rng>>;
-
-	template<typename Rng>
-	concept has_constexpr_size = requires { tc::constexpr_size<Rng>::value; };
+	concept has_constexpr_size = requires { no_adl::constexpr_size_impl<std::remove_cvref_t<Rng>>::value; };
 
 	template<typename T>
 	[[nodiscard]] constexpr std::size_t strlen( T const* pt ) noexcept {
@@ -246,11 +273,12 @@ namespace tc {
 		}
 		template<typename T, std::size_t N>
 		constexpr T* end_array_impl(T (&at)[N]) noexcept {
-			constexpr auto nSize = tc::constexpr_size<T[N]>::value;
 			if constexpr (tc::char_type<T>) {
-				_ASSERTE( tc::strlen(at) == nSize );
+				_ASSERTE( tc::strlen(at) == N - 1 );
+				return at + N - 1;
+			} else {
+				return at + N;
 			}
-			return at + nSize;
 		}
 		template<typename T, std::size_t N>
 		constexpr T* end(begin_end_tag_t, T (&at)[N]) noexcept {
@@ -270,73 +298,58 @@ namespace tc {
 			return pairit.second;
 		}
 	}
+
+	template <typename It>
+	constexpr auto enable_borrowed_range<std::pair<It, It>> = true;
+}
+
+namespace boost {
+	template<typename Rng> requires std::same_as<Rng, std::remove_cvref_t<Rng>> && requires { typename tc::iterator_t<Rng>; }
+	struct range_mutable_iterator<Rng> {
+		using type = tc::iterator_t<Rng>;
+	};
+
+	template<typename Rng> requires std::same_as<Rng, std::remove_cvref_t<Rng>> && requires { typename tc::iterator_t<std::add_const_t<Rng>>; }
+	struct range_const_iterator<Rng> {
+		using type = tc::iterator_t<std::add_const_t<Rng>>;
+	};
 }
 
 #pragma push_macro("CHAR_RANGE")
 #define CHAR_RANGE( xchar ) \
-namespace boost { \
-	template<> \
-	struct range_mutable_iterator<xchar*> { \
-		using type = xchar*; \
-	}; \
-	template<> \
-	struct range_const_iterator<xchar*> { \
-		using type = xchar*; \
-	}; \
-	template<> \
-	struct range_mutable_iterator<xchar const*> { \
-		using type = xchar const*; \
-	}; \
-	template<> \
-	struct range_const_iterator<xchar const*> { \
-		using type = xchar const*; \
-	}; \
-	template<std::size_t N> \
-	struct range_mutable_iterator<xchar[N]> { \
-		using type = xchar*; \
-	}; \
-	template<std::size_t N> \
-	struct range_const_iterator<xchar[N]> { \
-		using type = xchar const*; \
-	}; \
-	/* support array-of-unknown-bounds incomplete type */ \
-	template<> \
-	struct range_mutable_iterator<xchar[]> { \
-		using type = xchar*; \
-	}; \
-	template<> \
-	struct range_const_iterator<xchar[]> { \
-		using type = xchar const*; \
-	}; \
-} \
 namespace tc { \
 	namespace begin_end_adl { \
 		/* Note: We cannot use overloading to differentiate xchar* and xchar(&)[N]. */ \
 		template<typename CharPtrConvertible> requires \
 			tc::safely_convertible_to<CharPtrConvertible, xchar*> \
 				&& (!tc::has_constexpr_size<CharPtrConvertible>) \
-		constexpr xchar* begin(begin_end_tag_t, CharPtrConvertible&& pchc) noexcept { \
+		constexpr xchar* begin(begin_end_tag_t, CharPtrConvertible& pchc) noexcept { \
 			return pchc; \
 		} \
 		template<typename CharPtrConvertible> requires \
 			tc::safely_convertible_to<CharPtrConvertible, xchar const*> \
 				&& (!tc::safely_convertible_to<CharPtrConvertible, xchar*>) \
 				&& (!tc::has_constexpr_size<CharPtrConvertible>) \
-		constexpr xchar const* begin(begin_end_tag_t, CharPtrConvertible&& pchc) noexcept { \
+		constexpr xchar const* begin(begin_end_tag_t, CharPtrConvertible& pchc) noexcept { \
 			return pchc; \
 		} \
 		template<typename CharPtrConvertible> requires \
 			tc::safely_convertible_to<CharPtrConvertible, xchar const*> \
 				&& (!tc::has_constexpr_size<CharPtrConvertible>) \
-		constexpr tc::zero_termination_sentinel end(begin_end_tag_t, CharPtrConvertible&& pchc) noexcept { \
-			_ASSERT( pchc ); \
+		constexpr tc::zero_termination_sentinel end(begin_end_tag_t, CharPtrConvertible& pchc) noexcept { \
+			_ASSERT( tc::implicit_cast<xchar const*>(pchc) ); \
 			return {}; \
 		} \
 	} \
+	template <> \
+	inline constexpr auto enable_borrowed_range<xchar*> = true; \
+	template <> \
+	inline constexpr auto enable_borrowed_range<xchar const*> = true; \
 }
 
 CHAR_RANGE(char)
 CHAR_RANGE(wchar_t)
+CHAR_RANGE(char8_t)
 CHAR_RANGE(char16_t)
 CHAR_RANGE(char32_t)
 
@@ -355,23 +368,23 @@ namespace tc{
 
 namespace tc_begin_end_no_adl {
 	template< typename Rng >
-	auto adl_begin(Rng&& rng) return_decltype_MAYTHROW(
+	auto adl_begin(Rng& rng) return_decltype_MAYTHROW(
 		// Rng has free begin found by ADL
-		begin( std::forward<Rng>(rng) )
+		begin( rng )
 	)
 
 	template< typename Rng >
-	auto adl_end(Rng&& rng) return_decltype_MAYTHROW(
+	auto adl_end(Rng& rng) return_decltype_MAYTHROW(
 		// Rng has free end found by ADL
-		end( std::forward<Rng>(rng) )
+		end( rng )
 	)
 }
 
 namespace tc {
 	template <typename Rng>
-	auto cyclic_next(tc::iterator_t<Rng> it, Rng&& rng) noexcept {
+	auto cyclic_next(tc::iterator_t<Rng> it, Rng& rng) noexcept {
 		++it;
-		return tc::end(rng)==it ? tc::begin(std::forward<Rng>(rng)) : it;
+		return tc::end(rng)==it ? tc::begin(rng) : it;
 	}
 }
 
@@ -390,21 +403,82 @@ namespace tc {
 namespace boost {
 	template< typename Rng >
 	auto begin(Rng&& rng) return_decltype_MAYTHROW(
-		tc::begin( std::forward<Rng>(rng) )
+		tc::begin( rng )
 	)
 
 	template< typename Rng >
 	auto end(Rng&& rng) return_decltype_MAYTHROW(
-		tc::end( std::forward<Rng>(rng) )
+		tc::end( rng )
 	)
 
 	template< typename Rng >
-	auto const_begin(Rng&& rng) return_decltype_MAYTHROW(
-		tc::begin( std::forward<Rng>(rng) )
+	auto const_begin(Rng const& rng) return_decltype_MAYTHROW(
+		tc::begin( rng )
 	)
 
 	template< typename Rng >
-	auto const_end(Rng&& rng) return_decltype_MAYTHROW(
-		tc::end( std::forward<Rng>(rng) )
+	auto const_end(Rng const& rng) return_decltype_MAYTHROW(
+		tc::end( rng )
 	)
 }
+
+//////////////////////////////////////////////
+// std.range compatiblity
+namespace std::ranges {
+	template <typename Rng> requires (std::same_as<decltype(tc::enable_borrowed_range<Rng>), const bool>)
+	constexpr bool enable_borrowed_range<Rng> = tc::enable_borrowed_range<Rng>;
+}
+
+//////////////////////////////////////////////
+// range customizations for tuple_like types
+namespace tc {
+	namespace no_adl {
+		template<typename Tuple> requires requires { std::tuple_size<Tuple>::value; } && (!requires { tc::begin(std::declval<Tuple>()); })
+		struct constexpr_size_impl<Tuple>: tc::least_uint_constant<std::tuple_size<Tuple>::value> {};
+	}
+
+	namespace tuple_detail {
+		template<std::size_t I, tuple_like... Tuple>
+		constexpr auto zip_get(Tuple&&... tuple) noexcept {
+			// Tuple elements are tc::apply_cvref_t<std::tuple_element_t<I, std::remove_cvref_t<Tuple>>, Tuple>... unless tuple is tc::tuple and element types is empty.
+			return tc::tuple<std::conditional_t<
+				std::is_rvalue_reference<std::tuple_element_t<I, std::remove_cvref_t<Tuple>>>::value,
+				decltype(tc::get<I>(std::declval<Tuple>())),
+				tc::remove_rvalue_reference_t<decltype(tc::get<I>(std::declval<Tuple>()))>
+			>...>{{
+				{tc::get<I>(std::forward<Tuple>(tuple))}...
+			}};
+		}
+
+		template<std::size_t... I, tuple_like... Tuple>
+		constexpr auto zip_impl(std::index_sequence<I...>, Tuple&&... tuple) noexcept {
+			return tc::tuple<decltype(tuple_detail::zip_get<I>(std::forward<Tuple>(tuple)...))...>{{ // tc::make_tuple without extra copy
+				{tuple_detail::zip_get<I>(std::forward<Tuple>(tuple)...)}...
+			}};
+		}
+	}
+
+	template<tuple_like Tuple0, tuple_like... Tuple>
+		requires (!tc::range_with_iterators<Tuple0> || ... || !tc::range_with_iterators<Tuple>) // Prefer zip_adaptor for zip(std::array...)
+	[[nodiscard]] constexpr auto zip(Tuple0&& tuple0, Tuple&&... tuple) noexcept {
+		static_assert( ((std::tuple_size<std::remove_reference_t<Tuple0>>::value == std::tuple_size<std::remove_reference_t<Tuple>>::value) && ...) );
+		return tuple_detail::zip_impl(
+			std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple0>>::value>(),
+			std::forward<Tuple0>(tuple0),
+			std::forward<Tuple>(tuple)...
+		);
+	}
+
+	template<typename TIndex, TIndex... Is>
+	[[nodiscard]] consteval tc::tuple<tc::constant<Is>...> index_sequence_as_tuple(std::integer_sequence<TIndex, Is...>) {
+		return {};
+	}
+
+	template<tuple_like Tuple> requires (!tc::range_with_iterators<Tuple>)
+	[[nodiscard]] constexpr auto enumerate(Tuple&& tuple) noexcept {
+		return tc::zip(
+			tc::index_sequence_as_tuple(std::make_integer_sequence<int, std::tuple_size<std::remove_reference_t<Tuple>>::value>()),
+			std::forward<Tuple>(tuple)
+		);
+	}
+}
diff --git a/tc/range/ordered_pairs.h b/tc/range/ordered_pairs.h
index dbaca7e..b6db723 100644
--- a/tc/range/ordered_pairs.h
+++ b/tc/range/ordered_pairs.h
@@ -46,18 +46,14 @@ namespace tc {
 				return tc::constant<tc::continue_>();
 			}
 
-			constexpr auto size() const& noexcept requires tc::has_size<Rng> {
-				std::size_t const nSize = tc::size_raw(this->base_range());
-				return nSize * (nSize - 1) / 2;
+			constexpr auto size() const& MAYTHROW requires tc::has_size<Rng> {
+				return tc::compute_range_adaptor_size<[](auto const n) noexcept {
+					return tc::as_unsigned(n * (n - 1) / 2);
+				}>(this->base_range());
 			}
 		};
 	}
 
-	namespace no_adl {
-		template<tc::has_constexpr_size Rng>
-		struct constexpr_size_impl<ordered_pairs_adaptor_adl::ordered_pairs_adaptor<Rng>> : tc::constant<tc::constexpr_size<Rng>::value * (tc::constexpr_size<Rng>::value - 1) / 2> {};
-	}
-
 	template<typename Rng>
 	auto ordered_pairs(Rng&& rng) return_ctor_noexcept(
 		ordered_pairs_adaptor_adl::ordered_pairs_adaptor<Rng>,
diff --git a/tc/range/partial_sum.h b/tc/range/partial_sum.h
index 6bdf19c..a783d7c 100644
--- a/tc/range/partial_sum.h
+++ b/tc/range/partial_sum.h
@@ -36,7 +36,7 @@ namespace tc {
 			constexpr auto operator()(Sink sink) const& MAYTHROW {
 				tc::decay_t<T> accu = *m_init;
 				return tc_break_or_continue_sequence(
-					(CONDITIONAL_PRVALUE_AS_VAL(
+					(tc_conditional_prvalue_as_val(
 						c_bIncludeInit,
 						tc::continue_if_not_break(sink, tc::as_const(accu)),
 						tc::constant<tc::continue_>()
@@ -48,12 +48,11 @@ namespace tc {
 				);
 			}
 
-			template<ENABLE_SFINAE>
-			constexpr auto size() const& noexcept -> tc::decay_t<decltype(tc::size_raw(SFINAE_VALUE(this)->base_range()))> {
-				return tc_modified(
-					tc::size_raw(this->base_range()),
-					if constexpr( c_bIncludeInit ) ++_;
-				);
+			constexpr auto size() const& MAYTHROW requires tc::has_size<Rng> {
+				return tc::compute_range_adaptor_size<[](auto n) noexcept {
+					if constexpr (c_bIncludeInit) ++n;
+					return n;
+				}>(this->base_range());
 			}
 		};
 	}
diff --git a/tc/range/range.t.cpp b/tc/range/range.t.cpp
index ae82f8e..bcc277d 100644
--- a/tc/range/range.t.cpp
+++ b/tc/range/range.t.cpp
@@ -112,8 +112,8 @@ namespace {
 UNITTESTDEF( generator_range ) {
    TEST_init_hack(tc::vector, int, vexp, {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48});
 
-   TEST_RANGE_EQUAL(vexp, tc::filter( void_range(generator_range()), [](int i) noexcept { return i%2==0; } ));
-   TEST_RANGE_EQUAL(tc::filter( void_range(generator_range()), [](int i) noexcept { return i%2==0; } ), vexp);
+   TEST_RANGE_EQUAL(vexp, tc::filter( void_range(generator_range()), [](int const i) noexcept { return i%2==0; } ));
+   TEST_RANGE_EQUAL(tc::filter( void_range(generator_range()), [](int const i) noexcept { return i%2==0; } ), vexp);
 }
 
 //---- Generator Range (with break) -------------------------------------------------------------------------------------------
@@ -135,9 +135,9 @@ UNITTESTDEF( N3752 ) {
 
    auto r =  tc::filter( tc::filter( tc::filter(
                                 v,
-                                [](int i) noexcept { return i%2!=0; } ),
-                                [](int i) noexcept { return i%3!=0; } ),
-                                [](int i) noexcept { return i%5!=0; } );
+                                [](int const i) noexcept { return i%2!=0; } ),
+                                [](int const i) noexcept { return i%3!=0; } ),
+                                [](int const i) noexcept { return i%5!=0; } );
 
    TEST_init_hack(tc::vector, int, vexp, {1, 7, 11, 13, 17, 19});
    TEST_RANGE_EQUAL(vexp, r);
@@ -249,7 +249,7 @@ UNITTESTDEF( construct_array_from_range ) {
 	auto an=tc::explicit_cast<std::array<int, 10>>(rng);
 	auto anCopy=an;
 	tc::array<int&, 10> anRef(an);
-	tc::for_each(rng, [&](int n) {
+	tc::for_each(rng, [&](int const n) {
 		_ASSERTEQUAL(tc::at(an, n), n);
 		_ASSERTEQUAL(tc::at(anCopy, n), n);
 		_ASSERTEQUAL(tc::at(anRef, n), n);
@@ -421,7 +421,7 @@ UNITTESTDEF(filter_with_generator_range) {
 		tc::max_element<tc::return_value>(
 			tc::filter(
 				GeneratorInt(),
-				[](int n) noexcept {return 1==n%2;}
+				[](int const n) noexcept {return 1==n%2;}
 			)
 		),
 		3
@@ -438,7 +438,7 @@ UNITTESTDEF(filter_with_generator_range) {
 		tc::max_element<tc::return_value>(
 			tc::transform(
 				GeneratorInt(),
-				[](int n) noexcept {return -n;}
+				[](int const n) noexcept {return -n;}
 			)
 		),
 		-1
@@ -446,7 +446,7 @@ UNITTESTDEF(filter_with_generator_range) {
 
 	auto const tr1 = tc::transform(
 		GeneratorInt(),
-		[](int n) noexcept {return -n;}
+		[](int const n) noexcept {return -n;}
 	);
 
 	static_assert(
@@ -458,7 +458,7 @@ UNITTESTDEF(filter_with_generator_range) {
 
 	auto const filtered = tc::filter(
 		GeneratorInt(),
-		[](int n) noexcept {return n>0;}
+		[](int const n) noexcept {return n>0;}
 	);
 	static_assert(
 		std::is_same<
@@ -518,7 +518,7 @@ UNITTESTDEF(filter_with_generator_range) {
 }
 
 UNITTESTDEF(make_constexpr_array_test) {
-	constexpr auto const& an = as_constexpr(tc::make_array(tc::aggregate_tag, 1, 2, 3));
+	constexpr auto const& an = tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1, 2, 3));
 	static_assert(tc::at(an, 0) == 1);
 	static_assert(tc::at(an, 1) == 2);
 	static_assert(tc::at(an, 2) == 3);
@@ -542,7 +542,7 @@ namespace {
 		tc::for_each(tc::cartesian_product(tc::as_const(an), tc::as_const(an)), [](auto&& x){
 			STATICASSERTSAME(decltype(x), (tc::tuple<int const&, const int&>&&));
 		});
-		auto rvaluerng = [](auto sink) { sink(1); };
+		auto const rvaluerng = [](auto sink) { sink(1); };
 		tc::for_each(tc::cartesian_product(rvaluerng, rvaluerng), [](auto&& x){
 			STATICASSERTSAME(decltype(x), (tc::tuple<int const&&, int&&>&&));
 		});
diff --git a/tc/range/range_adaptor.h b/tc/range/range_adaptor.h
index ae4e886..6b85c37 100644
--- a/tc/range/range_adaptor.h
+++ b/tc/range/range_adaptor.h
@@ -30,74 +30,84 @@ namespace tc {
 	// Basic building block for all ranges.
 	// Comes in two variations, one for generator ranges, one for iterator ranges. 
 	//
-	namespace range_iterator_from_index_impl {
-
-		template<
-			typename Derived,
-			typename Index
-		>
-		struct TC_EMPTY_BASES range_iterator_from_index {
+	namespace no_adl {
+		template <typename Derived, typename Index>
+		struct TC_EMPTY_BASES index_range_interface {
 		private:
-			using this_type = range_iterator_from_index;
+			using this_type = index_range_interface;
 		public:
-			////////////////////////////////////////////////////////
-			// simulate iterator interface on top of index interface
-
 			using tc_index = Index;
 
-			using iterator = index_iterator< Derived, false >;
-			using const_iterator = index_iterator< Derived, true >;
-			STATIC_VIRTUAL_CONSTEXPR(begin_index)
-			STATIC_VIRTUAL_CONSTEXPR(end_index)
-			STATIC_VIRTUAL_CONSTEXPR(at_end_index)
-			STATIC_VIRTUAL_CONSTEXPR(increment_index)
-			STATIC_VIRTUAL_CONSTEXPR(decrement_index)
-			STATIC_VIRTUAL_CONSTEXPR(dereference_index)
-			STATIC_VIRTUAL_CONSTEXPR(advance_index)
-			STATIC_VIRTUAL_CONSTEXPR(index_to_address)
-			STATIC_VIRTUAL_CONSTEXPR(distance_to_index)
-			STATIC_VIRTUAL_CONSTEXPR(middle_point)
-
-			constexpr const_iterator make_iterator( tc_index idx ) const& noexcept {
-				return const_iterator(tc::derived_cast<Derived>(MSVC_WORKAROUND_THIS), tc_move(idx));
-			}
-
-			constexpr const_iterator begin() const&
-				return_MAYTHROW(make_iterator(begin_index()))
+			STATIC_VIRTUAL(begin_index)
+			STATIC_VIRTUAL(end_index)
+			STATIC_VIRTUAL(increment_index)
+			STATIC_VIRTUAL(decrement_index)
+			STATIC_VIRTUAL(dereference_index)
+			STATIC_VIRTUAL(advance_index)
+			STATIC_VIRTUAL(index_to_address)
+			STATIC_VIRTUAL(distance_to_index)
+			STATIC_VIRTUAL(middle_point)
+
+			STATIC_VIRTUAL_WITH_DEFAULT_IMPL_MOD(
+				TC_FWD(
+					template<typename Derived_ = Derived> requires has_mem_fn_end_index<Derived_> && tc::is_equality_comparable<Index>::value
+					constexpr
+				),
+			at_end_index)(tc_index const& idx) const&
+				return_MAYTHROW(end_index() == idx)
 
-			template<typename Derived_=Derived, std::enable_if_t<!has_mem_fn_end_index<Derived_> || !tc::is_equality_comparable<Index>::value>* = nullptr>
-			constexpr end_sentinel end() const& noexcept {
-				return {};
-			}
+		};
+	}
+	using no_adl::index_range_interface;
 
-			template<typename Derived_ = Derived, std::enable_if_t<has_mem_fn_end_index<Derived_> && tc::is_equality_comparable<Index>::value>* = nullptr>
-			constexpr const_iterator end() const&
-				return_MAYTHROW(make_iterator(end_index()))
+	namespace no_adl {
+		// simulate iterator interface on top of index interface
+		template <typename Derived, typename Index>
+		struct TC_EMPTY_BASES range_iterator_from_index : index_range_interface<Derived, Index> {
+		private:
+			using iterator = index_iterator<Derived, false>;
+			using const_iterator = index_iterator<Derived, true>;
 
-			constexpr iterator make_iterator( tc_index idx ) & noexcept {
-				return iterator(tc::derived_cast<Derived>(MSVC_WORKAROUND_THIS),tc_move(idx));
+		public:
+			constexpr iterator make_iterator(auto&& idx) & noexcept {
+				return iterator(*tc::derived_cast<Derived>(MSVC_WORKAROUND_THIS),tc_move_if_owned(idx));
+			}
+			constexpr const_iterator make_iterator(auto&& idx) const& noexcept {
+				return const_iterator(*tc::derived_cast<Derived>(MSVC_WORKAROUND_THIS), tc_move_if_owned(idx));
 			}
 
 			constexpr iterator begin() &
-				return_MAYTHROW(make_iterator(begin_index()))
+				return_MAYTHROW(make_iterator(this->begin_index()))
+			constexpr const_iterator begin() const&
+				return_MAYTHROW(make_iterator(this->begin_index()))
+
 
-			template<typename Derived_ = Derived, std::enable_if_t<has_mem_fn_end_index<Derived_> && tc::is_equality_comparable<Index>::value>* = nullptr>
+			template<typename Derived_ = Derived>
+				requires tc::has_mem_fn_end_index<Derived_> && tc::is_equality_comparable<Index>::value
 			constexpr iterator end() &
-				return_MAYTHROW(make_iterator(end_index()))
+				return_MAYTHROW(make_iterator(this->end_index()))
+			template<typename Derived_ = Derived>
+				requires tc::has_mem_fn_end_index<Derived_> && tc::is_equality_comparable<Index>::value
+			constexpr const_iterator end() const&
+				return_MAYTHROW(make_iterator(this->end_index()))
 
-			constexpr bool empty() const&
-				return_MAYTHROW(at_end_index(begin_index()))
+			template<typename Derived_ = Derived> // no requires, so lower priority
+			constexpr end_sentinel end() const& noexcept {
+				return {};
+			}
 
-			STATIC_OVERRIDE_MOD(
-				TC_FWD(
-					template<typename Derived_ = Derived, std::enable_if_t<has_mem_fn_end_index<Derived_> && tc::is_equality_comparable<Index>::value>* = nullptr>
-					constexpr
-				),
-			at_end_index)(tc_index const& idx) const&
-				return_MAYTHROW(end_index() == idx)
+			template<typename It>
+			constexpr static decltype(auto) iterator2index(It&& it) noexcept {
+				if constexpr(std::same_as<Index, std::remove_cvref_t<It>>) {
+					return std::forward<It>(it);
+				} else {
+					static_assert(std::same_as<Index, std::remove_cvref_t<decltype(it.m_idx)>>);
+					return (std::forward<It>(it).m_idx);
+				}
+			}
 		};
 	}
-	using range_iterator_from_index_impl::range_iterator_from_index;
+	using no_adl::range_iterator_from_index;
 
 	namespace no_adl {
 		template<typename Rng>
@@ -152,14 +162,6 @@ namespace tc {
 				std::forward<Self>(self).adapted_sink(std::forward<Sink>(sink), /*bReverse*/tc::constant<false>())
 			)
 		)
-
-		template<typename Self, typename Sink, typename std::remove_reference_t<Self>::is_generator_range_adaptor* = nullptr>
-		constexpr auto for_each_reverse_impl(Self&& self, Sink&& sink) return_decltype_MAYTHROW(
-			tc::for_each(
-				tc::reverse(std::forward<Self>(self).base_range()),
-				std::forward<Self>(self).adapted_sink(std::forward<Sink>(sink), /*bReverse*/tc::constant<true>())
-			)
-		)
 	}
 	using generator_range_adl::generator_range_adaptor;
 
@@ -240,99 +242,192 @@ namespace tc {
 	}
 	using range_output_from_base_range_adl::range_output_from_base_range;
 
+	//-------------------------------------------------------------------------------------------------------------------------
+	// iterator/index based ranges
+	//
+	// they derive from the generator case, because the generator interface can transparently and efficiently be added
+	// to any iterator or index based range.
+	//
+	namespace index_range_adaptor_flags_adl {
+		// Cannot use tc::enumset due to cyclic dependency.
+		enum class index_range_adaptor_flags {
+			inherit_none = 0,
+
+			inherit_begin = 1 << 0,
+			inherit_end = 1 << 1,
+			inherit_begin_end = inherit_begin | inherit_end,
+
+			inherit_dereference = 1 << 2,
+			inherit_traversal = 1 << 3,
+			inherit_behavior = inherit_dereference | inherit_traversal,
+
+			inherit_all = inherit_begin_end | inherit_behavior,
+		};
+		TC_BITMASK_OPS(index_range_adaptor_flags)
+	}
+	using index_range_adaptor_flags_adl::index_range_adaptor_flags;
+
 	namespace no_adl {
-		//-------------------------------------------------------------------------------------------------------------------------
-		// iterator/index based ranges
-		//
-		// they derive from the generator case, because the generator interface can transparently and efficiently be added
-		// to any iterator or index based range.
-		//
+		namespace index_range_adaptor_detail {
+			template <typename Derived, typename Rng, bool InheritBehavior>
+			struct iterator_range_interface : tc::range_iterator_from_index<Derived, tc::index_t<Rng>> {};
+
+			template <typename Derived, typename Rng>
+				requires tc::range_with_iterators<Rng>
+			struct iterator_range_interface<Derived, Rng, true> : tc::index_range_interface<Derived, tc::index_t<Rng>> {
+			private:
+				using iterator = tc::iterator_t<decltype(*std::declval<tc::reference_or_value<Rng>&>())>;
+				using const_iterator = tc::iterator_t<decltype(*std::declval<tc::reference_or_value<Rng> const&>())>;
+				
+				struct sentinel {
+					Derived const* self;
+
+					constexpr bool operator==(auto const& it) const MAYTHROW {
+						return tc::at_end_index(*self, tc::iterator2index<Rng>(it));
+					}
+				};
+
+			public:
+				constexpr iterator make_iterator(auto&& idx) & return_MAYTHROW(
+					tc::make_iterator(tc::derived_cast<Derived>(MSVC_WORKAROUND_THIS)->base_range(), tc_move_if_owned(idx))
+				)
+				constexpr const_iterator make_iterator(auto&& idx) const& return_MAYTHROW(
+					tc::make_iterator(tc::derived_cast<Derived>(MSVC_WORKAROUND_THIS)->base_range(), tc_move_if_owned(idx))
+				)
+
+				constexpr iterator begin() &
+					return_MAYTHROW(make_iterator(this->begin_index()))
+				constexpr const_iterator begin() const&
+					return_MAYTHROW(make_iterator(this->begin_index()))
+
+				template<typename Derived_ = Derived>
+					requires tc::has_mem_fn_end_index<Derived_>
+				constexpr iterator end() &
+					return_MAYTHROW(make_iterator(this->end_index()))
+				template<typename Derived_ = Derived>
+					requires tc::has_mem_fn_end_index<Derived_>
+				constexpr const_iterator end() const&
+					return_MAYTHROW(make_iterator(this->end_index()))
+
+				template<typename Derived_ = Derived> // no requires, so lower priority
+				constexpr auto end() const& noexcept {
+					return sentinel{tc::derived_cast<Derived>(MSVC_WORKAROUND_THIS)};
+				}
+
+				template<typename It>
+				constexpr static decltype(auto) iterator2index(It&& it) noexcept {
+					return tc::iterator2index<Rng>(std::forward<It>(it));
+				}
+			};
+		}
 
 		template<
-			typename Derived 
-			, typename Rng
-			, typename Base = tc::range_adaptor_base_range<Rng>
-			, typename MaximumTraversal = boost::iterators::random_access_traversal_tag // This is used to ensure that filter_adaptor is never random access
-			, bool WithMiddlePoint = true
+			typename Derived,
+			typename Rng, index_range_adaptor_flags Flags,
+			typename Base = tc::range_adaptor_base_range<Rng>
 		>
 		struct TC_EMPTY_BASES index_range_adaptor
 			: Base
-			, range_iterator_from_index<
-				Derived,
-				tc::index_t<std::remove_reference_t<Rng>>
+			, index_range_adaptor_detail::iterator_range_interface<
+				Derived, Rng,
+				(Flags & index_range_adaptor_flags::inherit_behavior) == index_range_adaptor_flags::inherit_behavior
 			>
 		{
 		private:
 			using this_type = index_range_adaptor;
-			
-		public:
-			constexpr index_range_adaptor()=default;
 
+		public:
+			constexpr index_range_adaptor() = default;
 			using Base::Base;
-			using tc_index = tc::index_t<std::remove_reference_t<Rng>>;
+
+			using tc_index = tc::index_t<Rng>;
 			static constexpr bool c_bHasStashingIndex=tc::has_stashing_index<std::remove_reference_t<Rng>>::value;
+
 		private:
-			STATIC_OVERRIDE_MOD(constexpr,begin_index)() const& return_MAYTHROW(
-				this->base_begin_index()
-			)
+			static constexpr auto inherit_begin = static_cast<bool>(Flags & index_range_adaptor_flags::inherit_begin);
 
-			STATIC_OVERRIDE_MOD(template<ENABLE_SFINAE> constexpr,end_index)() const& return_decltype_MAYTHROW(
-				SFINAE_VALUE(this)->base_end_index()
-			)
+			STATIC_OVERRIDE_MOD(constexpr,begin_index)() const& MAYTHROW
+				requires inherit_begin
+			{
+				return this->base_begin_index();
+			}
 
-			STATIC_OVERRIDE_MOD(constexpr,at_end_index)(tc_index const& idx) const& return_MAYTHROW(
-				tc::at_end_index(this->base_range(),idx)
-			)
+		private:
+			static constexpr auto inherit_end = static_cast<bool>(Flags & index_range_adaptor_flags::inherit_end);
 
-			STATIC_OVERRIDE_MOD(constexpr,dereference_index)(tc_index const& idx) & return_decltype_xvalue_by_ref_MAYTHROW(
-				tc::dereference_index(this->base_range(),idx)
-			)
+			STATIC_OVERRIDE_MOD(constexpr,end_index)() const& MAYTHROW
+				requires inherit_end && tc::has_end_index<Rng>
+			{
+				return this->base_end_index();
+			}
 
-			STATIC_OVERRIDE_MOD(constexpr,dereference_index)(tc_index const& idx) const& return_decltype_xvalue_by_ref_MAYTHROW(
-				tc::dereference_index(this->base_range(),idx)
-			)
+			STATIC_OVERRIDE_MOD(constexpr,at_end_index)(tc_index const& idx) const& MAYTHROW
+				requires inherit_end
+			{
+				return tc::at_end_index(this->base_range(),idx);
+			}
 
-			STATIC_OVERRIDE_MOD(constexpr,increment_index)(tc_index& idx) const& return_MAYTHROW(
-				tc::increment_index(this->base_range(),idx)
-			)
+		private:
+			static constexpr auto inherit_dereference = static_cast<bool>(Flags & index_range_adaptor_flags::inherit_dereference);
 
-			STATIC_OVERRIDE_MOD(constexpr, decrement_index)(tc_index& idx) const& MAYTHROW -> void
-				requires
-					tc::has_decrement_index<std::remove_reference_t<Rng>> &&
-					boost::iterators::detail::is_traversal_at_least<MaximumTraversal, boost::iterators::bidirectional_traversal_tag>::value
+			STATIC_OVERRIDE_MOD(constexpr,dereference_index)(tc_index const& idx) & MAYTHROW -> decltype(tc::dereference_index(this->base_range(), idx))
+				requires inherit_dereference
 			{
-				tc::decrement_index(this->base_range(),idx);
+				return tc::dereference_index(this->base_range(),idx);
 			}
-
-			STATIC_OVERRIDE_MOD(constexpr, advance_index)(tc_index& idx, typename boost::range_difference<Rng>::type d) const& MAYTHROW -> void
-				requires
-					tc::has_advance_index<std::remove_reference_t<Rng>> &&
-					boost::iterators::detail::is_traversal_at_least<MaximumTraversal, boost::iterators::random_access_traversal_tag>::value
+			STATIC_OVERRIDE_MOD(constexpr,dereference_index)(tc_index const& idx) const& MAYTHROW -> decltype(tc::dereference_index(this->base_range(), idx))
+				requires inherit_dereference
 			{
-				tc::advance_index(this->base_range(),idx,d);
+				return tc::dereference_index(this->base_range(),idx);
 			}
 
 			STATIC_OVERRIDE_MOD(constexpr, index_to_address)(tc_index const& idx) & MAYTHROW
-				requires tc::has_index_to_address<std::remove_reference_t<Rng>>
+				requires inherit_dereference && tc::has_index_to_address<std::remove_reference_t<Rng>>
 			{
 				return tc::index_to_address(this->base_range(), idx);
 			}
 			STATIC_OVERRIDE_MOD(constexpr, index_to_address)(tc_index const& idx) const& MAYTHROW
-				requires tc::has_index_to_address<std::remove_reference_t<Rng>>
+				requires inherit_dereference && tc::has_index_to_address<std::remove_reference_t<Rng>>
 			{
 				return tc::index_to_address(this->base_range(), idx);
 			}
 
-			STATIC_OVERRIDE_MOD(constexpr, distance_to_index)(tc_index const& idxLhs, tc_index const& idxRhs) const& noexcept
-				requires
-					tc::has_distance_to_index<std::remove_reference_t<Rng>> &&
-					boost::iterators::detail::is_traversal_at_least<MaximumTraversal, boost::iterators::random_access_traversal_tag>::value
+		public:
+			constexpr decltype(auto) dereference_untransform(tc_index const& idx) const& noexcept
+				requires inherit_dereference
+			{
+				return this->base_range().dereference_untransform(idx);
+			}
+
+		private:
+			static constexpr auto inherit_traversal = static_cast<bool>(Flags & index_range_adaptor_flags::inherit_traversal);
+
+			STATIC_OVERRIDE_MOD(constexpr,increment_index)(tc_index& idx) const& MAYTHROW
+				requires inherit_traversal
+			{
+				tc::increment_index(this->base_range(),idx);
+			}
+
+			STATIC_OVERRIDE_MOD(constexpr, decrement_index)(tc_index& idx) const& MAYTHROW
+				requires inherit_traversal && tc::has_decrement_index<std::remove_reference_t<Rng>>
+			{
+				tc::decrement_index(this->base_range(),idx);
+			}
+
+			STATIC_OVERRIDE_MOD(constexpr, advance_index)(tc_index& idx, typename boost::range_difference<Rng>::type d) const& MAYTHROW
+				requires inherit_traversal && tc::has_advance_index<std::remove_reference_t<Rng>>
+			{
+				tc::advance_index(this->base_range(),idx,d);
+			}
+
+			STATIC_OVERRIDE_MOD(constexpr, distance_to_index)(tc_index const& idxLhs, tc_index const& idxRhs) const& MAYTHROW
+				requires inherit_traversal && tc::has_distance_to_index<std::remove_reference_t<Rng>>
 			{
 				return tc::distance_to_index(this->base_range(),idxLhs,idxRhs);
 			}
 
-			STATIC_OVERRIDE_MOD(constexpr, middle_point)( tc_index & idxBegin, tc_index const& idxEnd ) const& noexcept -> void
-				requires WithMiddlePoint && tc::has_middle_point<std::remove_reference_t<Rng>>
+			STATIC_OVERRIDE_MOD(constexpr, middle_point)( tc_index & idxBegin, tc_index const& idxEnd ) const& MAYTHROW
+				requires inherit_traversal && tc::has_middle_point<std::remove_reference_t<Rng>>
 			{
 				tc::middle_point(this->base_range(),idxBegin,idxEnd);
 			}
@@ -389,7 +484,7 @@ namespace tc {
 }
 
 namespace tc::no_adl {
-	template<typename... T>
+	template<typename... T> requires (requires { typename tc::value_t<T>; } && ...)
 	struct value_type_impl<tc::tuple<T...>> final {
 		using type = tc::tuple<tc::value_t<T>...>;
 	};
diff --git a/tc/range/range_fwd.h b/tc/range/range_fwd.h
deleted file mode 100644
index 1feb3ec..0000000
--- a/tc/range/range_fwd.h
+++ /dev/null
@@ -1,79 +0,0 @@
-
-// think-cell public library
-//
-// Copyright (C) 2016-2023 think-cell Software GmbH
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
-
-#pragma once
-
-#include "../base/explicit_cast_fwd.h"
-#include <boost/range/has_range_iterator.hpp>
-#include <type_traits>
-
-namespace tc {
-	template<typename Rng>
-	concept range_with_iterators = boost::has_range_iterator<Rng>::value;
-
-	namespace no_adl {
-		template<typename It>
-		struct iterator_base;
-	}
-	using no_adl::iterator_base;
-
-	namespace subrange_adl {
-		template< typename Rng >
-		struct subrange;
-	}
-	using subrange_adl::subrange;
-
-	namespace transform_adaptor_adl {
-		template< typename Func, typename Rng, bool HasIterator=tc::range_with_iterators< Rng > >
-		struct transform_adaptor;
-	}
-	using transform_adaptor_adl::transform_adaptor;
-
-	namespace no_adl {
-		template< typename Pred, typename Rng, bool HasIterator=tc::range_with_iterators< Rng > >
-		struct filter_adaptor;
-	}
-	using no_adl::filter_adaptor;
-
-	namespace no_adl {
-		template< typename Pred, typename Rng, bool HasIterator=tc::range_with_iterators< Rng > >
-		struct take_while_adaptor;
-	}
-	using no_adl::take_while_adaptor;
-
-	namespace no_adl {
-		struct identity;
-	}
-	using no_adl::identity;
-
-	namespace no_adl {
-		template< typename Rng>
-		struct make_subrange_result;
-	}
-	template<typename Rng>
-	using make_subrange_result_t = typename no_adl::make_subrange_result<Rng>::type;
-
-	namespace reverse_adaptor_adl {
-		template<typename Rng, bool HasIterators = tc::range_with_iterators<Rng>>
-		struct reverse_adaptor;
-	}
-	using reverse_adaptor_adl::reverse_adaptor;
-
-	template<typename Rng>
-	constexpr reverse_adaptor<Rng> reverse(Rng&& rng) noexcept;
-
-	namespace no_adl {
-		template<typename Rng>
-		struct constexpr_size_impl;
-	}
-
-	namespace empty_range_adl {
-		struct empty_range;
-	}
-	using empty_range_adl::empty_range;
-}
diff --git a/tc/range/range_return.h b/tc/range/range_return.h
new file mode 100644
index 0000000..c189b4a
--- /dev/null
+++ b/tc/range/range_return.h
@@ -0,0 +1,640 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "subrange.h"
+
+namespace tc {
+	namespace return_detail {
+		template<typename Rng>
+		constexpr decltype(auto) empty_slice(Rng&& rng) noexcept {
+			auto it = tc::begin(rng);
+			auto it2 = it;
+			return tc::slice(std::forward<Rng>(rng), tc_move(it), tc_move(it2));
+		}
+
+		namespace no_adl {
+			// Pack border as subrange
+
+			struct return_take_base {
+				template<typename It, typename Rng>
+				static constexpr auto pack_border(It&& it, Rng&& rng) return_decltype_xvalue_by_ref_noexcept(
+					tc::take(std::forward<Rng>(rng), std::forward<It>(it))
+				)
+			};
+
+			struct return_drop_base {
+				template<typename It, typename Rng>
+				static constexpr auto pack_border(It&& it, Rng&& rng) return_decltype_xvalue_by_ref_noexcept(
+					tc::drop(tc_move_if_owned(rng), tc_move_if_owned(it))
+				)
+			};
+
+			template<typename ReturnSubrange>
+			struct return_subrange_or_assert final : ReturnSubrange {
+				static constexpr bool allowed_if_always_has_border = true;
+
+				template<typename... Args>
+				static decltype(auto) pack_no_border(Args&&... args) noexcept {
+					_ASSERTFALSE;
+					return ReturnSubrange::pack_no_border(std::forward<Args>(args)...);
+				}
+			};
+
+			template<typename ReturnSubrange>
+			struct return_subrange_or_none final {
+				static constexpr bool allowed_if_always_has_border = false;
+
+				template<typename It, typename Rng>
+				static constexpr auto pack_border(It&& it, Rng&& rng) noexcept {
+					return std::optional(ReturnSubrange::pack_border(std::forward<It>(it), std::forward<Rng>(rng)));
+				}
+
+				template<typename Rng, typename... OptEndIt>
+				static constexpr decltype(std::optional(ReturnSubrange::pack_border(tc::begin(std::declval<Rng&>()), std::declval<Rng>()))) pack_no_border(Rng&&, OptEndIt&&...) noexcept {
+					return std::nullopt;
+				}
+			};
+
+			template<typename ReturnSubrange>
+			struct return_subrange_or_all final : ReturnSubrange {
+				static constexpr bool allowed_if_always_has_border = false;
+
+				template<typename Rng, typename... OptEndIt>
+				static constexpr decltype(ReturnSubrange::pack_border(tc::begin(std::declval<Rng&>()), std::declval<Rng>())) pack_no_border(Rng&& rng, OptEndIt&&...) noexcept {
+					return std::forward<Rng>(rng);
+				}
+			};
+
+			// Pack element as border before/after
+
+			template<typename ReturnBorder, bool bSupportsNoElement>
+			struct pack_as_border_base {
+				static_assert( !ReturnBorder::allowed_if_always_has_border, "Specify what to return in the no_element case. Use bSupportsNoElement=false to _ASSERT it does not occur." );
+				static constexpr bool requires_iterator = true;
+
+				template<typename Rng>
+				static constexpr auto pack_no_element(Rng&& rng) noexcept code_return_decltype_xvalue_by_ref(
+					if constexpr( !bSupportsNoElement ) _ASSERTFALSE;,
+					ReturnBorder::pack_no_border(std::forward<Rng>(rng))
+				)
+			};
+
+			template<typename ReturnBorder, bool bSupportsNoElement = true>
+			struct pack_as_border_before : pack_as_border_base<ReturnBorder, bSupportsNoElement> {
+				template<typename It, typename Rng>
+				static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) return_decltype_xvalue_by_ref_noexcept(
+					ReturnBorder::pack_border(std::forward<It>(it), std::forward<Rng>(rng))
+				)
+				template<typename Rng, typename Begin, typename End>
+				static constexpr auto pack_view(Rng&& rng, Begin&& begin, End&& end) return_decltype_xvalue_by_ref_noexcept(
+					ReturnBorder::pack_border(std::forward<Begin>(begin), std::forward<Rng>(rng))
+				)
+			};
+
+			template<typename ReturnBorder, bool bSupportsNoElement = true>
+			struct pack_as_border_after : pack_as_border_base<ReturnBorder, bSupportsNoElement> {
+				template<typename It, typename Rng>
+				static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) return_decltype_xvalue_by_ref_MAYTHROW(
+					++it, // MAYTHROW
+					ReturnBorder::pack_border(std::forward<It>(it), std::forward<Rng>(rng))
+				)
+				template<typename Rng, typename Begin, typename End>
+				static constexpr auto pack_view(Rng&& rng, Begin&&, End&& end) return_decltype_xvalue_by_ref_noexcept(
+					ReturnBorder::pack_border(std::forward<End>(end), std::forward<Rng>(rng))
+				)
+			};
+
+			// Pack border as element before/after
+
+			template<typename ReturnElement>
+			struct pack_as_element_base {
+				static constexpr bool allowed_if_always_has_border = true; // element before/after may not exist, even if we have a border.
+				static_assert( ReturnElement::requires_iterator );
+
+				template<typename Rng, typename... OptEndIt>
+				static constexpr auto pack_no_border(Rng&& rng, OptEndIt&&...) return_decltype_noexcept(
+					ReturnElement::pack_no_element(std::forward<Rng>(rng))
+				)
+			};
+
+			template<typename ReturnElement>
+			struct pack_as_element_before final : pack_as_element_base<ReturnElement> {
+				template<typename It, typename Rng>
+				static constexpr decltype(auto) pack_border(It&& it, Rng&& rng) noexcept(noexcept(--it)) {
+					if( tc::begin(rng) != it ) {
+						--it;
+						return ReturnElement::pack_element(std::forward<It>(it), std::forward<Rng>(rng));
+					} else {
+						return ReturnElement::pack_no_element(std::forward<Rng>(rng));
+					}
+				}
+			};
+
+			template<typename ReturnElement>
+			struct pack_as_element_after final : pack_as_element_base<ReturnElement> {
+				template<typename It, typename Rng>
+				static constexpr decltype(auto) pack_border(It&& it, Rng&& rng) noexcept {
+					if( tc::end(rng) != it ) {
+						return ReturnElement::pack_element(std::forward<It>(it), std::forward<Rng>(rng));
+					} else {
+						return ReturnElement::pack_no_element(std::forward<Rng>(rng));
+					}
+				}
+			};
+		}
+	}
+
+	namespace no_adl {
+		/////////////////////////////////////
+		// return void
+
+		struct return_void final {
+			static constexpr bool requires_iterator = false;
+			static constexpr bool allowed_if_always_has_border = true;
+
+			static constexpr void pack_border(tc::unused /*it*/, tc::unused /*rng*/) noexcept {}
+			static constexpr void pack_no_border(tc::unused /*rng*/) noexcept {}
+			static constexpr void pack_no_border(tc::unused /*rng*/, tc::unused /*itEnd*/) noexcept {}
+			static constexpr void pack_element(tc::unused /*it*/, tc::unused /*rng*/) noexcept {}
+			static constexpr void pack_element(tc::unused /*it*/, tc::unused /*rng*/, tc::unused /*ref*/) noexcept {}
+			template<typename Rng>
+			static constexpr void pack_element(tc::unused /*ref*/) noexcept {}
+			static constexpr void pack_no_element(tc::unused) noexcept {}
+			template<typename Rng>
+			static constexpr void pack_no_element() noexcept {}
+			static constexpr void pack_view(tc::unused /*rng*/, tc::unused /*itBegin*/, tc::unused /*itEnd*/) noexcept {}
+		};
+
+		/////////////////////////////////////
+		// return bool
+
+		struct return_bool {
+			static constexpr bool requires_iterator = false;
+			static constexpr bool allowed_if_always_has_border = false;
+
+			static constexpr bool pack_border(tc::unused /*it*/, tc::unused /*rng*/) noexcept {
+				return true;
+			}
+			static constexpr bool pack_no_border(tc::unused /*rng*/) noexcept {
+				return false;
+			}
+			static constexpr bool pack_no_border(tc::unused /*rng*/, tc::unused /*itEnd*/) noexcept {
+				return false;
+			}
+
+			static constexpr bool pack_element(tc::unused /*it*/, tc::unused /*rng*/) noexcept {
+				return true;
+			}
+			static constexpr bool pack_element(tc::unused /*it*/, tc::unused /*rng*/, tc::unused /*ref*/) noexcept {
+				return true;
+			}
+			template<typename Rng>
+			static constexpr bool pack_element(tc::unused /*ref*/) noexcept {
+				return true;
+			}
+			static constexpr bool pack_no_element(tc::unused) noexcept {
+				return false;
+			}
+			template<typename Rng>
+			static constexpr bool pack_no_element() noexcept {
+				return false;
+			}
+
+			static constexpr bool pack_view(tc::unused /*rng*/, tc::unused /*itBegin*/, tc::unused /*itEnd*/) noexcept {
+				return true;
+			}
+		};
+
+		/////////////////////////////////////
+		// controlling bound return
+
+		// returning bound
+
+		struct return_border {
+			static constexpr bool allowed_if_always_has_border = true;
+
+			template<typename It>
+			static constexpr tc::decay_t<It> pack_border(It&& it, tc::unused /*rng*/) noexcept {
+				return std::forward<It>(it);
+			}
+
+			template<typename Rng, typename... OptEndIt>
+			static auto pack_no_border(Rng&& rng, OptEndIt&&...) noexcept {
+				_ASSERTFALSE;
+				return tc::begin(rng);
+			}
+		};
+
+		struct return_border_or_begin final : return_border {
+			static constexpr bool allowed_if_always_has_border = false;
+
+			template<typename Rng, typename... OptEndIt>
+			static constexpr auto pack_no_border(Rng&& rng, OptEndIt&&...) noexcept {
+				return tc::begin(rng);
+			}
+		};
+
+		struct return_border_or_end final : return_border {
+			static constexpr bool allowed_if_always_has_border = false;
+
+			template<typename Rng>
+			static constexpr auto pack_no_border(Rng&& rng) noexcept {
+				return tc::end(rng);
+			}
+
+			template<typename Rng>
+			static constexpr auto pack_no_border(Rng&& rng, tc::iterator_t<Rng>&& itEnd) noexcept {
+				return tc_move(itEnd);
+			}
+		};
+
+		struct return_border_or_null final {
+			static constexpr bool allowed_if_always_has_border = false;
+
+			template<typename It, typename Rng>
+			static constexpr auto pack_border(It&& it, Rng&&) noexcept {
+				return tc::border_t<tc::decay_t<It>>(std::forward<It>(it));
+			}
+
+			template<typename Rng, typename... OptEndIt>
+			static constexpr auto pack_no_border(Rng&&, OptEndIt&&...) noexcept {
+				return tc::border_t<tc::decay_t<decltype(tc::begin(std::declval<Rng&>()))>>{};
+			}
+		};
+
+		struct return_border_index final {
+			static constexpr bool allowed_if_always_has_border = true;
+
+			template<typename It, typename Rng>
+			static constexpr auto pack_border(It&& it, Rng&& rng) noexcept {
+				return tc::make_size_proxy(it - tc::begin(rng));
+			}
+
+			template<typename Rng, typename... OptEndIt>
+			static auto pack_no_border(Rng&&, OptEndIt&&...) noexcept {
+				_ASSERTFALSE;
+				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
+			}
+		};
+
+		// returning range
+
+		struct return_take_or_empty : return_detail::no_adl::return_take_base {
+			static constexpr bool allowed_if_always_has_border = false;
+
+			template<typename Rng, typename... OptEndIt>
+			static constexpr auto pack_no_border(Rng&& rng, OptEndIt&&...) return_decltype_xvalue_by_ref_MAYTHROW(
+				tc::take(std::forward<Rng>(rng), tc::begin(rng))
+			)
+		};
+
+		struct return_drop_or_empty : return_detail::no_adl::return_drop_base {
+			static constexpr bool allowed_if_always_has_border = false;
+
+			template<typename Rng>
+			static constexpr auto pack_no_border(Rng&& rng) return_decltype_xvalue_by_ref_MAYTHROW(
+				tc::drop(tc_move_if_owned(rng), tc::end(rng))
+			)
+
+			template<typename Rng>
+			static constexpr auto pack_no_border(Rng&& rng, tc::iterator_t<Rng>&& itEnd) return_decltype_xvalue_by_ref_MAYTHROW(
+				tc::drop(tc_move_if_owned(rng), tc_move(itEnd))
+			)
+		};
+
+		/////////////////////////////////////
+		// controlling element return
+
+		// returning element
+
+		struct return_element {
+			static constexpr bool requires_iterator = true;
+
+			template<typename It>
+			static constexpr tc::decay_t<It> pack_element(It&& it, tc::unused /*rng*/, tc::unused /*ref*/={}) noexcept {
+				return std::forward<It>(it);
+			}
+
+			template<typename Rng>
+			static auto pack_no_element(Rng&& rng) noexcept {
+				_ASSERTFALSE;
+				return tc::begin(rng);
+			}
+		};
+
+		struct return_element_or_null final {
+			static constexpr bool requires_iterator = true;
+
+			template<typename It>
+			static constexpr auto pack_element(It&& it, tc::unused /*rng*/, tc::unused /*ref*/={}) noexcept {
+				return tc::make_element(std::forward<It>(it));
+			}
+
+			template<typename Rng>
+			static constexpr auto pack_no_element(Rng&&) noexcept {
+				return tc::element_t<tc::decay_t<decltype(tc::begin(std::declval<Rng&>()))>>{}; // value initialization to initialize pointers to nullptr
+			}
+		};
+
+		struct return_element_or_front final : return_element {
+			template<typename Rng>
+			static constexpr auto pack_no_element(Rng&& rng) noexcept {
+				return tc::begin(rng);
+			}
+		};
+
+		struct return_element_or_back final : return_element {
+			template<typename Rng>
+			static constexpr auto pack_no_element(Rng&& rng) noexcept {
+				return tc::end_prev<tc::return_border>(std::forward<Rng>(rng));
+			}
+		};
+
+		struct return_value {
+			static constexpr bool requires_iterator = false;
+
+			// Don't take it by value, or ref may be invalidated
+			template<typename Rng, typename Ref>
+			static constexpr tc::range_value_t<Rng> pack_element(tc::unused /*it*/, Rng&&, Ref&& ref) noexcept {
+				return std::forward<Ref>(ref);
+			}
+			template<typename It, typename Rng>
+			static constexpr tc::range_value_t<Rng> pack_element(It&& it, Rng&&) noexcept {
+				return *std::forward<It>(it);
+			}
+			template<typename Rng, typename Ref>
+			static constexpr tc::range_value_t<Rng> pack_element(Ref&& ref) noexcept {
+				return std::forward<Ref>(ref);
+			}
+			template<typename Rng>
+			static auto pack_no_element(Rng&&) noexcept {
+				_ASSERTFALSE;
+				return tc::construct_default_or_terminate<tc::range_value_t<Rng>>();
+			}
+			template<typename Rng>
+			static auto pack_no_element() noexcept {
+				_ASSERTFALSE;
+				return tc::construct_default_or_terminate<tc::range_value_t<Rng>>();
+			}
+		};
+
+		struct return_value_or_default final : return_value {
+			template<typename Rng>
+			static constexpr tc::range_value_t<Rng> pack_no_element(Rng&&) noexcept {
+				return {};
+			}
+			template<typename Rng>
+			static constexpr tc::range_value_t<Rng> pack_no_element() noexcept {
+				return {};
+			}
+		};
+
+		struct return_value_or_none final {
+			static constexpr bool requires_iterator = false;
+
+			// Don't take it by value, or ref may be invalidated
+			template<typename Rng, typename Ref>
+			static constexpr std::optional<tc::range_value_t<Rng>> pack_element(tc::unused /*it*/, Rng&&, Ref&& ref) noexcept {
+				return std::forward<Ref>(ref);
+			}
+			template<typename It, typename Rng>
+			static constexpr std::optional<tc::range_value_t<Rng>> pack_element(It&& it, Rng&&) noexcept {
+				return *std::forward<It>(it);
+			}
+			template<typename Rng, typename Ref>
+			static constexpr std::optional<tc::range_value_t<Rng>> pack_element(Ref&& ref) noexcept {
+				return std::forward<Ref>(ref);
+			}
+			template<typename Rng>
+			static constexpr std::optional<tc::range_value_t<Rng>> pack_no_element(Rng&&) noexcept {
+				return std::nullopt;
+			}
+			template<typename Rng>
+			static constexpr std::optional<tc::range_value_t<Rng>> pack_no_element() noexcept {
+				return std::nullopt;
+			}
+		};
+
+		struct return_element_index {
+			static constexpr bool requires_iterator = true;
+
+			template<typename It, typename Rng>
+			static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) noexcept {
+				return tc::make_size_proxy(it - tc::begin(rng));
+			}
+
+			template<typename Rng>
+			static auto pack_no_element(Rng&&) noexcept {
+				_ASSERTFALSE;
+				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
+			}
+		};
+
+		struct return_element_index_or_none final {
+			static constexpr bool requires_iterator = true;
+
+			template<typename It, typename Rng>
+			static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) noexcept {
+				return std::optional(tc::make_size_proxy(it - tc::begin(rng)));
+			}
+
+			template<typename Rng>
+			static constexpr decltype(std::optional(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))) pack_no_element(Rng&&) noexcept {
+				return std::nullopt;
+			}
+		};
+
+		struct return_element_index_or_npos final : return_element_index {
+			// Note: prefer return_element_index_or_none
+			// static_cast<int>(npos) must be -1. Anything else is error-prone. So use range_difference instead of range_size.
+			// Alternatively, we could return a special type that casts npos to -1.
+			static constexpr bool requires_iterator = true;
+
+			template<typename Rng>
+			static constexpr auto pack_no_element(Rng&&) noexcept {
+				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(-1);
+			}
+		};
+
+		struct return_element_index_or_size final : return_element_index {
+			template<typename Rng>
+			static constexpr auto pack_no_element(Rng&& rng) noexcept {
+				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(tc::size(rng));
+			}
+		};
+
+		struct return_singleton_range {
+			static constexpr bool requires_iterator = true;
+
+			template<typename It, typename Rng>
+			static constexpr decltype(auto) pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) noexcept(noexcept(++tc::as_lvalue(tc::decay_copy(it)))) {
+				return tc::slice(std::forward<Rng>(rng), it, tc_modified(it, ++_));
+			}
+			template<typename Rng>
+			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
+				// safe choice is empty because result may be empty
+				_ASSERTFALSE;
+				return tc::return_detail::empty_slice(std::forward<Rng>(rng));
+			}
+		};
+
+		struct return_singleton_range_or_empty final : return_singleton_range {
+			template<typename Rng>
+			static constexpr auto pack_no_element(Rng&& rng) return_decltype_noexcept(
+				tc::return_detail::empty_slice(std::forward<Rng>(rng))
+			)
+		};
+
+		/////////////////////////////////////
+		// controlling view return
+
+		struct return_view {
+			template<typename Rng, typename Begin, typename End>
+			static constexpr auto pack_view(Rng&& rng, Begin&& begin, End&& end) return_decltype_noexcept(
+				tc::slice(std::forward<Rng>(rng), std::forward<Begin>(begin), std::forward<End>(end))
+			)
+
+			template<typename Rng>
+			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
+				_ASSERTFALSE;
+				return tc::slice(std::forward<Rng>(rng), tc::begin(rng), tc::end(rng));
+			}
+		};
+
+		struct return_view_or_none final {
+			template<typename Rng, typename Begin, typename End>
+			static constexpr auto pack_view(Rng&& rng, Begin&& begin, End&& end) noexcept {
+				return std::optional(return_view::pack_view(std::forward<Rng>(rng), std::forward<Begin>(begin), std::forward<End>(end)));
+			}
+
+			template<typename Rng>
+			static decltype(std::optional(return_view::pack_no_element(std::declval<Rng>()))) pack_no_element(Rng&&) noexcept {
+				return std::nullopt;
+			}
+		};
+
+		struct return_view_or_empty final : return_view {
+			template<typename Rng>
+			static constexpr auto pack_no_element(Rng&& rng) return_decltype_noexcept(
+				tc::return_detail::empty_slice(std::forward<Rng>(rng))
+			)
+		};
+
+		struct return_begin_index final {
+			template<typename Rng, typename Begin, typename End>
+			static constexpr decltype(auto) pack_view(Rng&& rng, Begin&& begin, End&& end) noexcept {
+				return tc::make_size_proxy(begin - tc::begin(rng));
+			}
+
+			template<typename Rng>
+			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
+				_ASSERTFALSE;
+				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
+			}
+		};
+
+		struct return_end_index final {
+			template<typename Rng, typename Begin, typename End>
+			static constexpr decltype(auto) pack_view(Rng&& rng, Begin&& begin, End&& end) noexcept {
+				return tc::make_size_proxy(end - tc::begin(rng));
+			}
+
+			template<typename Rng>
+			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
+				_ASSERTFALSE;
+				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
+			}
+		};
+	} // namespace no_adl
+	using no_adl::return_void;
+	using no_adl::return_bool;
+
+	// return border
+	using no_adl::return_border;
+	using no_adl::return_border_or_begin;
+	using no_adl::return_border_or_end;
+	using no_adl::return_border_or_null;
+	using no_adl::return_border_index;
+
+	using no_adl::return_take_or_empty;
+	using return_take = return_detail::no_adl::return_subrange_or_assert<tc::return_take_or_empty>;
+	using return_take_or_none = return_detail::no_adl::return_subrange_or_none<return_detail::no_adl::return_take_base>;
+	using return_take_or_all = return_detail::no_adl::return_subrange_or_all<return_detail::no_adl::return_take_base>;
+
+	using no_adl::return_drop_or_empty;
+	using return_drop = return_detail::no_adl::return_subrange_or_assert<tc::return_drop_or_empty>;
+	using return_drop_or_none = return_detail::no_adl::return_subrange_or_none<return_detail::no_adl::return_drop_base>;
+	using return_drop_or_all = return_detail::no_adl::return_subrange_or_all<return_detail::no_adl::return_drop_base>;
+
+	// return element
+	using no_adl::return_element;
+	using no_adl::return_element_or_null;
+	using no_adl::return_element_or_front;
+	using no_adl::return_element_or_back;
+	using no_adl::return_value;
+	using no_adl::return_value_or_default;
+	using no_adl::return_value_or_none;
+	using no_adl::return_element_index;
+	using no_adl::return_element_index_or_none;
+	using no_adl::return_element_index_or_npos;
+	using no_adl::return_element_index_or_size;
+	using no_adl::return_singleton_range;
+	using no_adl::return_singleton_range_or_empty;
+
+	template< tc::actual_integer T >
+	[[nodiscard]] constexpr bool is_npos(T t) noexcept {
+		if constexpr( std::is_signed<T>::value ) {
+			return -1 == t;
+		} else {
+			return std::numeric_limits<T>::max() == t;
+		}
+	}
+
+	// return border element
+	using return_element_before = return_detail::no_adl::pack_as_element_before<tc::return_element>;
+	using return_element_before_or_null = return_detail::no_adl::pack_as_element_before<tc::return_element_or_null>;
+	using return_element_before_or_front = return_detail::no_adl::pack_as_element_before<tc::return_element_or_front>;
+	using return_element_after = return_detail::no_adl::pack_as_element_after<tc::return_element>;
+	using return_element_after_or_null = return_detail::no_adl::pack_as_element_after<tc::return_element_or_null>;
+	using return_element_after_or_back = return_detail::no_adl::pack_as_element_after<tc::return_element_or_back>;
+
+	// return element border
+	using return_border_after = return_detail::no_adl::pack_as_border_after<tc::return_border_or_end, false>;
+	using return_border_after_or_begin = return_detail::no_adl::pack_as_border_after<tc::return_border_or_begin>;
+	using return_border_after_or_end = return_detail::no_adl::pack_as_border_after<tc::return_border_or_end>;
+	using return_border_before = return_detail::no_adl::pack_as_border_before<tc::return_border_or_begin, false>;
+	using return_border_before_or_begin = return_detail::no_adl::pack_as_border_before<tc::return_border_or_begin>;
+	using return_border_before_or_end = return_detail::no_adl::pack_as_border_before<tc::return_border_or_end>;
+
+	using return_take_before = return_detail::no_adl::pack_as_border_before<tc::return_take_or_empty, false>; // safe choice is empty because result may be empty
+	using return_take_before_or_empty = return_detail::no_adl::pack_as_border_before<tc::return_take_or_empty>;
+	using return_take_before_or_all = return_detail::no_adl::pack_as_border_before<tc::return_take_or_all>;
+	using return_take_before_or_none = return_detail::no_adl::pack_as_border_before<tc::return_take_or_none>;
+	using return_take_after = return_detail::no_adl::pack_as_border_after<tc::return_take_or_all, false>; // safe choice is all because result is never empty
+	using return_take_after_or_empty = return_detail::no_adl::pack_as_border_after<tc::return_take_or_empty>;
+	using return_take_after_or_all = return_detail::no_adl::pack_as_border_after<tc::return_take_or_all>;
+	using return_take_after_or_none = return_detail::no_adl::pack_as_border_after<tc::return_take_or_none>;
+
+	using return_drop_before = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_all, false>; // safe choice is all because result is never empty
+	using return_drop_before_or_empty = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_empty>;
+	using return_drop_before_or_all = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_all>;
+	using return_drop_before_or_none = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_none>;
+	using return_drop_after = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_empty, false>; // safe choice is empty because result may be empty
+	using return_drop_after_or_empty = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_empty>;
+	using return_drop_after_or_all = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_all>;
+	using return_drop_after_or_none = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_none>;
+
+	// return view
+	using no_adl::return_view;
+	using no_adl::return_view_or_none;
+	using no_adl::return_view_or_empty;
+	using no_adl::return_begin_index;
+	using no_adl::return_end_index;
+}
diff --git a/tc/range/repeat_n.h b/tc/range/repeat_n.h
index e6d7a79..ef0c025 100644
--- a/tc/range/repeat_n.h
+++ b/tc/range/repeat_n.h
@@ -69,6 +69,10 @@ namespace tc {
 			}
 		};
 	}
+	using no_adl::repeat_range;
+
+	template<typename T>
+	constexpr auto enable_stable_index_on_move<repeat_range<T>> = true;
 
 	template<typename TSize, typename T>
 	constexpr auto repeat_n( TSize&& ct, T && t ) return_ctor_noexcept(
diff --git a/tc/range/reverse_adaptor.h b/tc/range/reverse_adaptor.h
index d18fa02..3eed489 100644
--- a/tc/range/reverse_adaptor.h
+++ b/tc/range/reverse_adaptor.h
@@ -11,7 +11,6 @@
 #include "../base/assert_defs.h"
 #include "../base/modified.h"
 #include "../algorithm/size.h"
-#include "range_fwd.h"
 #include "range_adaptor.h"
 #include "meta.h"
 #include "subrange.h"
@@ -37,6 +36,9 @@ namespace tc {
 	}
 
 	namespace reverse_adaptor_adl {
+		template<typename Rng, bool HasIterators = tc::range_with_iterators<Rng>>
+		struct reverse_adaptor;
+
 		template<typename Rng>
 		struct [[nodiscard]] reverse_adaptor<Rng, false> : tc::range_adaptor_base_range<Rng>, tc::range_output_from_base_range {
 			using tc::range_adaptor_base_range<Rng>::range_adaptor_base_range;
@@ -74,6 +76,10 @@ namespace tc {
 			using reverse_adaptor<Rng, false>::reverse_adaptor;
 			static constexpr bool c_bHasStashingIndex=tc::has_stashing_index<std::remove_reference_t<Rng>>::value;
 
+			constexpr auto size() const& MAYTHROW requires tc::has_size<Rng> {
+				return tc::compute_range_adaptor_size<tc::identity{}>(this->base_range());
+			}
+
 		private:
 			STATIC_FINAL(begin_index)() const& noexcept -> tc_index {
 				auto idx = this->base_end_index();
@@ -159,7 +165,7 @@ namespace tc {
 				return *idx;
 			}
 		private:
-			STATIC_FINAL(middle_point)(tc_index & idx, tc_index const& idxEnd ) const& noexcept -> void {
+			STATIC_FINAL(middle_point)(tc_index & idx, tc_index const& idxEnd ) const& noexcept -> void requires tc::has_middle_point<Rng> {
 				auto idxBeginBase = border_base_index(idxEnd);
 				tc::middle_point(this->base_range(), idxBeginBase, border_base_index(idx));
 				idx = idxBeginBase;
@@ -176,18 +182,24 @@ namespace tc {
 			}
 		};
 	}
-
-	template<typename Rng>
-	struct no_adl::constexpr_size_impl<tc::reverse_adaptor<Rng>> : tc::constexpr_size<Rng> {};
+	using reverse_adaptor_adl::reverse_adaptor;
 
 	template<typename Rng>
 	constexpr auto reverse(Rng&& rng) return_ctor_noexcept(
-		reverse_adaptor< Rng >,
+		tc::reverse_adaptor< Rng >,
 		(aggregate_tag, std::forward<Rng>(rng))
 	)
 	
-	namespace no_adl {
-		template<typename Rng>
-		struct is_index_valid_for_move_constructed_range<tc::reverse_adaptor<Rng, true>> : tc::is_index_valid_for_move_constructed_range<Rng> {};
+	template<typename Rng>
+	constexpr auto enable_stable_index_on_move<tc::reverse_adaptor<Rng, true>> = tc::stable_index_on_move<Rng>;
+
+	namespace generator_range_adl {
+		template<typename Self, typename Sink, typename std::remove_reference_t<Self>::is_generator_range_adaptor* = nullptr>
+		constexpr auto for_each_reverse_impl(Self&& self, Sink&& sink) return_decltype_MAYTHROW(
+			tc::for_each(
+				tc::reverse(std::forward<Self>(self).base_range()),
+				std::forward<Self>(self).adapted_sink(std::forward<Sink>(sink), /*bReverse*/tc::constant<true>())
+			)
+		)
 	}
 }
diff --git a/tc/range/reverse_adaptor.t.cpp b/tc/range/reverse_adaptor.t.cpp
index e09dd3e..01ed61c 100644
--- a/tc/range/reverse_adaptor.t.cpp
+++ b/tc/range/reverse_adaptor.t.cpp
@@ -11,11 +11,13 @@
 #include "../algorithm/algorithm.h"
 #include "reverse_adaptor.h"
 
+#include <list>
+
 UNITTESTDEF(tc_reverse_random_access) {
-	TEST_RANGE_EQUAL(as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)), tc::reverse(as_constexpr(tc::make_array(tc::aggregate_tag, 3,2,1))));
+	TEST_RANGE_EQUAL(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)), tc::reverse(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 3,2,1))));
 
 	// test iterators:
-	auto rng = as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3));
+	auto rng = tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3));
 	auto revrng = tc::reverse(rng);
 	auto it = tc::begin(revrng);
 	_ASSERTEQUAL(*it++, 3);
@@ -64,7 +66,7 @@ UNITTESTDEF(tc_reverse_bidirectional) {
 	_ASSERTEQUAL(*it++, 1);
 	_ASSERTEQUAL(tc::end(rngrev), it);
 
-	TEST_RANGE_EQUAL(tc::reverse(rng), as_constexpr(tc::make_array(tc::aggregate_tag, 3,2,1)));
+	TEST_RANGE_EQUAL(tc::reverse(rng), tc_as_constexpr(tc::make_array(tc::aggregate_tag, 3,2,1)));
 	TEST_RANGE_EQUAL(tc::reverse(tc::reverse(rng)), rng);
 }
 
@@ -82,7 +84,7 @@ UNITTESTDEF(tc_reverse_base_bound) {
 
 UNITTESTDEF(tc_reverse_drop_first_last_inplace) {
 	tc::vector<int> vecn{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-	auto&& rngnReverse = tc::reverse(tc::make_view(vecn));
+	auto&& rngnReverse = tc::reverse(tc::all(vecn));
 
 	tc::drop_first_inplace(rngnReverse, 0);
 	TEST_RANGE_EQUAL(rngnReverse, (tc::vector<int>{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}));
diff --git a/tc/range/sparse_adaptor.h b/tc/range/sparse_adaptor.h
index 8415e9c..a21cb53 100644
--- a/tc/range/sparse_adaptor.h
+++ b/tc/range/sparse_adaptor.h
@@ -10,7 +10,6 @@
 
 #include "../base/assert_defs.h"
 #include "../algorithm/compare.h"
-#include "range_fwd.h"
 #include "range_adaptor.h"
 #include "meta.h"
 #include "repeat_n.h"
@@ -48,7 +47,7 @@ namespace tc {
 			template<typename Func>
 			auto operator()(Func func) const& MAYTHROW {
 				std::size_t n=0;
-				auto GenerateDefaultUpTo = [&](std::size_t nEnd) MAYTHROW {
+				auto const GenerateDefaultUpTo = [&](std::size_t const nEnd) MAYTHROW {
 					_ASSERT( n <= nEnd );
 					auto bc=tc::for_each(tc::repeat_n(nEnd - n, *m_default), func); // MAYTHROW
 					n = nEnd;
diff --git a/tc/range/sparse_adaptor.t.cpp b/tc/range/sparse_adaptor.t.cpp
index 2598a26..423fc6a 100644
--- a/tc/range/sparse_adaptor.t.cpp
+++ b/tc/range/sparse_adaptor.t.cpp
@@ -16,5 +16,5 @@ UNITTESTDEF(sparse_range) {
 	auto const rngb = tc::sparse_range(tc::make_array(tc::aggregate_tag, std::make_pair(0u, true), std::make_pair(3u, true)), 6, false);
 	_ASSERT(tc::equal(rngb, abVals));
 	int iVal = 0;
-	tc::for_each(rngb, [&](bool b) noexcept { _ASSERTEQUAL(b, abVals[iVal++]); });
+	tc::for_each(rngb, [&](bool const b) noexcept { _ASSERTEQUAL(b, abVals[iVal++]); });
 }
diff --git a/tc/range/subrange.h b/tc/range/subrange.h
index f2d1517..7106352 100644
--- a/tc/range/subrange.h
+++ b/tc/range/subrange.h
@@ -16,40 +16,102 @@
 #include "../container/container_traits.h"
 #include "../algorithm/size.h"
 #include "../algorithm/size_linear.h"
+#include "../algorithm/size_bounded.h"
 #include "../base/assign.h"
 #include "../base/rvalue_property.h"
 #include "../optional.h"
 #include "../storage_for.h"
 #include "../base/scope.h"
 
-#include "range_fwd.h"
-#include "range_adaptor.h"
-
-#include "meta.h"
 #include "empty_range.h"
+#include "index_range.h"
+#include "meta.h"
+#include "range_adaptor.h"
 
 #include <type_traits>
 #include <memory>
 #include <deque>
 
 namespace tc {
+	namespace return_detail::no_adl {
+		template<typename ReturnSubrange>
+		struct return_subrange_or_assert;
+	}
+	namespace no_adl {
+		struct return_border;
+		struct return_take_or_empty;
+		struct return_drop_or_empty;
+	}
+	using no_adl::return_border;
+	using return_take = return_detail::no_adl::return_subrange_or_assert<no_adl::return_take_or_empty>;
+	using return_drop = return_detail::no_adl::return_subrange_or_assert<no_adl::return_drop_or_empty>;
+
+	namespace no_adl {
+		template < typename It >
+		struct universal_range;
+		template< typename Rng >
+		struct subrange;
+	}
+	using no_adl::universal_range;
+	using no_adl::subrange;
+
 	//-------------------------------------------------------------------------------------------------------------------------
-	
-	template<tc::contiguous_range Rng>
-	[[nodiscard]] constexpr auto ptr_begin(Rng&& rng) noexcept {
-		return std::to_address(tc::begin(std::forward<Rng>(rng)));
+	// Utility functions.
+#if !defined(_MSC_VER)
+	// On libc++ and libstdc++, std::pointer_trait is broken.
+	// E.g. on libc++, it is misisng a specialization for std::__wrap_iter (aka std::vector::iterator).
+	template <tc::contiguous_range Rng>
+	using ptr_iterator_t = decltype(std::to_address(std::declval<tc::iterator_t<Rng>>()));
+#else
+	// On MSVC, std::to_address isn't SFINAE friendly, so we have to use std::pointer_traits.
+	template <tc::contiguous_range Rng>
+	using ptr_iterator_t = typename std::pointer_traits<tc::iterator_t<Rng>>::element_type*;
+#endif
+
+	template<tc::contiguous_range Rng> requires tc::borrowed_range<Rng>
+	[[nodiscard]] constexpr ptr_iterator_t<Rng> ptr_begin(Rng&& rng) noexcept {
+		return std::to_address(tc::begin(rng));
 	}
 
-	template<tc::contiguous_range Rng>
-	[[nodiscard]] constexpr auto ptr_end(Rng&& rng) noexcept {
+	template<tc::contiguous_range Rng> requires tc::borrowed_range<Rng>
+	[[nodiscard]] constexpr ptr_iterator_t<Rng> ptr_end(Rng&& rng) noexcept {
 		if constexpr (tc::common_range<Rng>) {
-			return std::to_address(tc::end(std::forward<Rng>(rng)));
+			return std::to_address(tc::end(rng));
 		} else {
-			return tc::ptr_begin(std::forward<Rng>(rng)) + tc::size_linear_raw(std::forward<Rng>(rng));
+			return tc::ptr_begin(rng) + tc::size_linear_raw(rng);
 		}
 	}
+
+#ifdef _CHECKS
+	namespace no_adl {
+		template< typename Rng >
+		struct SSinglePassRange : tc::noncopyable {
+			explicit SSinglePassRange(Rng&& rng) noexcept
+			: m_rng(tc_move(rng)) {}
+			template< typename Sink >
+			constexpr auto operator()(Sink&& sink) && MAYTHROW {
+				_ASSERTE( tc::change(m_bFirstPass, false) );
+				return tc::for_each(tc_move(m_rng), std::forward<Sink>(sink));
+			}
+
+			Rng m_rng;
+			bool mutable m_bFirstPass = true;
+		};
+	}
+
+	template< typename Rng >
+	auto assert_single_pass(Rng&& rng) noexcept {
+		return no_adl::SSinglePassRange<Rng>(tc_move(rng)); // Disallow lvalue references.
+	}
+#else
+	template< typename Rng >
+	decltype(auto) assert_single_pass(Rng&& rng) noexcept {
+		return std::forward<Rng>(rng);
+	}
+#endif
 	
 	//-------------------------------------------------------------------------------------------------------------------------
+	// subrange
 
 	namespace subrange_detail {
 		template<typename Rng>
@@ -64,63 +126,146 @@ namespace tc {
 		template<typename Rng>
 		using whole_range_t = tc::remove_rvalue_reference_t<decltype(subrange_detail::whole_range(std::declval<Rng>()))>;
 
+		// It may not be tc::safely_constructible_from because of slicing (e.g. tc::iterator_t<std::vector (const)> on Windows, or tc::element_t)
+		template <typename TTarget, typename TSource> constexpr auto is_index_safely_constructible = std::is_constructible<TTarget, TSource>::value;
+
+		// Unlike tc::safely_constructible_from, we want to prevent pointer slicing here, as we're dealing with arrays, not single values.
+		template<typename TTarget, typename TSource> constexpr auto is_ptr_safely_constructible = false;
+		template<typename T> constexpr auto is_ptr_safely_constructible<T*, T*> = true;
+		template<typename T> constexpr auto is_ptr_safely_constructible<T const*, T*> = true;
+		template<typename T> constexpr auto is_ptr_safely_constructible<T volatile*, T*> = true;
+		template<typename T> constexpr auto is_ptr_safely_constructible<T const volatile*, T*> = true;
+
+		// When forwarding `Rhs` into `Rng`, do we first need to translate existing indices of `Rhs` because they might be invalidated?
+		template <typename Rng, typename Rhs>
+		constexpr auto require_index_translation = true;
+		template <typename Rng, typename Rhs>
+			requires tc::borrowed_range<Rng>
+		constexpr auto require_index_translation<Rng, Rhs> = false; // Forwarding `Rhs` doesn't affect indices at all.
+		template <typename Rng, typename Rhs>
+			requires (!tc::borrowed_range<Rng>) && tc::stable_index_on_move<Rng>
+				&& (!std::is_lvalue_reference<Rhs>::value && !std::is_const<std::remove_reference_t<Rhs>>::value)
+		constexpr auto require_index_translation<Rng, Rhs> = false; // We perform a move but have a stable index.
+
 		namespace no_adl {
-			template<typename Rng, typename Rhs>
-			struct enable_subrange_iterator_base_ctor;
-
-			template<typename It, typename Rhs> requires
-				(!std::is_pointer<It>::value) && // not span
-				(!std::is_same<subrange<iterator_base<It>>, std::remove_cvref_t<Rhs>>::value) && // not copy/move ctor
-				// It may not be tc::safely_constructible_from because of slicing (e.g. std::vector::const_iterator/iterator on Windows, or tc::element_t)
-				std::is_constructible<It, decltype(tc::begin(std::declval<Rhs&>()))>::value &&
-				std::is_constructible<It, decltype(tc::end(std::declval<Rhs&>()))>::value
-			struct enable_subrange_iterator_base_ctor<iterator_base<It>, Rhs> : tc::constant<true> {};
-
-			template<typename Rng, typename Rhs>
-			struct enable_span_ctor;
-
-			template<typename TTarget, typename TSource> struct is_ptr_safely_convertible;
-			template<typename T> struct is_ptr_safely_convertible<T*, T*> : tc::constant<true> {};
-			template<typename T> struct is_ptr_safely_convertible<T const*, T*> : tc::constant<true> {};
-			template<typename T> struct is_ptr_safely_convertible<T volatile*, T*> : tc::constant<true> {};
-			template<typename T> struct is_ptr_safely_convertible<T const volatile*, T*> : tc::constant<true> {};
-
-			template<typename T, typename Rhs> requires
-				(!std::is_same<subrange<iterator_base<T*>>, std::remove_cvref_t<Rhs>>::value) && // not copy/move ctor
-				is_ptr_safely_convertible<T*, decltype(tc::ptr_begin(std::declval<Rhs&>()))>::value &&
-				is_ptr_safely_convertible<T*, decltype(tc::ptr_end(std::declval<Rhs&>()))>::value
-			struct enable_span_ctor<iterator_base<T*>, Rhs> : tc::constant<true> {};
+			template <typename Rng>
+			struct get_index {
+				template <typename Rhs>
+				static constexpr auto begin(Rhs& rng) return_decltype_MAYTHROW(tc::begin_index(rng));
+				template <typename BaseRng, typename Rhs>
+				static constexpr auto begin(BaseRng&& baserng, Rhs&) return_decltype_MAYTHROW(tc::begin_index(baserng));
+
+				template <typename Rhs>
+				static constexpr auto end(Rhs& rng) return_decltype_MAYTHROW(tc::end_index(rng));
+				template <typename BaseRng, typename Rhs>
+				static constexpr auto end(BaseRng&& baserng, Rhs&) return_decltype_MAYTHROW(tc::end_index(baserng));
+			};
+
+			template <typename It>
+			struct get_index<universal_range<It>> {
+				template <typename Rhs>
+				static constexpr auto begin(Rhs& rng) return_decltype_MAYTHROW(tc::begin(rng));
+				template <typename Rhs>
+				static constexpr auto begin(universal_range<It>, Rhs& rng) return_decltype_MAYTHROW(tc::begin(rng));
+
+				template <typename Rhs>
+				static constexpr auto end(Rhs& rng) return_decltype_MAYTHROW(tc::end(rng));
+				template <typename Rhs>
+				static constexpr auto end(universal_range<It>, Rhs& rng) return_decltype_MAYTHROW(tc::end(rng));
+			};
+
+			template <typename T>
+			struct get_index<universal_range<T*>> {
+				template <typename Rhs>
+				static constexpr auto begin(Rhs& rng) return_decltype_MAYTHROW(tc::ptr_begin(rng));
+				template <typename Rhs>
+				static constexpr auto begin(universal_range<T*>, Rhs& rng) return_decltype_MAYTHROW(tc::ptr_begin(rng));
+
+				template <typename Rhs>
+				static constexpr auto end(Rhs& rng) return_decltype_MAYTHROW(tc::ptr_end(rng));
+				template <typename Rhs>
+				static constexpr auto end(universal_range<T*>, Rhs& rng) return_decltype_MAYTHROW(tc::ptr_end(rng));
+			};
 		}
+		using no_adl::get_index;
 	}
 
 	namespace no_adl {
-		//-------------------------------------------------------------------------------------------------------------------------
 		// meta function to determine the correct type
-		// collapse subrange< subrange< ... > > to single subrange
 		template<typename Rng>
-		struct make_subrange_result final {
-			static_assert(!std::is_rvalue_reference<Rng>::value);
-			using type = subrange<subrange_detail::whole_range_t<Rng>>;
+		struct make_subrange_result {
+			using type = subrange<Rng>;
+		};
+
+		// collapse subrange< subrange< ... > > to single subrange
+		template <typename Rng> requires tc::instance<std::remove_reference_t<Rng>, tc::subrange> 
+		struct make_subrange_result<Rng> : make_subrange_result<tc::subrange_detail::whole_range_t<Rng>> {};
+
+		// turn subrange< borrowed_range< ... > > to subrange< universal_range<...> >
+		template <typename Rng> requires
+			(!tc::instance<std::remove_reference_t<Rng>, tc::subrange>) &&
+			(!tc::is_index_iterator<tc::iterator_t<Rng>>) && // storing two index_iterator is worse than storing ptr + two indices
+			tc::borrowed_range<Rng> && tc::common_range<Rng>
+		struct make_subrange_result<Rng> {
+			using type = subrange<universal_range<tc::iterator_t<Rng>>>;
+		};
+	}
+	template <typename Rng>
+	using make_subrange_result_t = typename no_adl::make_subrange_result<Rng>::type;
+
+	namespace no_adl {
+		// The universal range is the superset of all possible ranges build from iterator pairs It.
+		// It is used as Rng type of subrange when the range isn't known.
+		template <typename It>
+		struct universal_range {
+			constexpr universal_range() noexcept = default;
+
+			template <tc::common_range Rhs> requires
+				(!std::is_pointer<It>::value) &&
+				subrange_detail::is_index_safely_constructible<It, tc::iterator_t<Rhs>>
+			constexpr universal_range(Rhs&&) noexcept {}
+
+			template <tc::contiguous_range Rhs> requires
+				std::is_pointer<It>::value &&
+				subrange_detail::is_ptr_safely_constructible<It, tc::ptr_iterator_t<Rhs>>
+			constexpr universal_range(Rhs&&) noexcept {}
+
+			// subrange constructors assume that "universal_range constructible from Rhs" <=> "can call subrange_detail::get_index".
+			// Without deleting construction from non-ranges, this assumption breaks for tc_return_cast.
+			template <typename Rhs> requires (!tc::range_with_iterators<Rhs>)
+			universal_range(Rhs&&) = delete;
+
+			template <typename It_ = It>
+			constexpr It begin() const& noexcept {
+				static_assert(tc::dependent_false<It_>::value, "tc::universal_range::begin() does not exist");
+				return std::declval<It>();
+			}
+			template <typename It_ = It>
+			constexpr It end() const& noexcept {
+				static_assert(tc::dependent_false<It_>::value, "tc::universal_range::end() does not exist");
+				return std::declval<It>();
+			}
 		};
 	}
 
-	namespace subrange_adl {
+	template <typename It>
+	constexpr auto enable_borrowed_range<universal_range<It>> = true;
+
+	namespace no_adl {
 		template< typename Rng >
 		struct subrange
-			: tc::index_range_adaptor<subrange<Rng>, Rng>
+			: tc::index_range_adaptor<subrange<Rng>, Rng, tc::index_range_adaptor_flags::inherit_behavior>
 			// Disable compiler generated special member functions.
 			// Implicit construction from another subrange of the same type may still be possible via the user-defined constructor below.
-			, std::conditional_t<
-				std::is_lvalue_reference<Rng>::value || tc::instance<Rng, tc::iterator_base>,
+			, std::conditional_t<tc::borrowed_range<Rng>,
 				tc::copyable,
-				std::conditional_t<
-					tc::is_index_valid_for_move_constructed_range<Rng>::value,
+				std::conditional_t<tc::stable_index_on_move<Rng>,
 					tc::noncopyable,
 					tc::nonmovable
 				>
 			>
 		{
-			static_assert( !tc::instance<std::remove_reference_t<Rng>, tc::subrange>, "Use tc::make_subrange_result_t to construct subrange type." );
+			static_assert( std::same_as<subrange, tc::make_subrange_result_t<Rng>>, "Use tc::make_subrange_result_t to construct subrange type." );
 
 		private:
 			using this_type = subrange;
@@ -133,136 +278,90 @@ namespace tc {
 			tc_index m_idxBegin;
 			tc_index m_idxEnd;
 
-		public:
-			// default ctor (for deferred initialization)
-			constexpr subrange() = default;
-
-			// ctor from whole range
-			template<typename Rhs> requires
-				(!tc::instance<Rng, tc::iterator_base>) && tc::safely_constructible_from<Rng, Rhs>
-			constexpr subrange(Rhs&& rng) noexcept(
-				std::is_nothrow_constructible<base_, aggregate_tag_t, Rhs>::value &&
-				noexcept(this->base_begin_index()) && std::is_nothrow_constructible<decltype(this->base_begin_index())>::value &&
-				noexcept(this->base_end_index()) && std::is_nothrow_constructible<decltype(this->base_end_index())>::value
-			)
-				: base_(aggregate_tag, std::forward<Rhs>(rng))
-				, m_idxBegin(this->base_begin_index())
-				, m_idxEnd(this->base_end_index())
-			{
-				static_assert( !tc::instance<std::remove_reference_t<Rhs>, tc::subrange> );
-			}
-
-			template<typename Rhs> requires subrange_detail::no_adl::enable_subrange_iterator_base_ctor<Rng, Rhs>::value
-			constexpr subrange(Rhs&& rng) noexcept(
-				noexcept(tc::begin(rng)) && std::is_nothrow_constructible<tc_index, decltype(tc::begin(rng))>::value &&
-				noexcept(tc::end(rng)) && std::is_nothrow_constructible<tc_index, decltype(tc::end(rng))>::value
-			)
-				: m_idxBegin(tc::begin(rng))
-				, m_idxEnd(tc::end(rng))
-			{}
-
-			template<typename Rhs> requires subrange_detail::no_adl::enable_span_ctor<Rng, Rhs>::value
-			constexpr subrange(Rhs&& rng) noexcept
-				: m_idxBegin(tc::ptr_begin(rng))
-				, m_idxEnd(tc::ptr_end(rng))
-			{}
-
 		private:
+			DEFINE_NESTED_TAG_TYPE(integer_tag)
 			DEFINE_NESTED_TAG_TYPE(index_tag)
-			DEFINE_NESTED_TAG_TYPE(slice_tag)
-			DEFINE_NESTED_TAG_TYPE(index_translation_tag)
 
 			// ctor from rng/numeric begin/numeric end
-			template<typename RhsBase, typename N>
-			constexpr subrange(slice_tag_t, RhsBase&& rng, N nFrom, N nTo) noexcept
-				: /*construct from whole base range*/subrange(std::forward<RhsBase>(rng))
+			template<typename Rhs, typename N>
+			constexpr subrange(integer_tag_t, Rhs&& wholerng, N nFrom, N nTo) noexcept
+				: subrange(tc_move_if_owned(wholerng))
 			{
-				static_assert(!tc::instance<RhsBase, tc::subrange>);
-				static_assert(tc::random_access_range<Rng>); // Enables index translation in O(1).
-				this->take_inplace(tc_modified(this->begin_index(), this->advance_index(_, nTo)));
-				this->drop_inplace(tc_modified(this->begin_index(), this->advance_index(_, nFrom)));
+				take_inplace(tc_modified(this->begin_index(), this->advance_index(_, nTo)));
+				drop_inplace(tc_modified(this->begin_index(), this->advance_index(_, nFrom)));
 			}
 
-			// ctor that translates indices
-			template<typename RhsBase, typename IndexBegin, typename IndexEnd>
-			constexpr subrange(index_translation_tag_t, RhsBase&& baserng, IndexBegin&& idxBegin, IndexEnd&& idxEnd) noexcept
-				: subrange(
-					slice_tag,
-					std::forward<RhsBase>(baserng),
-					tc::distance_to_index(baserng, tc::begin_index(baserng), std::forward<IndexBegin>(idxBegin)),
-					tc::distance_to_index(baserng, tc::begin_index(baserng), std::forward<IndexEnd>(idxEnd))
+			// ctor from baserng/begin/end (with translation)
+			template<typename Rhs, typename IndexBegin, typename IndexEnd> requires subrange_detail::require_index_translation<Rng, Rhs>
+			constexpr subrange(index_tag_t, Rhs&& wholerng, IndexBegin&& idxBegin, IndexEnd&& idxEnd) noexcept
+				: subrange(integer_tag,
+					tc_move_if_owned(wholerng),
+					tc::distance_to_index(wholerng, tc::begin_index(wholerng), tc_move_if_owned(idxBegin)),
+					tc::distance_to_index(wholerng, tc::begin_index(wholerng), tc_move_if_owned(idxEnd))
 				)
 			{}
+			// ctor from baserng/begin/end (no index translation)
+			template<typename Rhs, typename IndexBegin, typename IndexEnd> requires (!subrange_detail::require_index_translation<Rng, Rhs>)
+			constexpr subrange(index_tag_t, Rhs&& wholerng, IndexBegin&& idxBegin, IndexEnd&& idxEnd) noexcept
+				: base_(aggregate_tag, tc_move_if_owned(wholerng))
+				, m_idxBegin(tc_move_if_owned(idxBegin))
+				, m_idxEnd(tc_move_if_owned(idxEnd))
+			{}
 
-			// ctor from rng/begin/end (no index translation)
-			template<typename Rhs, typename IndexBegin, typename IndexEnd> requires 
-				std::is_lvalue_reference<Rng>::value || // Implies no copy/move of base range is necessary.
-				(
-					!std::is_lvalue_reference<decltype(subrange_detail::whole_range(std::declval<Rhs>()))>::value && // Implies copy of base range otherwise
-					!std::is_const<std::remove_reference_t<decltype(subrange_detail::whole_range(std::declval<Rhs>()))>>::value && // Implies copy of base range otherwise
-					tc::is_index_valid_for_move_constructed_range<Rng>::value
-				)
-			constexpr subrange(index_tag_t, Rhs&& rng, IndexBegin&& idxBegin, IndexEnd&& idxEnd) noexcept
-				: base_(aggregate_tag, subrange_detail::whole_range(std::forward<Rhs>(rng)))
-				, m_idxBegin(std::forward<IndexBegin>(idxBegin))
-				, m_idxEnd(std::forward<IndexEnd>(idxEnd))
+		public:
+			// default ctor (for deferred initialization)
+			constexpr subrange() = default;
+
+			// ctor from empty range
+			constexpr subrange(tc::empty_range) noexcept(std::is_nothrow_default_constructible<base_>::value) requires std::is_default_constructible<base_>::value
+				: base_()
+				, m_idxBegin()
+				, m_idxEnd()
 			{}
 
-			// ctor from rng/begin/end (with translation)
-			template<typename Rhs, typename IndexBegin, typename IndexEnd>
-			constexpr subrange(index_tag_t, Rhs&& rng, IndexBegin&& idxBegin, IndexEnd&& idxEnd) noexcept
-				: subrange(index_translation_tag, subrange_detail::whole_range(std::forward<Rhs>(rng)), std::forward<IndexBegin>(idxBegin), std::forward<IndexEnd>(idxEnd))
+			// ctor from whole range
+			template<typename Rhs> requires
+				(!tc::instance<std::remove_cvref_t<Rhs>, tc::subrange>) && (!tc::instance<std::remove_cvref_t<Rhs>, tc::universal_range>) && tc::safely_constructible_from<Rng, Rhs>
+			constexpr subrange(Rhs&& rng) noexcept(
+				std::is_nothrow_constructible<base_, aggregate_tag_t, Rhs>::value &&
+				noexcept(subrange_detail::get_index<Rng>::begin(rng)) &&
+				noexcept(subrange_detail::get_index<Rng>::end(rng))
+			)
+				: base_(aggregate_tag, tc_move_if_owned(rng))
+				, m_idxBegin(subrange_detail::get_index<Rng>::begin(this->base_range_best_access(), rng))
+				, m_idxEnd(subrange_detail::get_index<Rng>::end(this->base_range_best_access(), rng))
 			{}
 
-		public:
-			// ctor from other subrange ()
-			template<typename Rhs> requires 
-				(!tc::instance<Rng, tc::iterator_base>) &&
-				(
-					// Note: Substitution failure, if std::remove_cvref_t<Rhs> not a subrange
-					!std::is_same<Rng, tc::type::only_t<typename tc::is_instance<std::remove_reference_t<Rhs>, tc::subrange>::arguments>>::value ||
-					(
-						// Do not compete with valid, trivial copy and move ctors. But translate indices for random acess ranges, if necessary.
-						!std::is_lvalue_reference<Rng>::value && tc::random_access_range<Rng>
-					)
-				) &&
-				tc::safely_constructible_from<Rng, decltype(std::declval<Rhs>().base_range())> &&
-				// tc_index may not be tc::safely_constructible_from because of slicing (e.g. std::vector::const_iterator/iterator on Windows, or tc::element_t)
-				std::is_constructible<tc_index, decltype(std::declval<Rhs>().begin_index())>::value
-			constexpr subrange(Rhs&& rng) noexcept
+			// ctor from other subrange
+			template <typename Rhs> requires
+				tc::instance<std::remove_cvref_t<Rhs>, tc::subrange> && tc::safely_constructible_from<Rng, subrange_detail::whole_range_t<Rhs>> &&
+				// If Rhs is the same subrange, we must not have a copy constructor we could have used instead.
+				(!std::same_as<std::remove_cvref_t<Rhs>, subrange> || !tc::borrowed_range<Rhs>) &&
+				// If we require index translation, we must have a random access range.
+				(!subrange_detail::require_index_translation<Rng, Rhs> || tc::random_access_range<Rng>)
+			constexpr subrange(Rhs&& rng) noexcept(noexcept(tc::begin_index(rng)) && noexcept(tc::end_index(rng)))
 				: subrange(index_tag,
-					std::forward<Rhs>(rng),
-					std::forward<Rhs>(rng).begin_index(),
-					std::forward<Rhs>(rng).end_index()
+					subrange_detail::whole_range(tc_move_if_owned(rng)),
+					subrange_detail::get_index<Rng>::begin(rng),
+					subrange_detail::get_index<Rng>::end(rng)
 				)
 			{}
 
+			// ctor for tc::slice
 			template<typename Rhs, typename Begin, typename End> requires
-				tc::safely_constructible_from<Rng, decltype(subrange_detail::whole_range(std::declval<Rhs>()))> &&
-				 // tc_index may not be tc::safely_constructible_from because of slicing (e.g. std::vector::const_iterator/iterator on Windows, or tc::element_t)
-				std::is_constructible<tc_index, decltype(tc::iterator2index<Rhs>(std::declval<Begin>()))>::value &&
-				std::is_constructible<tc_index, decltype(tc::iterator2index<Rhs>(std::declval<End>()))>::value
+				tc::safely_constructible_from<Rng, subrange_detail::whole_range_t<Rhs>> &&
+				subrange_detail::is_index_safely_constructible<tc_index, decltype(tc::iterator2index<Rhs>(std::declval<Begin>()))> &&
+				subrange_detail::is_index_safely_constructible<tc_index, decltype(tc::iterator2index<Rhs>(std::declval<End>()))>
 			constexpr explicit subrange(Rhs&& rng, Begin&& begin, End&& end) noexcept
-				: subrange(index_tag, std::forward<Rhs>(rng), tc::iterator2index<Rhs>(std::forward<Begin>(begin)), tc::iterator2index<Rhs>(std::forward<End>(end)))
-			{}
-
-			constexpr subrange(tc::empty_range) noexcept(std::is_nothrow_default_constructible<base_>::value) requires std::is_default_constructible<base_>::value
-				: m_idxBegin()
-				, m_idxEnd()
-			{}
-
-		private:
-			template<typename Self>
-			constexpr static auto data_(Self&& self) return_decltype_NOEXCEPT(
-				tc::ptr_begin(self.base_range()) + tc::distance_to_index(
-					self.base_range(),
-					tc::begin_index(self.base_range()), // declared MAYTHROW
-					self.begin_index()
+				: subrange(index_tag,
+					subrange_detail::whole_range(tc_move_if_owned(rng)),
+					tc::iterator2index<Rhs>(tc_move_if_owned(begin)),
+					tc::iterator2index<Rhs>(tc_move_if_owned(end))
 				)
-			)
-
-		public:
-			RVALUE_THIS_OVERLOAD_MOVABLE_MUTABLE_REF(data)
+			{
+				static_assert(!subrange_detail::require_index_translation<Rng, subrange_detail::whole_range_t<Rhs>> || tc::random_access_range<Rng>,
+					"We require index translation but do not have a random access range. Potential fixes: make Rng a random access range, specialize tc::enable_stable_index_on_move for Rng and move Rhs in, or specialize tc::enable_borrowed_range");
+			}
 
 		private:
 			STATIC_FINAL_MOD(constexpr, begin_index)() const& noexcept -> tc_index {
@@ -276,38 +375,8 @@ namespace tc {
 			STATIC_FINAL_MOD(constexpr, at_end_index)(tc_index const& idx) const& noexcept -> bool {
 				return idx == m_idxEnd;
 			}
-		public:
-			////////////////////////////////////////////////////////
-			// simulate iterator interface on top of index interface
-
-			// boost::range_iterator<subrange>::type is the same type as the base range iterator:
-			using iterator = tc::decay_t<decltype(tc::make_iterator(*std::declval<tc::reference_or_value<Rng>&>(), std::declval<tc_index>()))>;
-			using const_iterator = tc::decay_t<decltype(tc::make_iterator(*std::declval<tc::reference_or_value<Rng> const&>(), std::declval<tc_index>()))>;
-
-			constexpr const_iterator make_iterator( tc_index idx ) const& noexcept {
-				return tc::make_iterator( this->base_range(), tc_move(idx));
-			}
-
-			constexpr const_iterator begin() const& noexcept {
-				return make_iterator(this->begin_index());
-			}
-
-			constexpr const_iterator end() const& noexcept {
-				return make_iterator(this->end_index());
-			}
-
-			constexpr iterator make_iterator( tc_index idx ) & noexcept {
-				return tc::make_iterator( this->base_range(), tc_move(idx));
-			}
-
-			constexpr iterator begin() & noexcept {
-				return make_iterator(this->begin_index());
-			}
-
-			constexpr iterator end() & noexcept {
-				return make_iterator(this->end_index());
-			}
 
+		public:
 			template< typename It >
 			constexpr void take_inplace( It&& it ) & noexcept {
 				m_idxEnd=tc::iterator2index<Rng>( std::forward<It>(it) );
@@ -317,58 +386,74 @@ namespace tc {
 			constexpr void drop_inplace( It&& it ) & noexcept {
 				m_idxBegin=tc::iterator2index<Rng>( std::forward<It>(it) );
 			}
-
-			template< typename It >
-			constexpr friend subrange&& take( subrange&& rng, It&& it ) noexcept {
-				rng.take_inplace(std::forward<It>(it));
-				return tc_move(rng);
-			}
-
-			template< typename It >
-			constexpr friend subrange&& drop( subrange&& rng, It&& it ) noexcept {
-				rng.drop_inplace(std::forward<It>(it));
-				return tc_move(rng);
-			}
-
-			constexpr decltype(auto) dereference_untransform(tc_index const& idx) const& noexcept {
-				return this->base_range().dereference_untransform(idx);
-			}
 		};
 	}
 
-	namespace no_adl {
-		template<typename Rng>
-		struct is_index_valid_for_move_constructed_range<tc::subrange<Rng>> : tc::is_index_valid_for_move_constructed_range<Rng> {};
-	}
-
-	template<tc::range_with_iterators Rng>
-	[[nodiscard]] constexpr auto make_view(Rng&& rng) return_ctor_MAYTHROW(
-		tc::make_subrange_result_t< Rng >,
-		(std::forward<Rng>(rng))
-	)
+	template<typename Rng>
+	constexpr auto enable_stable_index_on_move<tc::subrange<Rng>> = tc::stable_index_on_move<Rng>;
+	template <typename Rng>
+	constexpr auto enable_borrowed_range<tc::subrange<Rng>> = tc::borrowed_range<Rng>;
 
 	//-------------------------------------------------------------------------------------------------------------------------
-	// slice
+	// subrange creation
+
+	template<tc::range_with_iterators Rng>
+	[[nodiscard]] constexpr auto all(Rng&& rng) return_ctor_MAYTHROW( tc::make_subrange_result_t< Rng >, (std::forward<Rng>(rng)) )
 
 	// slice from range + iterator pair
 	// slice from range + difference
 	template< typename Rng, typename Begin, typename End >
-	[[nodiscard]] constexpr auto slice(Rng&& rng, Begin&& begin, End&& end) return_ctor_noexcept(
+	[[nodiscard]] constexpr auto slice(Rng&& rng, Begin&& begin, End&& end) return_ctor_MAYTHROW(
 		tc::make_subrange_result_t< Rng >,
 		(std::forward<Rng>(rng), std::forward<Begin>(begin), std::forward<End>(end))
 	)
 
-	//-------------------------------------------------------------------------------------------------------------------------
-	// take
-	template< typename Rng, typename End >
-	[[nodiscard]] constexpr auto take(Rng&& rng, End&& end) return_ctor_NOEXCEPT( // boost::iterator_range doesn't have a noexcept constructor
-		tc::make_subrange_result_t< Rng >,
-		(std::forward<Rng>(rng), tc::begin(rng), std::forward<End>(end))
+	template< typename It >
+	[[nodiscard]] constexpr auto make_iterator_range( It itBegin, It itEnd ) return_ctor_MAYTHROW(
+		tc::subrange<tc::universal_range<It>>,
+		( tc::universal_range<It>(), tc_move(itBegin), tc_move(itEnd) )
 	)
 
+	namespace make_iterator_range_detail {
+		template< typename IndexRange, bool bConst >
+		[[nodiscard]] constexpr decltype(auto) get_range( tc::index_iterator<IndexRange, bConst> const& itBegin, tc::index_iterator<IndexRange, bConst> const& itEnd ) noexcept {
+			if constexpr (!tc::empty_type<IndexRange>) _ASSERTEQUAL(std::addressof(itBegin.get_range()), std::addressof(itEnd.get_range()));
+			return itBegin.get_range();
+		}
+	}
+
+	template< typename IndexRange, bool bConst >
+	[[nodiscard]] constexpr auto make_iterator_range( tc::index_iterator<IndexRange, bConst> itBegin, tc::index_iterator<IndexRange, bConst> itEnd ) return_ctor_MAYTHROW(
+		TC_FWD(tc::make_subrange_result_t< tc::conditional_const_t<IndexRange,bConst> & >),
+		( make_iterator_range_detail::get_range(itBegin, itEnd), tc_move(itBegin).get_index(), tc_move(itEnd).get_index() )
+	) 
+
+	template <typename It>
+	using iterator_range = decltype(tc::make_iterator_range(std::declval<It>(), std::declval<It>()));
+	template <typename Rng>
+		requires tc::safely_convertible_to<Rng&&, tc::iterator_range<tc::iterator_t<Rng>>>
+	using iterator_range_t = tc::iterator_range<tc::iterator_t<Rng>>;
+
+	template< typename T >
+	[[nodiscard]] constexpr auto make_empty_range() noexcept {
+		return tc::make_iterator_range( std::add_pointer_t<T>(), std::add_pointer_t<T>() );
+	}
+
+	//-------------------------------------------------------------------------------------------------------------------------
+	// make counted range
+
+	template< typename It, typename Count >
+	[[nodiscard]] constexpr auto counted( It const& it, Count&& count ) noexcept {
+		return tc::make_iterator_range( it, it+std::forward<Count>(count) );
+	}
+
+	template< tc::char_type T, std::size_t N >
+	[[nodiscard]] auto as_array(T (&at)[N] ) return_decltype_noexcept(
+		tc::counted( std::addressof(at[0]), N )
+	)
 
 	//-------------------------------------------------------------------------------------------------------------------------
-	// drop
+	// take/drop
 	namespace detail {
 		template<typename Cont, typename It>
 		concept has_mem_fn_erase_from_begin = requires { std::declval<Cont&>().erase(tc::begin(std::declval<Cont&>()),std::declval<It&&>()); };
@@ -380,8 +465,43 @@ namespace tc {
 		concept has_mem_fn_drop_inplace = requires { std::declval<Cont&>().drop_inplace(std::declval<It&&>()); };
 	}
 
-	template< typename T >
-	concept char_ptr = std::is_pointer<T>::value && tc::char_type<std::remove_pointer_t<T>>;
+	template< typename Cont, typename It >
+	constexpr void take_inplace( Cont& cont, It&& it ) noexcept {
+		if constexpr( detail::has_mem_fn_take_inplace<Cont,It> ) {
+			cont.take_inplace(std::forward<It>(it));
+		} else if constexpr( (tc::instance<Cont, std::vector> || tc::instance<Cont, std::deque>) && !std::is_move_assignable<tc::range_value_t<Cont&>>::value ) {
+			if (tc::begin(cont) == it) {
+				cont.clear();
+			} else {
+				--it;
+				while (tc_modified(tc::end(cont), --_) != it) {
+					cont.pop_back();
+				}
+			}
+		} else {
+			cont.erase(std::forward<It>(it),tc::end(cont));
+		}
+	}
+
+	template< typename Rng, typename End >
+	[[nodiscard]] constexpr auto take(Rng&& rng, End&& end) return_ctor_NOEXCEPT( // boost::iterator_range doesn't have a noexcept constructor
+		tc::make_subrange_result_t< Rng >,
+		(std::forward<Rng>(rng), tc::begin(rng), std::forward<End>(end))
+	)
+
+	template< typename C, typename T, typename A, typename It >
+	[[nodiscard]] std::basic_string<C,T,A> && take( std::basic_string<C,T,A>&& rng, It&& it ) noexcept {
+		tc::take_inplace(rng,std::forward<It>(it));
+		return tc_move(rng);
+	}
+#if 0
+	// TODO: pending proper fix of chained calls in partition_range.h
+	template< typename Rng, typename It >
+	[[nodiscard]] constexpr subrange<Rng>&& take( subrange<Rng>&& rng, It&& it ) noexcept {
+		rng.take_inplace(std::forward<It>(it));
+		return tc_move(rng);
+	}
+#endif
 
 	template< typename Cont, typename It> requires detail::has_mem_fn_erase_from_begin<Cont,It>
 	constexpr void drop_inplace( Cont & cont, It&& it ) noexcept {
@@ -398,22 +518,33 @@ namespace tc {
 		pch=std::forward<It>(it);
 	}
 
-	template< typename Rng, typename It>
-	constexpr tc::make_subrange_result_t< Rng > drop_impl( Rng&& rng, It&& itBegin ) noexcept {
-		return tc::make_subrange_result_t< Rng >( std::forward<Rng>(rng), std::forward<It>(itBegin), tc::end(rng) );
-	}
+	namespace detail {
+		template< typename Rng, typename It>
+		constexpr tc::make_subrange_result_t< Rng > drop_impl( Rng&& rng, It&& itBegin ) noexcept {
+			return tc::make_subrange_result_t< Rng >( std::forward<Rng>(rng), std::forward<It>(itBegin), tc::end(rng) );
+		}
 
-	// C strings have efficient in-place drop
-	template< typename CharPtr, typename It> requires tc::char_ptr<std::remove_reference_t<CharPtr>>
-	constexpr std::decay_t<CharPtr> drop_impl( CharPtr&& pch, It&& it ) noexcept {
-		return tc_modified(pch, tc::drop_inplace(_, std::forward<It>(it)));
+		// C strings have efficient in-place drop
+		template< typename CharPtr, typename It> requires tc::char_ptr<std::remove_reference_t<CharPtr>>
+		constexpr std::decay_t<CharPtr> drop_impl( CharPtr&& pch, It&& it ) noexcept {
+			return tc_modified(pch, tc::drop_inplace(_, std::forward<It>(it)));
+		}
 	}
 
 	template< typename Rng, typename It >
 	[[nodiscard]] constexpr auto drop(Rng&& rng, It&& it) return_decltype_NOEXCEPT(
-		drop_impl( std::forward<Rng>(rng), std::forward<It>(it) )
+		detail::drop_impl( std::forward<Rng>(rng), std::forward<It>(it) )
 	)
 
+#if 0
+	// TODO: pending proper fix of chained calls in partition_range.h
+	template< typename Rng, typename It >
+	[[nodiscard]] constexpr subrange<Rng>&& drop( subrange<Rng>&& rng, It&& it ) noexcept {
+		rng.drop_inplace(std::forward<It>(it));
+		return tc_move(rng);
+	}
+#endif
+
 	////////////////////////////////
 	// begin_next/end_prev
 
@@ -481,7 +612,6 @@ namespace tc {
 		return begin_next_detail::begin_next<RangeReturn, /*bLinear*/true>(std::forward<Rng>(rng), n, typename boost::range_traversal<Rng>::type());
 	}
 
-
 	namespace end_prev_detail {
 		template< typename RangeReturn, typename Rng >
 		constexpr auto end_prev(
@@ -529,54 +659,11 @@ namespace tc {
 	////////////////////////////////////////////////////////////////////////////////////
 	// take/drop_*_first/last_n
 
-	template< typename Cont, typename It >
-	constexpr void take_inplace( Cont& cont, It&& it ) noexcept {
-		if constexpr( detail::has_mem_fn_take_inplace<Cont,It> ) {
-			cont.take_inplace(std::forward<It>(it));
-		} else if constexpr( (tc::instance<Cont, std::vector> || tc::instance<Cont, std::deque>) && !std::is_move_assignable<tc::range_value_t<Cont&>>::value ) {
-			if (tc::begin(cont) == it) {
-				cont.clear();
-			} else {
-				--it;
-				while (tc_modified(tc::end(cont), --_) != it) {
-					cont.pop_back();
-				}
-			}
-		} else {
-			cont.erase(std::forward<It>(it),tc::end(cont));
-		}
-	}
-
-	template< typename C, typename T, typename A, typename It >
-	[[nodiscard]] std::basic_string<C,T,A> && take( std::basic_string<C,T,A>&& rng, It&& it ) noexcept {
-		tc::take_inplace(rng,std::forward<It>(it));
-		return tc_move(rng);
+	template< typename Cont >
+	void take_first_inplace(Cont& cont, typename boost::range_size< std::remove_reference_t<Cont> >::type n=1) noexcept {
+		tc::take_inplace(cont, tc::begin_next<tc::return_border>(cont,n));
 	}
 
-	namespace return_detail::no_adl {
-		template<typename ReturnSubrange>
-		struct return_subrange_or_assert;
-	}
-
-	namespace no_adl {
-		struct return_border;
-		struct return_take_or_empty;
-		struct return_drop_or_empty;
-	}
-	using no_adl::return_border;
-	using no_adl::return_take_or_empty;
-	using no_adl::return_drop_or_empty;
-	using return_take = return_detail::no_adl::return_subrange_or_assert<tc::return_take_or_empty>;
-	using return_drop = return_detail::no_adl::return_subrange_or_assert<tc::return_drop_or_empty>;
-
-	template< typename Cont >
-	void take_first_inplace(Cont& cont, typename boost::range_size< std::remove_reference_t<Cont> >::type n=1) noexcept {
-		tc::take_inplace(cont, tc::begin_next<tc::return_border>(cont,n));
-	}
-
-	template< typename It, typename T, typename Sentinel >
-	T advance_forward_bounded(It&& it, T n, Sentinel&& itBound) noexcept;
-
 	namespace take_first_detail {
 		TC_DEFINE_ENUM(ETakePred, etakepred,
 			(TAKEANDCONTINUE)
@@ -664,7 +751,7 @@ namespace tc {
 		}
 
 		template< typename TakePred, bool bTruncate, typename Rng >
-		auto take_first_impl(Rng&& rng, std::size_t n) noexcept {
+		auto take_first_impl(Rng&& rng, std::size_t const n) noexcept {
 			static_assert(!tc::range_with_iterators<Rng>);
 			return [rng=tc::make_reference_or_value(std::forward<Rng>(rng)), n](auto&& sink) MAYTHROW {
 				if(0<n) {
@@ -746,7 +833,7 @@ namespace tc {
 	}
 
 	template< typename RangeReturn, typename Rng> requires (!tc::range_with_iterators<Rng>) && std::is_same<RangeReturn, tc::return_drop>::value
-	[[nodiscard]] auto begin_next(Rng&& rng, std::size_t n=1) noexcept {
+	[[nodiscard]] auto begin_next(Rng&& rng, std::size_t const n=1) noexcept {
 		return [rng=tc::make_reference_or_value(std::forward<Rng>(rng)), n](auto&& sink) MAYTHROW {
 			auto nCount=n;
 			auto breakorcontinue=tc::for_each(*rng, no_adl::drop_first_sink<tc::decay_t<decltype(sink)>>(tc_move_if_owned(sink), nCount)); // MAYTHROW
@@ -777,31 +864,6 @@ namespace tc {
 	//-------------------------------------------------------------------------------------------------------------------------
 	// take_first_truncate...
 
-	template< typename It, typename T, typename Sentinel >
-	T advance_forward_bounded(It&& it, T n, Sentinel&& itBound) noexcept {
-		_ASSERT(0 <= n);
-		if constexpr( std::convertible_to<
-			typename boost::iterator_traversal<std::remove_reference_t<It>>::type,
-			boost::iterators::random_access_traversal_tag
-		> && requires { itBound - it; } ) {
-			if (tc::assign_better(tc::fn_less_equal(), n, tc::make_size_proxy(itBound - it))) {
-				it = std::forward<Sentinel>(itBound);
-			} else {
-				it += n;
-			}
-			return n;
-		} else {
-			// size_proxy does not provide operator++ and the operation cannot fail here,
-			// because nCount is always inside interval [0,n].
-			auto nCount = tc::explicit_cast<decltype(tc::unmake_size_proxy(n))>(0);
-			while (nCount != n && it != itBound) {
-				++nCount;
-				++it;
-			}
-			tc_return_cast(nCount);
-		}
-	}
-
 	template< typename Cont >
 	void take_first_truncate_inplace( Cont& rng, typename boost::range_size< std::remove_reference_t<Cont> >::type n ) noexcept {
 		auto it=tc::begin(rng);
@@ -809,779 +871,22 @@ namespace tc {
 		tc::take_inplace( rng, tc_move(it) );
 	}
 
-	//-------------------------------------------------------------------------------------------------------------------------
-	// make iterator range
-
-	// subrange from iterator pair
-	template< typename It >
-	constexpr auto make_iterator_range_impl( It itBegin, It itEnd )
-		return_ctor_noexcept( tc::subrange<tc::iterator_base<It>>, ( tc::iterator_base<It>(), tc_move(itBegin), tc_move(itEnd) ) )
-
-	// There is an other make_iterator_range_impl overload for range adaptor based iterarors in range_adaptor.h"
-
-	// make sure ADL lookup of index_iterator::make_iterator_range works
-	template< typename ItBegin, typename ItEnd >
-	[[nodiscard]] constexpr auto make_iterator_range(ItBegin&& itBegin, ItEnd&& itEnd) noexcept {
-		return make_iterator_range_impl( std::forward<ItBegin>(itBegin), std::forward<ItEnd>(itEnd) );
-	}
-
-	//-------------------------------------------------------------------------------------------------------------------------
-	// make empty range
-
-	template< typename T >
-	[[nodiscard]] constexpr auto make_empty_range() noexcept {
-		return make_iterator_range( std::add_pointer_t<T>(), std::add_pointer_t<T>() );
-	}
-		
-	//-------------------------------------------------------------------------------------------------------------------------
-	// make counted range
-
-	template< typename It, typename Count >
-	[[nodiscard]] constexpr auto counted( It const& it, Count&& count ) noexcept {
-		return make_iterator_range( it, it+std::forward<Count>(count) );
-	}
-
-	template< tc::actual_integer T >
-	[[nodiscard]] bool npos(T t) noexcept {
-		if constexpr( std::is_signed<T>::value ) {
-			return -1 == t;
-		} else {
-			return std::numeric_limits<T>::max() == t;
-		}
-	}
-
-	namespace return_detail {
-		template<typename Rng>
-		constexpr decltype(auto) empty_slice(Rng&& rng) noexcept {
-			auto it = tc::begin(rng);
-			auto it2 = it;
-			return tc::slice(std::forward<Rng>(rng), tc_move(it), tc_move(it2));
-		}
-
-		namespace no_adl {
-			// Pack border as subrange
-
-			struct return_take_base {
-				template<typename It, typename Rng>
-				static constexpr auto pack_border(It&& it, Rng&& rng) return_decltype_xvalue_by_ref_noexcept(
-					tc::take(std::forward<Rng>(rng), std::forward<It>(it))
-				)
-			};
-
-			struct return_drop_base {
-				template<typename It, typename Rng>
-				static constexpr auto pack_border(It&& it, Rng&& rng) return_decltype_noexcept(
-					tc::drop(std::forward<Rng>(rng), std::forward<It>(it))
-				)
-			};
-
-			template<typename ReturnSubrange>
-			struct return_subrange_or_assert final : ReturnSubrange {
-				static constexpr bool allowed_if_always_has_border = true;
-
-				template<typename... Args>
-				static decltype(auto) pack_no_border(Args&&... args) noexcept {
-					_ASSERTFALSE;
-					return ReturnSubrange::pack_no_border(std::forward<Args>(args)...);
-				}
-			};
-
-			template<typename ReturnSubrange>
-			struct return_subrange_or_none final {
-				static constexpr bool allowed_if_always_has_border = false;
-
-				template<typename It, typename Rng>
-				static constexpr auto pack_border(It&& it, Rng&& rng) noexcept {
-					return std::optional(ReturnSubrange::pack_border(std::forward<It>(it), std::forward<Rng>(rng)));
-				}
-
-				template<typename Rng, typename... OptEndIt>
-				static constexpr std::optional<decltype(ReturnSubrange::pack_border(tc::begin(std::declval<Rng&>()), std::declval<Rng>()))> pack_no_border(Rng&&, OptEndIt&&...) noexcept {
-					return std::nullopt;
-				}
-			};
-
-			template<typename ReturnSubrange>
-			struct return_subrange_or_all final : ReturnSubrange {
-				static constexpr bool allowed_if_always_has_border = false;
-
-				template<typename Rng, typename... OptEndIt>
-				static constexpr decltype(ReturnSubrange::pack_border(tc::begin(std::declval<Rng&>()), std::declval<Rng>())) pack_no_border(Rng&& rng, OptEndIt&&...) noexcept {
-					return std::forward<Rng>(rng);
-				}
-			};
-
-			// Pack element as border before/after
-
-			template<typename ReturnBorder, bool bSupportsNoElement>
-			struct pack_as_border_base {
-				static_assert( !ReturnBorder::allowed_if_always_has_border, "Specify what to return in the no_element case. Use bSupportsNoElement=false to _ASSERT it does not occur." );
-				static constexpr bool requires_iterator = true;
-
-				template<typename Rng>
-				static constexpr auto pack_no_element(Rng&& rng) noexcept code_return_decltype_xvalue_by_ref(
-					if constexpr( !bSupportsNoElement ) _ASSERTFALSE;,
-					ReturnBorder::pack_no_border(std::forward<Rng>(rng))
-				)
-			};
-
-			template<typename ReturnBorder, bool bSupportsNoElement = true>
-			struct pack_as_border_before : pack_as_border_base<ReturnBorder, bSupportsNoElement> {
-				template<typename It, typename Rng>
-				static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) return_decltype_xvalue_by_ref_noexcept(
-					ReturnBorder::pack_border(std::forward<It>(it), std::forward<Rng>(rng))
-				)
-				template<typename Rng, typename Begin, typename End>
-				static constexpr auto pack_view(Rng&& rng, Begin&& begin, End&& end) return_decltype_xvalue_by_ref_noexcept(
-					ReturnBorder::pack_border(std::forward<Begin>(begin), std::forward<Rng>(rng))
-				)
-			};
-
-			template<typename ReturnBorder, bool bSupportsNoElement = true>
-			struct pack_as_border_after : pack_as_border_base<ReturnBorder, bSupportsNoElement> {
-				template<typename It, typename Rng>
-				static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) return_decltype_xvalue_by_ref_MAYTHROW(
-					++it, // MAYTHROW
-					ReturnBorder::pack_border(std::forward<It>(it), std::forward<Rng>(rng))
-				)
-				template<typename Rng, typename Begin, typename End>
-				static constexpr auto pack_view(Rng&& rng, Begin&&, End&& end) return_decltype_xvalue_by_ref_noexcept(
-					ReturnBorder::pack_border(std::forward<End>(end), std::forward<Rng>(rng))
-				)
-			};
-
-			// Pack border as element before/after
-
-			template<typename ReturnElement>
-			struct pack_as_element_base {
-				static constexpr bool allowed_if_always_has_border = true; // element before/after may not exist, even if we have a border.
-				static_assert( ReturnElement::requires_iterator );
-
-				template<typename Rng, typename... OptEndIt>
-				static constexpr auto pack_no_border(Rng&& rng, OptEndIt&&...) return_decltype_noexcept(
-					ReturnElement::pack_no_element(std::forward<Rng>(rng))
-				)
-			};
-
-			template<typename ReturnElement>
-			struct pack_as_element_before final : pack_as_element_base<ReturnElement> {
-				template<typename It, typename Rng>
-				static constexpr decltype(auto) pack_border(It&& it, Rng&& rng) noexcept(noexcept(--it)) {
-					if( tc::begin(rng) != it ) {
-						--it;
-						return ReturnElement::pack_element(std::forward<It>(it), std::forward<Rng>(rng));
-					} else {
-						return ReturnElement::pack_no_element(std::forward<Rng>(rng));
-					}
-				}
-			};
-
-			template<typename ReturnElement>
-			struct pack_as_element_after final : pack_as_element_base<ReturnElement> {
-				template<typename It, typename Rng>
-				static constexpr decltype(auto) pack_border(It&& it, Rng&& rng) noexcept {
-					if( tc::end(rng) != it ) {
-						return ReturnElement::pack_element(std::forward<It>(it), std::forward<Rng>(rng));
-					} else {
-						return ReturnElement::pack_no_element(std::forward<Rng>(rng));
-					}
-				}
-			};
-		}
-	}
-
-	namespace no_adl {
-		/////////////////////////////////////
-		// return void
-
-		struct return_void final {
-			static constexpr bool requires_iterator = false;
-			static constexpr bool allowed_if_always_has_border = true;
-
-			static constexpr void pack_border(tc::unused /*it*/, tc::unused /*rng*/) noexcept {}
-			static constexpr void pack_no_border(tc::unused /*rng*/) noexcept {}
-			static constexpr void pack_no_border(tc::unused /*rng*/, tc::unused /*itEnd*/) noexcept {}
-			static constexpr void pack_element(tc::unused /*it*/, tc::unused /*rng*/) noexcept {}
-			static constexpr void pack_element(tc::unused /*it*/, tc::unused /*rng*/, tc::unused /*ref*/) noexcept {}
-			template<typename Rng>
-			static constexpr void pack_element(tc::unused /*ref*/) noexcept {}
-			static constexpr void pack_no_element(tc::unused) noexcept {}
-			template<typename Rng>
-			static constexpr void pack_no_element() noexcept {}
-			static constexpr void pack_view(tc::unused /*rng*/, tc::unused /*itBegin*/, tc::unused /*itEnd*/) noexcept {}
-		};
-
-		/////////////////////////////////////
-		// return bool
-
-		struct return_bool {
-			static constexpr bool requires_iterator = false;
-			static constexpr bool allowed_if_always_has_border = false;
-
-			static constexpr bool pack_border(tc::unused /*it*/, tc::unused /*rng*/) noexcept {
-				return true;
-			}
-			static constexpr bool pack_no_border(tc::unused /*rng*/) noexcept {
-				return false;
-			}
-			static constexpr bool pack_no_border(tc::unused /*rng*/, tc::unused /*itEnd*/) noexcept {
-				return false;
-			}
-
-			static constexpr bool pack_element(tc::unused /*it*/, tc::unused /*rng*/) noexcept {
-				return true;
-			}
-			static constexpr bool pack_element(tc::unused /*it*/, tc::unused /*rng*/, tc::unused /*ref*/) noexcept {
-				return true;
-			}
-			template<typename Rng>
-			static constexpr bool pack_element(tc::unused /*ref*/) noexcept {
-				return true;
-			}
-			static constexpr bool pack_no_element(tc::unused) noexcept {
-				return false;
-			}
-			template<typename Rng>
-			static constexpr bool pack_no_element() noexcept {
-				return false;
-			}
-
-			static constexpr bool pack_view(tc::unused /*rng*/, tc::unused /*itBegin*/, tc::unused /*itEnd*/) noexcept {
-				return true;
-			}
-		};
-
-		/////////////////////////////////////
-		// controlling bound return
-
-		// returning bound
-
-		struct return_border {
-			static constexpr bool allowed_if_always_has_border = true;
-
-			template<typename It>
-			static constexpr tc::decay_t<It> pack_border(It&& it, tc::unused /*rng*/) noexcept {
-				return std::forward<It>(it);
-			}
-
-			template<typename Rng, typename... OptEndIt>
-			static auto pack_no_border(Rng&& rng, OptEndIt&&...) noexcept {
-				_ASSERTFALSE;
-				return tc::begin(rng);
-			}
-		};
-
-		struct return_border_or_begin final : return_border {
-			static constexpr bool allowed_if_always_has_border = false;
-
-			template<typename Rng, typename... OptEndIt>
-			static constexpr auto pack_no_border(Rng&& rng, OptEndIt&&...) noexcept {
-				return tc::begin(rng);
-			}
-		};
-
-		struct return_border_or_end final : return_border {
-			static constexpr bool allowed_if_always_has_border = false;
-
-			template<typename Rng>
-			static constexpr auto pack_no_border(Rng&& rng) noexcept {
-				return tc::end(rng);
-			}
-
-			template<typename Rng>
-			static constexpr auto pack_no_border(Rng&& rng, tc::iterator_t<Rng>&& itEnd) noexcept {
-				return tc_move(itEnd);
-			}
-		};
-
-		struct return_border_or_null final {
-			static constexpr bool allowed_if_always_has_border = false;
-
-			template<typename It, typename Rng>
-			static constexpr auto pack_border(It&& it, Rng&&) noexcept {
-				return tc::border_t<tc::decay_t<It>>(std::forward<It>(it));
-			}
-
-			template<typename Rng, typename... OptEndIt>
-			static constexpr auto pack_no_border(Rng&&, OptEndIt&&...) noexcept {
-				return tc::border_t<tc::decay_t<decltype(tc::begin(std::declval<Rng&>()))>>{};
-			}
-		};
-
-		struct return_border_index final {
-			static constexpr bool allowed_if_always_has_border = true;
-
-			template<typename It, typename Rng>
-			static constexpr auto pack_border(It&& it, Rng&& rng) noexcept {
-				return tc::make_size_proxy(it - tc::begin(rng));
-			}
-
-			template<typename Rng, typename... OptEndIt>
-			static auto pack_no_border(Rng&&, OptEndIt&&...) noexcept {
-				_ASSERTFALSE;
-				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
-			}
-		};
-
-		// returning range
-
-		struct return_take_or_empty : return_detail::no_adl::return_take_base {
-			static constexpr bool allowed_if_always_has_border = false;
-
-			template<typename Rng, typename... OptEndIt>
-			static constexpr auto pack_no_border(Rng&& rng, OptEndIt&&...) return_decltype_xvalue_by_ref_MAYTHROW(
-				tc::take(std::forward<Rng>(rng), tc::begin(rng))
-			)
-		};
-
-		struct return_drop_or_empty : return_detail::no_adl::return_drop_base {
-			static constexpr bool allowed_if_always_has_border = false;
-
-			template<typename Rng>
-			static constexpr auto pack_no_border(Rng&& rng) return_decltype_NOEXCEPT(
-				tc::drop(std::forward<Rng>(rng), tc::end(rng))
-			)
-
-			template<typename Rng>
-			static constexpr auto pack_no_border(Rng&& rng, tc::iterator_t<Rng>&& itEnd) return_decltype_NOEXCEPT(
-				tc::drop(std::forward<Rng>(rng), tc_move(itEnd))
-			)
-		};
-
-		/////////////////////////////////////
-		// controlling element return
-
-		// returning element
-
-		struct return_element {
-			static constexpr bool requires_iterator = true;
-
-			template<typename It>
-			static constexpr tc::decay_t<It> pack_element(It&& it, tc::unused /*rng*/, tc::unused /*ref*/={}) noexcept {
-				return std::forward<It>(it);
-			}
-
-			template<typename Rng>
-			static auto pack_no_element(Rng&& rng) noexcept {
-				_ASSERTFALSE;
-				return tc::begin(rng);
-			}
-		};
-
-		struct return_element_or_null final {
-			static constexpr bool requires_iterator = true;
-
-			template<typename It>
-			static constexpr auto pack_element(It&& it, tc::unused /*rng*/, tc::unused /*ref*/={}) noexcept {
-				return tc::make_element(std::forward<It>(it));
-			}
-
-			template<typename Rng>
-			static constexpr auto pack_no_element(Rng&&) noexcept {
-				return tc::element_t<tc::decay_t<decltype(tc::begin(std::declval<Rng&>()))>>{}; // value initialization to initialize pointers to nullptr
-			}
-		};
-
-		struct return_element_or_front final : return_element {
-			template<typename Rng>
-			static constexpr auto pack_no_element(Rng&& rng) noexcept {
-				return tc::begin(rng);
-			}
-		};
-
-		struct return_element_or_back final : return_element {
-			template<typename Rng>
-			static constexpr auto pack_no_element(Rng&& rng) noexcept {
-				return tc::end_prev<tc::return_border>(std::forward<Rng>(rng));
-			}
-		};
-
-		struct return_value {
-			static constexpr bool requires_iterator = false;
-
-			// Don't take it by value, or ref may be invalidated
-			template<typename Rng, typename Ref>
-			static constexpr tc::range_value_t<Rng> pack_element(tc::unused /*it*/, Rng&&, Ref&& ref) noexcept {
-				return std::forward<Ref>(ref);
-			}
-			template<typename It, typename Rng>
-			static constexpr tc::range_value_t<Rng> pack_element(It&& it, Rng&&) noexcept {
-				return *std::forward<It>(it);
-			}
-			template<typename Rng, typename Ref>
-			static constexpr tc::range_value_t<Rng> pack_element(Ref&& ref) noexcept {
-				return std::forward<Ref>(ref);
-			}
-			template<typename Rng>
-			static auto pack_no_element(Rng&&) noexcept {
-				_ASSERTFALSE;
-				return tc::construct_default_or_terminate<tc::range_value_t<Rng>>();
-			}
-			template<typename Rng>
-			static auto pack_no_element() noexcept {
-				_ASSERTFALSE;
-				return tc::construct_default_or_terminate<tc::range_value_t<Rng>>();
-			}
-		};
-
-		struct return_value_or_default final : return_value {
-			template<typename Rng>
-			static constexpr tc::range_value_t<Rng> pack_no_element(Rng&&) noexcept {
-				return {};
-			}
-			template<typename Rng>
-			static constexpr tc::range_value_t<Rng> pack_no_element() noexcept {
-				return {};
-			}
-		};
-
-		struct return_value_or_none final {
-			static constexpr bool requires_iterator = false;
-
-			// Don't take it by value, or ref may be invalidated
-			template<typename Rng, typename Ref>
-			static constexpr std::optional<tc::range_value_t<Rng>> pack_element(tc::unused /*it*/, Rng&&, Ref&& ref) noexcept {
-				return std::forward<Ref>(ref);
-			}
-			template<typename It, typename Rng>
-			static constexpr std::optional<tc::range_value_t<Rng>> pack_element(It&& it, Rng&&) noexcept {
-				return *std::forward<It>(it);
-			}
-			template<typename Rng, typename Ref>
-			static constexpr std::optional<tc::range_value_t<Rng>> pack_element(Ref&& ref) noexcept {
-				return std::forward<Ref>(ref);
-			}
-			template<typename Rng>
-			static constexpr std::optional<tc::range_value_t<Rng>> pack_no_element(Rng&&) noexcept {
-				return std::nullopt;
-			}
-			template<typename Rng>
-			static constexpr std::optional<tc::range_value_t<Rng>> pack_no_element() noexcept {
-				return std::nullopt;
-			}
-		};
-
-		struct return_element_index {
-			static constexpr bool requires_iterator = true;
-
-			template<typename It, typename Rng>
-			static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) noexcept {
-				return tc::make_size_proxy(it - tc::begin(rng));
-			}
-
-			template<typename Rng>
-			static auto pack_no_element(Rng&&) noexcept {
-				_ASSERTFALSE;
-				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
-			}
-		};
-
-		struct return_element_index_or_none final {
-			static constexpr bool requires_iterator = true;
-
-			template<typename It, typename Rng>
-			static constexpr auto pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) noexcept {
-				return std::optional(tc::make_size_proxy(it - tc::begin(rng)));
-			}
-
-			template<typename Rng>
-			static constexpr std::optional<decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))> pack_no_element(Rng&&) noexcept {
-				return std::nullopt;
-			}
-		};
-
-		struct return_element_index_or_npos final : return_element_index {
-			// Note: prefer return_element_index_or_none
-			// static_cast<int>(npos) must be -1. Anything else is error-prone. So use range_difference instead of range_size.
-			// Alternatively, we could return a special type that casts npos to -1.
-			static constexpr bool requires_iterator = true;
-
-			template<typename Rng>
-			static constexpr auto pack_no_element(Rng&&) noexcept {
-				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(-1);
-			}
-		};
-
-		struct return_element_index_or_size final : return_element_index {
-			template<typename Rng>
-			static constexpr auto pack_no_element(Rng&& rng) noexcept {
-				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(tc::size(rng));
-			}
-		};
-
-		struct return_singleton_range {
-			static constexpr bool requires_iterator = true;
-
-			template<typename It, typename Rng>
-			static constexpr decltype(auto) pack_element(It&& it, Rng&& rng, tc::unused /*ref*/={}) noexcept(noexcept(++tc::as_lvalue(tc::decay_copy(it)))) {
-				return tc::slice(std::forward<Rng>(rng), it, tc_modified(it, ++_));
-			}
-			template<typename Rng>
-			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
-				// safe choice is empty because result may be empty
-				_ASSERTFALSE;
-				return tc::return_detail::empty_slice(std::forward<Rng>(rng));
-			}
-		};
-
-		struct return_singleton_range_or_empty final : return_singleton_range {
-			template<typename Rng>
-			static constexpr auto pack_no_element(Rng&& rng) return_decltype_noexcept(
-				tc::return_detail::empty_slice(std::forward<Rng>(rng))
-			)
-		};
-
-		/////////////////////////////////////
-		// controlling view return
-
-		struct return_view {
-			template<typename Rng, typename Begin, typename End>
-			static constexpr auto pack_view(Rng&& rng, Begin&& begin, End&& end) return_decltype_noexcept(
-				tc::slice(std::forward<Rng>(rng), std::forward<Begin>(begin), std::forward<End>(end))
-			)
-
-			template<typename Rng>
-			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
-				_ASSERTFALSE;
-				return tc::slice(std::forward<Rng>(rng), tc::begin(rng), tc::end(rng));
-			}
-		};
-
-		struct return_view_or_none final {
-			template<typename Rng, typename Begin, typename End>
-			static constexpr auto pack_view(Rng&& rng, Begin&& begin, End&& end) noexcept {
-				return std::optional(return_view::pack_view(std::forward<Rng>(rng), std::forward<Begin>(begin), std::forward<End>(end)));
-			}
-
-			template<typename Rng>
-			static std::optional<decltype(return_view::pack_no_element(std::declval<Rng>()))> pack_no_element(Rng&&) noexcept {
-				return std::nullopt;
-			}
-		};
-
-		struct return_view_or_empty final : return_view {
-			template<typename Rng>
-			static constexpr auto pack_no_element(Rng&& rng) return_decltype_noexcept(
-				tc::return_detail::empty_slice(std::forward<Rng>(rng))
-			)
-		};
-
-		struct return_begin_index final {
-			template<typename Rng, typename Begin, typename End>
-			static constexpr decltype(auto) pack_view(Rng&& rng, Begin&& begin, End&& end) noexcept {
-				return tc::make_size_proxy(begin - tc::begin(rng));
-			}
-
-			template<typename Rng>
-			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
-				_ASSERTFALSE;
-				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
-			}
-		};
-
-		struct return_end_index final {
-			template<typename Rng, typename Begin, typename End>
-			static constexpr decltype(auto) pack_view(Rng&& rng, Begin&& begin, End&& end) noexcept {
-				return tc::make_size_proxy(end - tc::begin(rng));
-			}
-
-			template<typename Rng>
-			static decltype(auto) pack_no_element(Rng&& rng) noexcept {
-				_ASSERTFALSE;
-				return decltype(tc::make_size_proxy(tc::begin(std::declval<Rng&>()) - tc::begin(std::declval<Rng&>())))(0);
-			}
-		};
-	} // namespace no_adl
-	using no_adl::return_void;
-	using no_adl::return_bool;
-
-	// return border
-	using no_adl::return_border;
-	using no_adl::return_border_or_begin;
-	using no_adl::return_border_or_end;
-	using no_adl::return_border_or_null;
-	using no_adl::return_border_index;
-
-	using no_adl::return_take_or_empty;
-	using return_take = return_detail::no_adl::return_subrange_or_assert<tc::return_take_or_empty>;
-	using return_take_or_none = return_detail::no_adl::return_subrange_or_none<return_detail::no_adl::return_take_base>;
-	using return_take_or_all = return_detail::no_adl::return_subrange_or_all<return_detail::no_adl::return_take_base>;
-
-	using no_adl::return_drop_or_empty;
-	using return_drop = return_detail::no_adl::return_subrange_or_assert<tc::return_drop_or_empty>;
-	using return_drop_or_none = return_detail::no_adl::return_subrange_or_none<return_detail::no_adl::return_drop_base>;
-	using return_drop_or_all = return_detail::no_adl::return_subrange_or_all<return_detail::no_adl::return_drop_base>;
-
-	// return element
-	using no_adl::return_element;
-	using no_adl::return_element_or_null;
-	using no_adl::return_element_or_front;
-	using no_adl::return_element_or_back;
-	using no_adl::return_value;
-	using no_adl::return_value_or_default;
-	using no_adl::return_value_or_none;
-	using no_adl::return_element_index;
-	using no_adl::return_element_index_or_none;
-	using no_adl::return_element_index_or_npos;
-	using no_adl::return_element_index_or_size;
-	using no_adl::return_singleton_range;
-	using no_adl::return_singleton_range_or_empty;
-
-	// return border element
-	using return_element_before = return_detail::no_adl::pack_as_element_before<tc::return_element>;
-	using return_element_before_or_null = return_detail::no_adl::pack_as_element_before<tc::return_element_or_null>;
-	using return_element_before_or_front = return_detail::no_adl::pack_as_element_before<tc::return_element_or_front>;
-	using return_element_after = return_detail::no_adl::pack_as_element_after<tc::return_element>;
-	using return_element_after_or_null = return_detail::no_adl::pack_as_element_after<tc::return_element_or_null>;
-	using return_element_after_or_back = return_detail::no_adl::pack_as_element_after<tc::return_element_or_back>;
-
-	// return element border
-	using return_border_after = return_detail::no_adl::pack_as_border_after<tc::return_border_or_end, false>;
-	using return_border_after_or_begin = return_detail::no_adl::pack_as_border_after<tc::return_border_or_begin>;
-	using return_border_after_or_end = return_detail::no_adl::pack_as_border_after<tc::return_border_or_end>;
-	using return_border_before = return_detail::no_adl::pack_as_border_before<tc::return_border_or_begin, false>;
-	using return_border_before_or_begin = return_detail::no_adl::pack_as_border_before<tc::return_border_or_begin>;
-	using return_border_before_or_end = return_detail::no_adl::pack_as_border_before<tc::return_border_or_end>;
-
-	using return_take_before = return_detail::no_adl::pack_as_border_before<tc::return_take_or_empty, false>; // safe choice is empty because result may be empty
-	using return_take_before_or_empty = return_detail::no_adl::pack_as_border_before<tc::return_take_or_empty>;
-	using return_take_before_or_all = return_detail::no_adl::pack_as_border_before<tc::return_take_or_all>;
-	using return_take_before_or_none = return_detail::no_adl::pack_as_border_before<tc::return_take_or_none>;
-	using return_take_after = return_detail::no_adl::pack_as_border_after<tc::return_take_or_all, false>; // safe choice is all because result is never empty
-	using return_take_after_or_empty = return_detail::no_adl::pack_as_border_after<tc::return_take_or_empty>;
-	using return_take_after_or_all = return_detail::no_adl::pack_as_border_after<tc::return_take_or_all>;
-	using return_take_after_or_none = return_detail::no_adl::pack_as_border_after<tc::return_take_or_none>;
-
-	using return_drop_before = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_all, false>; // safe choice is all because result is never empty
-	using return_drop_before_or_empty = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_empty>;
-	using return_drop_before_or_all = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_all>;
-	using return_drop_before_or_none = return_detail::no_adl::pack_as_border_before<tc::return_drop_or_none>;
-	using return_drop_after = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_empty, false>; // safe choice is empty because result may be empty
-	using return_drop_after_or_empty = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_empty>;
-	using return_drop_after_or_all = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_all>;
-	using return_drop_after_or_none = return_detail::no_adl::pack_as_border_after<tc::return_drop_or_none>;
-
-	// return view
-	using no_adl::return_view;
-	using no_adl::return_view_or_none;
-	using no_adl::return_view_or_empty;
-	using no_adl::return_begin_index;
-	using no_adl::return_end_index;
-
-	//-------------------------------------------------------------------------------------------------------------------------
-	// as_array
-
-	template< tc::char_type T, std::size_t N >
-	[[nodiscard]] auto as_array(T (&at)[N] ) return_decltype_noexcept(
-		tc::counted( std::addressof(at[0]), N )
-	)
-
 
 	//-------------------------------------------------------------------------------------------------------------------------
 	// span
 	template <typename T>
-	using span = subrange<iterator_base<T*>>;
+	using span = subrange<universal_range<T*>>;
 
 	namespace span_detail {
 		template <typename Rng>
-		using unchecked_span_t = span<std::remove_pointer_t<decltype(tc::ptr_begin(std::declval<Rng>()))>>;
+		using unchecked_span_t = span<std::remove_pointer_t<tc::ptr_iterator_t<Rng>>>;
 	}
 
 	template <tc::contiguous_range Rng>
-			requires tc::safely_convertible_to<Rng&&, span_detail::unchecked_span_t<Rng>>
+		requires tc::safely_convertible_to<Rng&&, span_detail::unchecked_span_t<Rng>>
 	using span_t = span_detail::unchecked_span_t<Rng>;
 
-	namespace no_adl {
-		template<typename T>
-		struct is_lvalue_reference_or_iterator_base_subrange : tc::constant<false> {};
-
-		template<typename Rng>
-		struct is_lvalue_reference_or_iterator_base_subrange<tc::subrange<Rng>>
-			: tc::constant<std::is_lvalue_reference<Rng>::value || tc::instance<Rng, tc::iterator_base>>
-		{};
-
-		template<typename T, typename TSource>
-		struct is_class_safely_constructible<tc::span<T>, TSource> final
-			: tc::constant<
-				std::is_lvalue_reference<TSource>::value ||
-				std::is_pointer<std::remove_reference_t<TSource>>::value ||
-				std::is_same<tc::decay_t<TSource>, tc::empty_range>::value ||
-				is_lvalue_reference_or_iterator_base_subrange<std::remove_cvref_t<TSource>>::value
-			>
-		{};
-
-		template<typename T1, typename T2>
-		struct common_span_impl_base {};
-
-		template<typename T1, typename T2>
-			requires (sizeof(T1)==sizeof(std::remove_pointer_t<tc::common_type_t<T1*, T2*>>))
-				&& (sizeof(T2)==sizeof(std::remove_pointer_t<tc::common_type_t<T1*, T2*>>))
-		struct common_span_impl_base<tc::span<T1>, tc::span<T2>> {
-			using type = tc::span<std::remove_pointer_t<tc::common_type_t<T1*, T2*>>>;
-		};
-
-		template<typename Rng0, typename Rng1, typename Enable=void>
-		struct common_span_impl final {};
-
-		template<>
-		struct common_span_impl<empty_range, empty_range, void> final
-		{
-			using type = empty_range;
-		};
-
-		template<typename Rng>
-		struct common_span_impl<empty_range, Rng, tc::void_t<tc::span_t<Rng>>> final
-		{
-			using type = tc::span_t<Rng>;
-		};
-
-		template<typename Rng>
-		struct common_span_impl<Rng, empty_range, tc::void_t<tc::span_t<Rng>>> final
-		{
-			using type = tc::span_t<Rng>;
-		};
-
-		template<typename Rng0, typename Rng1>
-		struct common_span_impl<Rng0, Rng1, tc::void_t<tc::span_t<Rng0>, tc::span_t<Rng1>>> final: common_span_impl_base<tc::span_t<Rng0>, tc::span_t<Rng1>> {};
-
-		template<typename Rng0, typename Rng1>
-		using common_span_impl_t = typename common_span_impl<Rng0, Rng1>::type;
-
-		template<typename... T>
-		using common_span_t = tc::type::accumulate_with_front_t<tc::type::list<T...>, common_span_impl_t>;
-
-		// tc::common_reference_xvalue_as_ref_t customization tc::subrange: If
-		//		1. the base ranges (whole_range_t) have a tc::common_reference_xvalue_as_ref which is an lvalue reference,
-		// the result type is tc::make_subrange_result_t<tc::common_reference_xvalue_as_ref<base ranges...>>
-		template<typename... T>
-		concept has_common_subrange_lvalue_reference =
-			(tc::instance<std::remove_reference_t<T>, tc::subrange> || ...)
-			&& std::is_lvalue_reference<
-				tc::common_reference_xvalue_as_ref_t<subrange_detail::whole_range_t<T>...>
-			>::value;
-
-		template<typename... T> requires (!has_actual_common_reference<T...>) && has_common_subrange_lvalue_reference<T...>
-		struct common_reference_xvalue_as_ref<T...> final {
-			using type = tc::make_subrange_result_t<tc::common_reference_xvalue_as_ref_t<subrange_detail::whole_range_t<T>...>>;
-		};
-
-		// tc::common_reference_xvalue_as_ref_t customization tc::span: If
-		//		1. all input ranges are tc::safely_convertible_to tc::span and,
-		//		2. those tc::span(s) has_common_span,
-		// the result type is common_span_t. 
-		template<typename... T>
-			requires (!has_actual_common_reference<T...>)
-				&& (!has_common_subrange_lvalue_reference<T...>)
-				&& requires { typename common_span_t<T...>; }
-		struct common_reference_xvalue_as_ref<T...> final {
-			using type = common_span_t<T...>;
-		};
-	}
-
-	//-------------------------------------------------------------------------------------------------------------------------
-	// as_span
 	// get a consecutive block of memory from range and return an iterator_range of pointers
-
 	template<tc::contiguous_range Rng>
 	[[nodiscard]] constexpr auto as_span(Rng&& rng) noexcept 
 		-> tc::span_t<Rng&&>
@@ -1589,130 +894,58 @@ namespace tc {
 		return std::forward<Rng>(rng);
 	}
 
-
-	//--------------------------------------------------------------------------------------------------------------------------
-	// as_blob
-	// reinterprets a range of items as a range of bytes
-
-	// We use unsigned char for uninterpreted memory.
-	// - The type used must support aliasing, so the only candidates are char, signed char and unsigned char.
-	// - char is bad because we interpret char as UTF-8 and char* as zero-terminated range.
-	// - unsigned char is better than signed char because the binary representation of signs may vary between platforms.
-	// - char is bad because it is either signed or unsigned, so it has the same problem.
-	// - unsigned char is better than std::uint8_t because the latter must be 8 bit, but we mean the smallest addressable unit, which is char and may be larger (or smaller?) on other platforms.
-
-	static_assert(!tc::range_with_iterators< void const* >);
-
-	template<typename T>
-	[[nodiscard]] constexpr auto single(T&& t) noexcept;
-
-	template<tc::contiguous_range Rng>
-	[[nodiscard]] auto range_as_blob(Rng&& rng) noexcept {
-		using cv_value_type = std::remove_pointer_t<decltype(tc::ptr_begin(rng))>;
-		static_assert( std::is_trivially_copyable< cv_value_type >::value, "as_blob only works on std::is_trivially_copyable types" );
-		if constexpr(tc::safely_constructible_from<tc::span<cv_value_type>, Rng>) {
-			return tc::make_iterator_range(
-				reinterpret_cast<same_cvref_t<unsigned char, cv_value_type>*>(tc::ptr_begin(rng)),
-				reinterpret_cast<same_cvref_t<unsigned char, cv_value_type>*>(tc::ptr_end(rng))
-			);
-		} else {
-			// not inside blob_range_t because templates cannot be declared inside of a local class
-			static auto constexpr as_blob_ptr=[](auto ptr) noexcept {
-				return reinterpret_cast<same_cvref_t<unsigned char, std::remove_pointer_t<decltype(ptr)>>*>(ptr);
-			};
-			struct blob_range_t final {
-				explicit blob_range_t(Rng&& rng) noexcept : m_rng(tc_move(rng)) {}
-				auto begin() & noexcept { return as_blob_ptr(tc::ptr_begin(m_rng)); }
-				auto begin() const& noexcept { return as_blob_ptr(tc::ptr_begin(m_rng)); }
-				auto end() & noexcept { return as_blob_ptr(tc::ptr_end(m_rng)); }
-				auto end() const& noexcept { return as_blob_ptr(tc::ptr_end(m_rng)); }
-			private:
-				static_assert(!std::is_reference<Rng>::value);
-				std::remove_cv_t<Rng> m_rng;
-			public:
-				using iterator=decltype(as_blob_ptr(tc::ptr_begin(m_rng)));
-				using const_iterator=decltype(as_blob_ptr(tc::ptr_begin(tc::as_const(m_rng))));
-			};
-			return blob_range_t(tc_move(rng));
-		}
-	}
-
+	//-------------------------------------------------------------------------------------------------------------------------
+	// range common reference
 	namespace no_adl {
-		template<typename Sink>
-		struct range_as_blob_sink { // no final: verify_sink_result_impl derives
-		private:
-			// range_as_blob_sink is only used inline in range_as_blob below, and m_sink is only passed to tc::for_each, so holding by lvalue reference ok
-			Sink& m_sink;
-
-		public:
-			explicit range_as_blob_sink(Sink& sink) noexcept: m_sink(sink) {}
+		template <typename It, typename TSource>
+		struct is_class_safely_constructible<tc::subrange<tc::universal_range<It>>, TSource> final
+			: tc::constant<
+				std::is_same<tc::decay_t<TSource>, tc::empty_range>::value ||
+				tc::borrowed_range<TSource>
+			>
+		{};
 
-			// chunk must be defined before operator() - otherwise MSVC will not allow it to occur in the return type of operator()
-			template<tc::contiguous_range Rng>
-			auto chunk(Rng&& rng) const& return_decltype_MAYTHROW (
-				tc::for_each(tc::range_as_blob(tc_move_if_owned(rng)), m_sink)
-			)
+		template <typename Rng1, typename Rng2>
+		struct common_iterator_range_impl {};
 
-			template<typename T>
-			auto operator()(T&& t) const& return_decltype_MAYTHROW (
-				chunk(tc::single(/* no std::forward<T> */ t))
-			)
+		// Rng have common iterator
+		template <typename Rng1, typename Rng2>
+			requires tc::safely_constructible_from<tc::iterator_range<tc::common_type_t<tc::iterator_t<Rng1>, tc::iterator_t<Rng2>>>, Rng1>
+				&& tc::safely_constructible_from<tc::iterator_range<tc::common_type_t<tc::iterator_t<Rng1>, tc::iterator_t<Rng2>>>, Rng2>
+		struct common_iterator_range_impl<Rng1, Rng2> {
+			using type = tc::iterator_range<tc::common_type_t<tc::iterator_t<Rng1>, tc::iterator_t<Rng2>>>;
 		};
-	}
-
-	template<typename Rng>
-	[[nodiscard]] auto range_as_blob(Rng&& rng) noexcept {
-		return [rng=tc::make_reference_or_value(tc_move_if_owned(rng))](auto&& sink) MAYTHROW {
-			return tc::for_each(*rng, no_adl::range_as_blob_sink<std::remove_reference_t<decltype(sink)>>(sink));
+		// Rng have common pointer iterator
+		template <typename Rng1, typename Rng2>
+			requires (!requires { typename tc::common_type_t<tc::iterator_t<Rng1>, tc::iterator_t<Rng2>>; })
+				&& tc::safely_constructible_from<tc::iterator_range<tc::common_type_t<tc::ptr_iterator_t<Rng1>, tc::ptr_iterator_t<Rng2>>>, Rng1>
+				&& tc::safely_constructible_from<tc::iterator_range<tc::common_type_t<tc::ptr_iterator_t<Rng1>, tc::ptr_iterator_t<Rng2>>>, Rng2>
+		struct common_iterator_range_impl<Rng1, Rng2> {
+			using type = tc::iterator_range<tc::common_type_t<tc::ptr_iterator_t<Rng1>, tc::ptr_iterator_t<Rng2>>>;
 		};
-	}
-
-	template<typename T> requires std::is_trivially_copyable<std::remove_reference_t<T>>::value
-	[[nodiscard]] auto as_blob(T&& t) noexcept {
-		return tc::range_as_blob( tc::single( std::forward<T>(t) ) );
-	}
 
-	namespace assert_no_overlap_impl {
-		void assert_no_overlap(auto const& lhs, auto const& rhs) noexcept {
-			_ASSERT(
-				reinterpret_cast<std::size_t>(tc::ptr_end(lhs)) <= reinterpret_cast<std::size_t>(tc::ptr_begin(rhs)) ||
-				reinterpret_cast<std::size_t>(tc::ptr_end(rhs)) <= reinterpret_cast<std::size_t>(tc::ptr_begin(lhs))
-			);
-		}
-	}
-	template< typename Lhs, typename Rhs>
-	void assert_no_overlap(Lhs const& lhs, Rhs const& rhs) noexcept {
-		assert_no_overlap_impl::assert_no_overlap(tc::single(lhs), tc::single(rhs));
-		if constexpr( tc::contiguous_range<Lhs> && tc::contiguous_range<Rhs> ) {
-			assert_no_overlap_impl::assert_no_overlap(lhs, rhs);
-		}
-	}
+		// special case: empty_range
+		template <typename Rng>
+			requires requires { typename tc::iterator_range_t<Rng>; }
+		struct common_iterator_range_impl<Rng, tc::empty_range> {
+			using type = tc::iterator_range_t<Rng>;
+		};
+		template <typename Rng>
+			requires requires { typename tc::iterator_range_t<Rng>; }
+		struct common_iterator_range_impl<tc::empty_range, Rng> {
+			using type = tc::iterator_range_t<Rng>;
+		};
 
-#ifdef _CHECKS
-	namespace no_adl {
-		template< typename Rng >
-		struct SSinglePassRange : tc::noncopyable {
-			explicit SSinglePassRange(Rng&& rng) noexcept
-			: m_rng(tc_move(rng)) {}
-			template< typename Sink >
-			constexpr auto operator()(Sink&& sink) && MAYTHROW {
-				_ASSERTE( tc::change(m_bFirstPass, false) );
-				return tc::for_each(tc_move(m_rng), std::forward<Sink>(sink));
-			}
+		template <typename Rng1, typename Rng2>
+		using common_iterator_range_impl_t = typename common_iterator_range_impl<Rng1, Rng2>::type;
+		template <typename... T>
+		using common_iterator_range_t = tc::type::accumulate_with_front_t<tc::type::list<T...>, common_iterator_range_impl_t>;
 
-			Rng m_rng;
-			bool mutable m_bFirstPass = true;
+		// If the Ts have a common iterator range, that is their common reference.
+		template <typename ... T>
+			requires (!tc::has_actual_common_reference<T...>) && requires { typename common_iterator_range_t<T...>; }
+		struct common_reference_xvalue_as_ref<T...> final {
+			using type = common_iterator_range_t<T...>;
 		};
 	}
-
-	template< typename Rng >
-	auto assert_single_pass(Rng&& rng) noexcept {
-		return no_adl::SSinglePassRange<Rng>(tc_move(rng)); // Disallow lvalue references.
-	}
-#else
-	template< typename Rng >
-	decltype(auto) assert_single_pass(Rng&& rng) noexcept {
-		return std::forward<Rng>(rng);
-	}
-#endif
 }
diff --git a/tc/range/subrange.t.cpp b/tc/range/subrange.t.cpp
index dec499e..3766fe2 100644
--- a/tc/range/subrange.t.cpp
+++ b/tc/range/subrange.t.cpp
@@ -11,33 +11,40 @@
 #include "../container/container.h" // tc::vector
 #include "../interval.h"
 #include "subrange.h"
+#include "range_return.h"
 #include "union_adaptor.h"
 #include "unique_range_adaptor.h"
 #include "intersection_adaptor.h"
 
 #include <type_traits>
+#include <string_view> // for test only
 
 namespace {
+	// non-borrowed ranges are subranges
+	STATICASSERTSAME(tc::make_subrange_result_t<std::string>, tc::subrange<std::string>);
+	// borrowed range are iterator_ranges
+	STATICASSERTSAME(tc::make_subrange_result_t<std::string&>, tc::iterator_range_t<std::string&>);
+	STATICASSERTSAME(tc::make_subrange_result_t<std::string_view>, tc::iterator_range_t<std::string_view>);
+	STATICASSERTSAME(tc::make_subrange_result_t<std::string_view&>, tc::iterator_range_t<std::string_view>);
+	// unwrapping
+	STATICASSERTSAME(tc::make_subrange_result_t<tc::subrange<std::string>>, tc::subrange<std::string>);
+	STATICASSERTSAME(tc::make_subrange_result_t<tc::subrange<std::string>&>, tc::iterator_range_t<std::string&>);
+	STATICASSERTSAME(tc::make_subrange_result_t<tc::span<char const>>, tc::span<char const>);
 	STATICASSERTSAME(tc::make_subrange_result_t<tc::span<char const>&>, tc::span<char const>);
 
-	using SRVI = tc::make_subrange_result_t<tc::vector<int>&>;
-	using CSRVI = tc::make_subrange_result_t<tc::vector<int> const&>;
-
-	using SSRVI = tc::make_subrange_result_t<tc::make_subrange_result_t<tc::vector<int>&>>;
-	using CSSRVI = tc::make_subrange_result_t<tc::make_subrange_result_t<tc::vector<int> const&>>;
 
 	UNITTESTDEF( subrange_array ) {
 
 		int arr[4] = {1,2,3,4};
 		auto arr_rng = tc::slice_by_interval(arr, tc::make_interval(1, 3));
 
-		void(tc::implicit_cast<tc::subrange<tc::iterator_base<int *>>>(arr_rng));
-		void(tc::implicit_cast<tc::subrange<tc::iterator_base<int const*>>>(arr_rng));
+		void(tc::implicit_cast<tc::subrange<tc::universal_range<int *>>>(arr_rng));
+		void(tc::implicit_cast<tc::subrange<tc::universal_range<int const*>>>(arr_rng));
 	}
 
 
 	UNITTESTDEF( const_subrange_char_ptr ) {
-		tc::subrange<tc::iterator_base<char const*>>{"test"};
+		tc::subrange<tc::universal_range<char const*>>{"test"};
 	}
 
 	//-------------------------------------------------------------------------------------------------------------------------
@@ -57,8 +64,8 @@ namespace {
 
 	UNITTESTDEF( const_subrange ) {
 		tc::vector<int> v;
-		auto srvi = tc::slice(v);
-		auto csrvi = tc::slice(tc::as_const(v));
+		auto srvi = tc::all(v);
+		auto csrvi = tc::all(tc::as_const(v));
 
 		(void) srvi;
 		(void) csrvi;
@@ -73,11 +80,11 @@ namespace {
 
 		tc::vector<int> v;
 
-		auto srvi = tc::slice(v);
-		auto csrvi = tc::slice(tc::as_const(v));
+		auto srvi = tc::all(v);
+		auto csrvi = tc::all(tc::as_const(v));
 
-		auto ssrvi = tc::slice(tc::slice(v));
-		auto cssrvi = tc::slice(tc::slice(tc::as_const(v)));
+		auto ssrvi = tc::all(tc::all(v));
+		auto cssrvi = tc::all(tc::all(tc::as_const(v)));
 
 		STATICASSERTSAME(decltype(ssrvi), decltype(srvi), "Sub-sub-range does not flatten to sub-range (decltype)");
 		STATICASSERTSAME(decltype(cssrvi), decltype(csrvi), "const sub-sub-range does not flatten to const sub-range (decltype)");
@@ -87,11 +94,11 @@ namespace {
 
 		tc::vector<int> v;
 
-		auto srvi = tc::slice(v);
-		auto csrvi = tc::slice(tc::as_const(v));
+		auto srvi = tc::all(v);
+		auto csrvi = tc::all(tc::as_const(v));
 
-		auto ssrvi = tc::slice(srvi);
-		auto cssrvi = tc::slice(csrvi);
+		auto ssrvi = tc::all(srvi);
+		auto cssrvi = tc::all(csrvi);
 
 		// sanity checks
 		STATICASSERTSAME(decltype(srvi), SRVI, "make_subrange_result gives wrong result");
@@ -109,8 +116,8 @@ namespace {
 		TEST_init_hack(tc::vector, int, v, {1,2,3,4,5,6,7,8,9});
 		TEST_init_hack(tc::vector, int, exp36, {4,5,6});
 
-		auto sr = tc::slice(v);
-		auto csr = tc::slice(tc::as_const(v));
+		auto sr = tc::all(v);
+		auto csr = tc::all(tc::as_const(v));
 
 		// use range_difference to specify bounds
 		auto ssr1 = tc::slice_by_interval(sr, tc::make_interval(3, 6));
@@ -121,41 +128,29 @@ namespace {
 
 	}
 
-	UNITTESTDEF( sub_subrange_crazy_manual ) {
-
-		tc::vector<int> v;
-
-		// don't try that at work! - Seriously: subrange is build to work correctly in a variety of situations,
-		// but normally it should not be necessary to manually utter the type. Use slice and make_subrange_result instead.
-		// if you do need to say the type (e.g. when deducting sth.)  ...
-		//_ASSERT(false);
-		tc::subrange<tc::vector<int>&>{v}; // create a sub range from unrelated range
-		static_cast<void>(tc::subrange<tc::vector<int>&>(tc::subrange<tc::vector<int>&>(v))); // copy sub range
-	}
-
 	UNITTESTDEF(union_range_tests) {
 		TEST_RANGE_EQUAL(
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4)),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4)),
 			tc::union_range(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,4)),
-				as_constexpr(tc::make_array(tc::aggregate_tag, 2,3))
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,4)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 2,3))
 			)
 		);
 
 		TEST_RANGE_EQUAL(
-			as_constexpr(tc::make_array(tc::aggregate_tag, 4,3,2,1,0)),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 4,3,2,1,0)),
 			tc::union_range(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 4,2,0)),
-				as_constexpr(tc::make_array(tc::aggregate_tag, 3,2,1)),
-				[](int lhs, int rhs) noexcept {return tc::compare(rhs,lhs);}
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 4,2,0)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 3,2,1)),
+				[](int const lhs, int const rhs) noexcept {return tc::compare(rhs,lhs);}
 			)
 		);
 
 		_ASSERTEQUAL(
 			*tc::upper_bound<tc::return_border>(
 				tc::union_range(
-					as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,4)),
-					as_constexpr(tc::make_array(tc::aggregate_tag, 2,3))
+					tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,4)),
+					tc_as_constexpr(tc::make_array(tc::aggregate_tag, 2,3))
 				),
 				2
 			),
@@ -164,13 +159,13 @@ namespace {
 
 		{
 			auto rng = tc::union_range(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,3,4,4,5)),
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,1,1,3,4,4,4))
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,3,4,4,5)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,1,1,3,4,4,4))
 			);
 
 			TEST_RANGE_EQUAL(
 				rng,
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,1,1,2,3,3,4,4,4,5))
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,1,1,2,3,3,4,4,4,5))
 			);
 
 			{
@@ -189,8 +184,8 @@ namespace {
 		}
 		{
 			auto rng = tc::union_range(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,1,1,1,1,1,1,1,1)),
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,1))
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,1,1,1,1,1,1,1,1)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,1))
 			);
 			auto it = tc::lower_bound<tc::return_border>(rng,1);
 			_ASSERTEQUAL(*it,1);
@@ -199,7 +194,7 @@ namespace {
 
 	UNITTESTDEF(union_range_generator) {
 		TEST_RANGE_EQUAL(
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,5,6)),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,5,6)),
 			tc::union_range(
 				[](auto sink) noexcept -> tc::break_or_continue {
 					tc_yield(sink, 1);
@@ -207,7 +202,7 @@ namespace {
 					tc_yield(sink, 5);
 					return tc::continue_;
 				},
-				as_constexpr(tc::make_array(tc::aggregate_tag, 2,6))
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 2,6))
 			)
 		);
 
@@ -221,7 +216,7 @@ namespace {
 		);
 
 		TEST_RANGE_EQUAL(
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1.1,3.1,5.1)),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1.1,3.1,5.1)),
 			vecf
 		);
 	}
@@ -229,25 +224,25 @@ namespace {
 	UNITTESTDEF(subrange_with_tranform) {
 
 		tc::vector<int> vecn{1,2,3};
-		auto rgntrnsfn = tc::transform(vecn, [](int n) noexcept {return n*n;});
+		auto rgntrnsfn = tc::transform(vecn, [](int const n) noexcept {return n*n;});
 
 		TEST_RANGE_EQUAL(
 			tc::slice(rgntrnsfn, tc::begin(rgntrnsfn), tc::end(rgntrnsfn)),
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,4,9))
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,4,9))
 		);
 
 		TEST_RANGE_EQUAL(
-			as_constexpr(tc::make_array(tc::aggregate_tag,  1, 2, 3 )),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag,  1, 2, 3 )),
 			tc::untransform(tc::slice(rgntrnsfn, tc::begin(rgntrnsfn), tc::end(rgntrnsfn)))
 		);
 
 		TEST_RANGE_EQUAL(
 			tc::single(2),
-			tc::untransform(tc::equal_range(tc::transform(vecn, [](int n) noexcept {return n*n; }), 4))
+			tc::untransform(tc::equal_range(tc::transform(vecn, [](int const n) noexcept {return n*n; }), 4))
 		);
 
 		{
-			auto rng = tc::transform(tc::filter(vecn, [](int n) noexcept {return n<3;}), [](int n) noexcept {return n*n; });
+			auto rng = tc::transform(tc::filter(vecn, [](int const n) noexcept {return n<3;}), [](int const n) noexcept {return n*n; });
 
 			TEST_RANGE_EQUAL(
 				tc::single(2),
@@ -257,44 +252,44 @@ namespace {
 
 		{
 			// r-value transform with l-value range
-			auto&& rng = tc::untransform(tc::transform(vecn, [](int n) noexcept {return n*n;}));
+			auto&& rng = tc::untransform(tc::transform(vecn, [](int const n) noexcept {return n*n;}));
 			_ASSERTEQUAL(tc::size(vecn), 3);
 			_ASSERTEQUAL(std::addressof(*tc::begin(rng)), std::addressof(*tc::begin(vecn)));
 			static_assert(std::is_lvalue_reference<decltype(rng)>::value);
 			// rewrite the following line to ::value once VC++ compiler bug is resolved https://developercommunity.visualstudio.com/content/problem/1088659/class-local-to-function-template-erroneously-cant.html
 			static_assert(!std::is_const_v<std::remove_reference_t<decltype(rng)>>);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
 
 		{
 			// r-value transform with l-value const range
-			auto&& rng = tc::untransform(tc::transform(tc::as_const(vecn), [](int n) noexcept {return n*n;}));
+			auto&& rng = tc::untransform(tc::transform(tc::as_const(vecn), [](int const n) noexcept {return n*n;}));
 			_ASSERTEQUAL(tc::size(vecn), 3);
 			_ASSERTEQUAL(std::addressof(*tc::begin(rng)), std::addressof(*tc::begin(vecn)));
 			static_assert(std::is_lvalue_reference<decltype((rng))>::value);
 			static_assert(std::is_const<std::remove_reference_t<decltype(rng)>>::value);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
 
 		{
 			// r-value transform with r-value range
-			auto rng = tc::untransform(tc::transform(tc::vector<int>{1, 2, 3}, [](int n) noexcept {return n*n;}));
+			auto rng = tc::untransform(tc::transform(tc::vector<int>{1, 2, 3}, [](int const n) noexcept {return n*n;}));
 			STATICASSERTSAME(decltype(rng),tc::vector<int>);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
 
 		{
 			// l-value transform of l-value-range
-			auto trnsfrng = tc::transform(vecn, [](int n) noexcept {return n*n;});
+			auto trnsfrng = tc::transform(vecn, [](int const n) noexcept {return n*n;});
 
 			auto&& rng = tc::untransform(trnsfrng);
 			_ASSERTEQUAL(tc::size(vecn), 3);
@@ -303,14 +298,14 @@ namespace {
 			// rewrite the following line to ::value once VC++ compiler bug is resolved https://developercommunity.visualstudio.com/content/problem/1088659/class-local-to-function-template-erroneously-cant.html
 			static_assert(!std::is_const_v<std::remove_reference_t<decltype(rng)>>);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
 
 		{
 			// l-value transform of const l-value-range
-			auto const trnsfrng = tc::transform(tc::as_const(vecn), [](int n) noexcept {return n*n;});
+			auto const trnsfrng = tc::transform(tc::as_const(vecn), [](int const n) noexcept {return n*n;});
 
 			auto&& rng = tc::untransform(trnsfrng);
 			_ASSERTEQUAL(tc::size(vecn), 3);
@@ -318,14 +313,14 @@ namespace {
 			static_assert(std::is_lvalue_reference<decltype(rng)>::value);
 			static_assert(std::is_const<std::remove_reference_t<decltype(rng)>>::value);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
 
 		{
 			// l-value transform of const l-value-range
-			auto trnsfrng = tc::transform(tc::as_const(vecn), [](int n) noexcept {return n*n;});
+			auto trnsfrng = tc::transform(tc::as_const(vecn), [](int const n) noexcept {return n*n;});
 
 			auto&& rng = tc::untransform(trnsfrng);
 			_ASSERTEQUAL(tc::size(vecn), 3);
@@ -333,14 +328,14 @@ namespace {
 			static_assert(std::is_lvalue_reference<decltype(rng)>::value);
 			static_assert(std::is_const<std::remove_reference_t<decltype(rng)>>::value);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
 
 		{
 			// l-value transform of r-value range
-			auto trnsfrng = tc::transform(tc::vector<int>{1, 2, 3}, [](int n) noexcept {return n*n; });
+			auto trnsfrng = tc::transform(tc::vector<int>{1, 2, 3}, [](int const n) noexcept {return n*n; });
 			auto&& rng = tc::untransform(trnsfrng);
 			_ASSERTEQUAL(
 				std::addressof(*tc::begin(trnsfrng).element_base()),
@@ -350,13 +345,13 @@ namespace {
 			// rewrite the following line to ::value once VC++ compiler bug is resolved https://developercommunity.visualstudio.com/content/problem/1088659/class-local-to-function-template-erroneously-cant.html
 			static_assert(!std::is_const_v<std::remove_reference_t<decltype(rng)>>);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
 		{
 			// const l-value transform of r-value range
-			auto const trnsfrng = tc::transform(tc::vector<int>{1, 2, 3}, [](int n) noexcept {return n*n; });
+			auto const trnsfrng = tc::transform(tc::vector<int>{1, 2, 3}, [](int const n) noexcept {return n*n; });
 			auto&& rng = tc::untransform(trnsfrng);
 			_ASSERTEQUAL(
 				std::addressof(*tc::begin(trnsfrng).element_base()),
@@ -365,7 +360,7 @@ namespace {
 			static_assert(std::is_lvalue_reference<decltype(rng)>::value);
 			static_assert(std::is_const<std::remove_reference_t<decltype(rng)>>::value);
 			TEST_RANGE_EQUAL(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3)),
 				rng
 			);
 		}
@@ -421,7 +416,7 @@ namespace {
 
 		}
 
-		auto Pred = [](int lhs, int rhs) noexcept {
+		auto const Pred = [](int const lhs, int const rhs) noexcept {
 			return std::abs(lhs-rhs) <=1;
 		};
 
@@ -464,19 +459,19 @@ namespace {
 	UNITTESTDEF(difference_range) {
 		TEST_RANGE_EQUAL(
 			tc::difference(
-				as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,4,7,8,8,11,11)),
-				as_constexpr(tc::make_array(tc::aggregate_tag, 2,3,4,8,8))
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,4,7,8,8,11,11)),
+				tc_as_constexpr(tc::make_array(tc::aggregate_tag, 2,3,4,8,8))
 			),
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,7,11,11))
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,7,11,11))
 		);
 	}
 
 	UNITTESTDEF(difference_unordered_set) {
 		tc::unordered_set<int> setn1;
-		tc::cont_assign(setn1, as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4,5,6,7,8,9,10,11)));
+		tc::cont_assign(setn1, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4,5,6,7,8,9,10,11)));
 
 		tc::unordered_set<int> setn2;
-		tc::cont_assign(setn2, as_constexpr(tc::make_array(tc::aggregate_tag, 10,9,8,7,6,5,4,3,2,1)));
+		tc::cont_assign(setn2, tc_as_constexpr(tc::make_array(tc::aggregate_tag, 10,9,8,7,6,5,4,3,2,1)));
 
 		TEST_RANGE_EQUAL(
 			tc::set_difference(setn1, setn2),
@@ -484,47 +479,47 @@ namespace {
 		);
 
 		tc::vector<int> vecn;
-		tc::for_each(tc::set_intersect(setn1, setn2), [&](int n) noexcept {
+		tc::for_each(tc::set_intersect(setn1, setn2), [&](int const n) noexcept {
 			vecn.emplace_back(n);
 		});
 
 		TEST_RANGE_EQUAL(
 			tc::sort(vecn),
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4,5,6,7,8,9,10))
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4,5,6,7,8,9,10))
 		);
 	}
 
 	UNITTESTDEF(tc_unique) {
 		TEST_RANGE_EQUAL(
-			tc::adjacent_unique(as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,4,7,8,8,11,11))),
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,4,7,8,11))
+			tc::adjacent_unique(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,4,7,8,8,11,11))),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,4,7,8,11))
 		);
 
 		TEST_RANGE_EQUAL(
-			tc::reverse(tc::adjacent_unique(as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,4,7,8,8,11,11)))),
-			as_constexpr(tc::make_array(tc::aggregate_tag, 11,8,7,4,2,1))
+			tc::reverse(tc::adjacent_unique(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,4,7,8,8,11,11)))),
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 11,8,7,4,2,1))
 		);
 
 		TEST_RANGE_EQUAL(
 			tc::transform(
 				tc::adjacent_unique(
-					tc::make_range_of_iterators(as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,3,3,3,4,7,8,8,11,11))),
+					tc::make_range_of_iterators(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,3,3,3,4,7,8,8,11,11))),
 					tc::projected(tc::fn_equal_to(), tc::fn_indirection())
 				),
 				tc::fn_indirection()
 			),
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4,7,8,11))
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4,7,8,11))
 		);
 
 		TEST_RANGE_EQUAL(
 			tc::transform(
 				tc::reverse(tc::adjacent_unique(
-					tc::make_range_of_iterators(as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,3,3,3,4,7,8,8,11,11))),
+					tc::make_range_of_iterators(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,2,3,3,3,4,7,8,8,11,11))),
 					tc::projected(tc::fn_equal_to(), tc::fn_indirection())
 				)),
 				tc::fn_indirection()
 			),
-			as_constexpr(tc::make_array(tc::aggregate_tag, 11,8,7,4,3,2,1))
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 11,8,7,4,3,2,1))
 		);
 
 		tc::vector<int> vecn{1,1,2,2};
@@ -584,7 +579,7 @@ namespace {
 
 		TEST_RANGE_EQUAL(
 			vecmn,
-			as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4))
+			tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2,3,4))
 		);
 	}
 
@@ -595,7 +590,7 @@ namespace {
 
 		_ASSERTEQUAL(tc::for_each(tc::begin_next<tc::return_take>(rngn), [](int) noexcept {}), tc::continue_);
 		_ASSERTEQUAL(tc::for_each(tc::begin_next<tc::return_take>(rngn), [](int) noexcept { return tc::break_; }), tc::break_);
-		_ASSERT(tc::equal(as_constexpr(tc::make_array(tc::aggregate_tag, 0,1,2,3)), tc::begin_next<tc::return_take>(rngn, 4)));
+		_ASSERT(tc::equal(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 0,1,2,3)), tc::begin_next<tc::return_take>(rngn, 4)));
 
 		auto rngch = tc::concat("123", [](auto&& sink) noexcept { return tc::for_each("456", tc_move_if_owned(sink)); });
 
@@ -615,7 +610,7 @@ namespace {
 
 		_ASSERTEQUAL(tc::for_each(tc::begin_next<tc::return_drop>(rngn), [](int) noexcept {}), tc::continue_);
 		_ASSERTEQUAL(tc::for_each(tc::begin_next<tc::return_drop>(rngn), [](int) noexcept { return tc::break_; }), tc::break_);
-		_ASSERT(tc::equal(as_constexpr(tc::make_array(tc::aggregate_tag, 4,5,6)), tc::begin_next<tc::return_drop>(rngn, 4)));
+		_ASSERT(tc::equal(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 4,5,6)), tc::begin_next<tc::return_drop>(rngn, 4)));
 
 		auto rngch = tc::begin_next<tc::return_drop>(tc::concat("123", [](auto&& sink) noexcept { return tc::for_each("456", tc_move_if_owned(sink)); }), 2);
 
@@ -655,7 +650,7 @@ namespace {
 #endif
 
 	UNITTESTDEF(and_then) {
-		auto const fn=[](auto n) noexcept {return n+1;};
+		auto const fn=[](auto const n) noexcept {return n+1;};
 		std::optional<int> on(12);
 
 		auto n1=tc::and_then(on, fn);
diff --git a/tc/range/take_while.h b/tc/range/take_while.h
index 5a510d3..35cf5de 100644
--- a/tc/range/take_while.h
+++ b/tc/range/take_while.h
@@ -12,13 +12,16 @@
 #include "../base/tc_move.h"
 #include "../base/conditional.h"
 #include "../base/invoke.h"
+#include "../base/trivial_functors.h"
 
 #include "range_adaptor.h"
 #include "meta.h"
-#include "range_fwd.h"
 
 namespace tc {
 	namespace no_adl {
+		template< typename Pred, typename Rng, bool HasIterator=tc::range_with_iterators< Rng > >
+		struct take_while_adaptor;
+
 		template< typename Pred, typename Rng >
 		struct [[nodiscard]] take_while_adaptor<Pred, Rng, false> : tc::range_adaptor_base_range<Rng>, tc::range_output_from_base_range {
 		protected:
@@ -55,7 +58,7 @@ namespace tc {
 		struct [[nodiscard]] take_while_adaptor<Pred, Rng, true>
 			: tc::index_range_adaptor<
 				take_while_adaptor<Pred, Rng, true>,
-				Rng,
+				Rng, tc::index_range_adaptor_flags::inherit_begin | tc::index_range_adaptor_flags::inherit_behavior,
 				take_while_adaptor<Pred, Rng, false>
 			>
 		{
@@ -73,7 +76,7 @@ namespace tc {
 			STATIC_FINAL_MOD(constexpr, end_index)() const& = delete;  // let range_iterator_from_index::end return end_sentinel
 
 			STATIC_FINAL_MOD(constexpr, at_end_index)(tc_index const& idx) const& return_MAYTHROW(
-				this->template at_end_index<base_>(idx) || !tc::invoke(this->m_pred, tc::as_const(this->dereference_index(idx)))
+				tc::at_end_index(this->base_range(), idx) || !tc::invoke(this->m_pred, tc::as_const(this->dereference_index(idx)))
 			)
 
 		public:
@@ -82,13 +85,12 @@ namespace tc {
 			}
 		};
 	}
+	using no_adl::take_while_adaptor;
+
+	template<typename Pred, typename Rng>
+	constexpr auto enable_stable_index_on_move<tc::take_while_adaptor<Pred, Rng, true>> = tc::stable_index_on_move<Rng>;
 
 	template<typename Rng, typename Pred = tc::identity>
 	constexpr auto take_while(Rng&& rng, Pred&& pred = Pred())
-		return_ctor_noexcept( TC_FWD( take_while_adaptor<tc::decay_t<Pred>, Rng>), (std::forward<Rng>(rng),std::forward<Pred>(pred)) )
-
-	namespace no_adl {
-		template<typename Pred, typename Rng>
-		struct is_index_valid_for_move_constructed_range<tc::take_while_adaptor<Pred, Rng, true>>: tc::is_index_valid_for_move_constructed_range<Rng> {};
-	}
+		return_ctor_noexcept( TC_FWD( tc::take_while_adaptor<tc::decay_t<Pred>, Rng>), (std::forward<Rng>(rng),std::forward<Pred>(pred)) )
 }
diff --git a/tc/range/transform.t.cpp b/tc/range/transform.t.cpp
index 12f4255..5c8ce63 100644
--- a/tc/range/transform.t.cpp
+++ b/tc/range/transform.t.cpp
@@ -28,24 +28,12 @@ namespace {
 		auto anNativeTrans = tc::make_array(tc::transform(anNative, tc::identity()));
 		auto anTcTrans = tc::make_array(tc::transform(anTc, tc::identity()));
 
-		static_assert(
-			tc::constexpr_size<decltype(anTc)>::value==
-			tc::constexpr_size<decltype(anNative)>::value
-		);
-		static_assert(
-			tc::constexpr_size<decltype(anTc2)>::value==
-			tc::constexpr_size<decltype(anNative)>::value
-		);
-		static_assert(
-			tc::constexpr_size<decltype(anNativeTrans)>::value==
-			tc::constexpr_size<decltype(anNative)>::value
-		);
-		static_assert(
-			tc::constexpr_size<decltype(anTcTrans)>::value==
-			tc::constexpr_size<decltype(anNative)>::value
-		);
+		static_assert( tc::constexpr_size<decltype(anTc)>() == tc::constexpr_size<decltype(anNative)>() );
+		static_assert( tc::constexpr_size<decltype(anTc2)>() == tc::constexpr_size<decltype(anNative)>() );
+		static_assert( tc::constexpr_size<decltype(anNativeTrans)>() == tc::constexpr_size<decltype(anNative)>() );
+		static_assert( tc::constexpr_size<decltype(anTcTrans)>() == tc::constexpr_size<decltype(anNative)>() );
 
-		auto rngnoncopy = tc::transform(as_constexpr(tc::make_array(tc::aggregate_tag, 1,2)), [](int) noexcept {
+		auto rngnoncopy = tc::transform(tc_as_constexpr(tc::make_array(tc::aggregate_tag, 1,2)), [](int) noexcept {
 			struct NonCopyNonMoveable final {
 				NonCopyNonMoveable(NonCopyNonMoveable const&) = delete;
 				NonCopyNonMoveable(NonCopyNonMoveable&&) = delete;
diff --git a/tc/range/transform_adaptor.h b/tc/range/transform_adaptor.h
index 94b50bc..3b37fe5 100644
--- a/tc/range/transform_adaptor.h
+++ b/tc/range/transform_adaptor.h
@@ -10,7 +10,6 @@
 
 #include "../base/assert_defs.h"
 #include "../base/tc_move.h"
-#include "range_fwd.h"
 
 #include "range_adaptor.h"
 #include "subrange.h"
@@ -35,6 +34,9 @@ namespace tc {
 	}
 
 	namespace transform_adaptor_adl {
+		template< typename Func, typename Rng, bool HasIterator=tc::range_with_iterators< Rng > >
+		struct transform_adaptor;
+
 		template< typename Func, typename Rng >
 		struct [[nodiscard]] transform_adaptor<Func,Rng,false> : tc::generator_range_adaptor<Rng> {
 		protected:
@@ -49,8 +51,8 @@ namespace tc {
 				, m_func(std::forward<FuncOther>(func))
 			{}
 
-			constexpr auto size() const& noexcept requires tc::has_size<Rng> {
-				return tc::size_raw(this->base_range());
+			constexpr auto size() const& MAYTHROW requires tc::has_size<Rng> {
+				return tc::compute_range_adaptor_size<tc::identity{}>(this->base_range());
 			}
 
 			template<typename Sink>
@@ -67,7 +69,7 @@ namespace tc {
 		struct [[nodiscard]] transform_adaptor<Func, Rng, true>
 			: tc::index_range_adaptor<
 				transform_adaptor<Func, Rng, true>,
-				Rng,
+				Rng, tc::index_range_adaptor_flags::inherit_begin_end | tc::index_range_adaptor_flags::inherit_traversal,
 				transform_adaptor<Func, Rng, false>
 			>
 		{
@@ -83,27 +85,23 @@ namespace tc {
 			template<ENABLE_SFINAE>
 			constexpr auto STATIC_VIRTUAL_METHOD_NAME(dereference_index)(tc_index const& idx) & MAYTHROW -> tc::transform_return_t<
 				SFINAE_TYPE(Func),
-				decltype(tc::invoke(std::declval<SFINAE_TYPE(Func) const&>(), std::declval<base_ &>().template dereference_index<base_>(std::declval<tc_index const&>()))),
-				decltype(std::declval<base_ &>().template dereference_index<base_>(std::declval<tc_index const&>()))
+				decltype(tc::invoke(std::declval<SFINAE_TYPE(Func) const&>(), tc::dereference_index(this->base_range(), std::declval<tc_index const&>()))),
+				decltype(tc::dereference_index(this->base_range(), std::declval<tc_index const&>()))
 			> {
 				// always call operator() const, which is assumed to be thread-safe
-				return tc::invoke(tc::as_const(this->m_func), this->template dereference_index<base_>(idx));
+				return tc::invoke(tc::as_const(this->m_func), tc::dereference_index(this->base_range(), idx));
 			}
 
 			template<ENABLE_SFINAE>
 			constexpr auto STATIC_VIRTUAL_METHOD_NAME(dereference_index)(tc_index const& idx) const& MAYTHROW -> tc::transform_return_t<
 				SFINAE_TYPE(Func),
-				decltype(tc::invoke(std::declval<SFINAE_TYPE(Func) const&>(), std::declval<base_ const&>().template dereference_index<base_>(std::declval<tc_index const&>()))),
-				decltype(std::declval<base_ const&>().template dereference_index<base_>(std::declval<tc_index const&>()))
+				decltype(tc::invoke(std::declval<SFINAE_TYPE(Func) const&>(), tc::dereference_index(this->base_range(), std::declval<tc_index const&>()))),
+				decltype(tc::dereference_index(this->base_range(), std::declval<tc_index const&>()))
 			> {
 				// always call operator() const, which is assumed to be thread-safe
-				return tc::invoke(tc::as_const(this->m_func), this->template dereference_index<base_>(idx));
+				return tc::invoke(tc::as_const(this->m_func), tc::dereference_index(this->base_range(), idx));
 			}
 
-			// We may inherit an index_to_address from our base; just like dereference_index(), we need to override it.
-			// But in the case of transform, we are no longer contiguous, so delete it.
-			auto STATIC_VIRTUAL_METHOD_NAME(index_to_address)(tc_index const&) const = delete;
-
 			static constexpr decltype(auto) border_base_index(tc_index const& idx) noexcept {
 				return idx;
 			}
@@ -124,11 +122,10 @@ namespace tc {
 			}
 		};
 	}
+	using transform_adaptor_adl::transform_adaptor;
 
-	namespace no_adl {
-		template<typename Func, typename Rng, bool bConst>
-		struct constexpr_size_impl<tc::transform_adaptor<Func,Rng,bConst>> : tc::constexpr_size<Rng> {};
-	}
+	template<typename Func, typename Rng>
+	constexpr auto enable_stable_index_on_move<tc::transform_adaptor<Func, Rng, true>> = tc::stable_index_on_move<Rng>;
 
 	template<typename Rng, typename Func>
 	[[nodiscard]] constexpr auto transform(Rng&& rng, Func&& func)
@@ -149,10 +146,5 @@ namespace tc {
 	[[nodiscard]] auto untransform(Rng&& rng) noexcept {
 		return tc::slice(untransform(std::forward<Rng>(rng).base_range()), rng.begin_index(), rng.end_index());
 	}
-
-	namespace no_adl {
-		template<typename Func, typename Rng>
-		struct is_index_valid_for_move_constructed_range<tc::transform_adaptor<Func, Rng, true>>: tc::is_index_valid_for_move_constructed_range<Rng> {};
-	}
 }
 
diff --git a/tc/range/union_adaptor.h b/tc/range/union_adaptor.h
index eff5075..3208a99 100644
--- a/tc/range/union_adaptor.h
+++ b/tc/range/union_adaptor.h
@@ -12,7 +12,6 @@
 #include "../base/modified.h"
 #include "../algorithm/compare.h"
 #include "../algorithm/algorithm.h"
-#include "range_fwd.h"
 #include "range_adaptor.h"
 #include "meta.h"
 
@@ -24,12 +23,13 @@ namespace tc {
 			typename Comp,
 			typename Rng0,
 			typename Rng1,
-			bool HasIterator = tc::range_with_iterators< Rng0 > && tc::range_with_iterators< Rng1 >
+			bool bDisjoint = false,
+			bool bHasIterator = tc::range_with_iterators< Rng0 > && tc::range_with_iterators< Rng1 >
 		>
 		struct union_adaptor;
 
-		template<typename Comp, typename Rng0, typename Rng1>
-		struct [[nodiscard]] union_adaptor<Comp, Rng0, Rng1, false>
+		template<typename Comp, typename Rng0, typename Rng1, bool bDisjoint>
+		struct [[nodiscard]] union_adaptor<Comp, Rng0, Rng1, bDisjoint, false>
 		{
 			tc::tuple<
 				tc::range_adaptor_base_range< Rng0 >,
@@ -56,6 +56,7 @@ namespace tc {
 
 				template<typename T0, typename T1>
 				auto operator()(T0&& arg0, T1&&) const {
+					_ASSERT(!bDisjoint);
 					return tc::continue_if_not_break(m_sink, std::forward<T0>(arg0));
 				}
 			};
@@ -92,39 +93,22 @@ namespace tc {
 			}
 		};
 
-		template<
-			typename Index0,
-			typename Index1
-		>
-		struct union_adaptor_index {
-			template<typename... Args>
-			union_adaptor_index(Args... args) noexcept
-				: m_tplindex{std::forward<Args>(args)...}
-			{}
-
-			template<typename... Args>
-			union_adaptor_index(std::weak_ordering order, Args... args) noexcept
-				: m_tplindex{std::forward<Args>(args)...}
-				, m_oorder(order)
-			{}
-
-			friend bool operator==(union_adaptor_index const& lhs, union_adaptor_index const& rhs) noexcept {
-				return EQUAL_MEMBERS(m_tplindex);
-			}
-
-			tc::tuple<Index0, Index1> m_tplindex;
-			std::optional<std::weak_ordering> m_oorder;
+		template<typename Index0, typename Index1>
+		struct union_adaptor_index : tc::tuple<Index0, Index1> {
+			// Inherit equality from tc::tuple
+			std::weak_ordering m_order=std::weak_ordering::less; // dummy default value to make index default constructible
 		};
 
 		template<
 			typename Comp,
 			typename Rng0,
-			typename Rng1
+			typename Rng1,
+			bool bDisjoint
 		>
-		struct [[nodiscard]] union_adaptor<Comp, Rng0, Rng1, true> :
-			union_adaptor<Comp, Rng0, Rng1, false>,
+		struct [[nodiscard]] union_adaptor<Comp, Rng0, Rng1, bDisjoint, true> :
+			union_adaptor<Comp, Rng0, Rng1, bDisjoint, false>,
 			range_iterator_from_index<
-				union_adaptor<Comp, Rng0, Rng1, true>,
+				union_adaptor<Comp, Rng0, Rng1, bDisjoint, true>,
 				union_adaptor_index<
 					tc::index_t<std::remove_reference_t<
 						Rng0
@@ -140,146 +124,151 @@ namespace tc {
 
 		public:
 			using typename this_type::range_iterator_from_index::tc_index;
-			using union_adaptor<Comp, Rng0, Rng1, false>::union_adaptor;
+			using union_adaptor<Comp, Rng0, Rng1, bDisjoint, false>::union_adaptor;
 
 			static constexpr bool c_bHasStashingIndex=tc::has_stashing_index<std::remove_reference_t<Rng0>>::value || tc::has_stashing_index<std::remove_reference_t<Rng1>>::value;
 		private:
 			void find_order(tc_index& idx) const& noexcept {
-				if (at_end_index_fwd<0>(idx)) {
-					idx.m_oorder = at_end_index_fwd<1>(idx) ? std::weak_ordering::less : std::weak_ordering::greater;
-				} else if (at_end_index_fwd<1>(idx)) {
-					idx.m_oorder = std::weak_ordering::less;
+				if (base_at_end_index<0>(idx)) {
+					idx.m_order = base_at_end_index<1>(idx) ? std::weak_ordering::less : std::weak_ordering::greater;
+				} else if (base_at_end_index<1>(idx)) {
+					idx.m_order = std::weak_ordering::less;
 				} else {
-					idx.m_oorder = this->m_comp(dereference_index_fwd<0>(idx), dereference_index_fwd<1>(idx));
+					idx.m_order = this->m_comp(base_dereference_index<0>(idx), base_dereference_index<1>(idx));
+					if constexpr(bDisjoint) {
+						_ASSERT(tc::is_neq(idx.m_order));
+					}
 				}
 			}
 
 			template<int N>
-			void increment_index_fwd(tc_index& idx) const& noexcept {
-				tc::increment_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx.m_tplindex));
+			void base_increment_index(tc_index& idx) const& noexcept {
+				tc::increment_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx));
 			}
 
 			template<int N>
-			void decrement_index_fwd(tc_index& idx) const& noexcept {
-				tc::decrement_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx.m_tplindex));
+			void base_decrement_index(tc_index& idx) const& noexcept {
+				tc::decrement_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx));
 			}
 
 			template<int N>
-			bool at_end_index_fwd(tc_index const& idx) const& noexcept {
-				return tc::at_end_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx.m_tplindex));
+			bool base_at_end_index(tc_index const& idx) const& noexcept {
+				return tc::at_end_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx));
 			}
 
 			template<int N>
-			bool at_begin_index(tc_index const& idx) const& noexcept {
-				return tc::get<N>(idx.m_tplindex) == tc::get<N>(this->m_tupleadaptbaserng).base_begin_index();
+			bool base_at_begin_index(tc_index const& idx) const& noexcept {
+				return tc::get<N>(idx) == tc::get<N>(this->m_tupleadaptbaserng).base_begin_index();
 			}
 
 			template<int N>
-			auto dereference_index_fwd(tc_index const& idx) const& return_decltype_MAYTHROW(
-				tc::dereference_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx.m_tplindex))
+			auto base_dereference_index(tc_index const& idx) const& return_decltype_MAYTHROW(
+				tc::dereference_index(tc::get<N>(this->m_tupleadaptbaserng).base_range(), tc::get<N>(idx))
 			)
 
 			STATIC_FINAL(at_end_index)(tc_index const& idx) const& noexcept -> bool {
-				return std::is_lt(*idx.m_oorder) && at_end_index_fwd<0>(idx);
+				return std::is_lt(idx.m_order) && base_at_end_index<0>(idx);
 			}
 
 			STATIC_FINAL(begin_index)() const& noexcept -> tc_index {
-				tc_index idx(tc::get<0>(this->m_tupleadaptbaserng).base_begin_index(), tc::get<1>(this->m_tupleadaptbaserng).base_begin_index());
+				tc_index idx{{tc::get<0>(this->m_tupleadaptbaserng).base_begin_index(), tc::get<1>(this->m_tupleadaptbaserng).base_begin_index()}};
 				find_order(idx);
 				return idx;
 			}
 
 			STATIC_FINAL(dereference_index)(tc_index const& idx) const& noexcept -> decltype(auto) {
-				return CONDITIONAL_PRVALUE_AS_VAL( std::is_lteq(*idx.m_oorder), dereference_index_fwd<0>(idx), dereference_index_fwd<1>(idx) );
+				return tc_conditional_prvalue_as_val( std::is_lteq(idx.m_order), base_dereference_index<0>(idx), base_dereference_index<1>(idx) );
 			}
 
 			STATIC_FINAL(end_index)() const& noexcept -> tc_index {
-				tc_index idx(std::weak_ordering::less, tc::get<0>(this->m_tupleadaptbaserng).base_end_index(), tc::get<1>(this->m_tupleadaptbaserng).base_end_index());
+				tc_index idx{{tc::get<0>(this->m_tupleadaptbaserng).base_end_index(), tc::get<1>(this->m_tupleadaptbaserng).base_end_index()}, std::weak_ordering::less};
 				return idx;
 			}
 
 			STATIC_FINAL(increment_index)(tc_index& idx) const& noexcept -> void {
-				if(std::is_lt(*idx.m_oorder)) {
-					increment_index_fwd<0>(idx);
+				if(std::is_lt(idx.m_order)) {
+					base_increment_index<0>(idx);
 				} else {
-					if(tc::is_eq(*idx.m_oorder)) {
-						increment_index_fwd<0>(idx);
+					if(tc::is_eq(idx.m_order)) {
+						base_increment_index<0>(idx);
 					} else {
-						_ASSERTDEBUG(std::is_gt(*idx.m_oorder));
+						_ASSERTDEBUG(std::is_gt(idx.m_order));
 					}
-					increment_index_fwd<1>(idx);
+					base_increment_index<1>(idx);
 				}
 
 				find_order(idx);
 			}
 
 			STATIC_FINAL(decrement_index)(tc_index& idx) const& noexcept -> void {
-				if (at_begin_index<0>(idx)) {
-					_ASSERT(!at_begin_index<1>(idx));
-					decrement_index_fwd<1>(idx);
-					idx.m_oorder = std::weak_ordering::greater;
-				} else if (at_begin_index<1>(idx)) {
-					_ASSERT(!at_begin_index<0>(idx));
-					decrement_index_fwd<0>(idx);
-					idx.m_oorder = std::weak_ordering::less;
+				if (base_at_begin_index<0>(idx)) {
+					_ASSERT(!base_at_begin_index<1>(idx));
+					base_decrement_index<1>(idx);
+					idx.m_order = std::weak_ordering::greater;
+				} else if (base_at_begin_index<1>(idx)) {
+					_ASSERT(!base_at_begin_index<0>(idx));
+					base_decrement_index<0>(idx);
+					idx.m_order = std::weak_ordering::less;
 				} else {
 					auto idxOriginal = idx;
-					decrement_index_fwd<0>(idx);
-					decrement_index_fwd<1>(idx);
-					idx.m_oorder = tc::negate(this->m_comp(dereference_index_fwd<0>(idx), dereference_index_fwd<1>(idx)));
-					if(std::is_lt(*idx.m_oorder)) {
-						tc::get<1>(idx.m_tplindex) = tc::get<1>(tc_move(idxOriginal).m_tplindex);
-					} else if(std::is_gt(*idx.m_oorder)) {
-						tc::get<0>(idx.m_tplindex) = tc::get<0>(tc_move(idxOriginal).m_tplindex);
+					base_decrement_index<0>(idx);
+					base_decrement_index<1>(idx);
+					idx.m_order = tc::negate(this->m_comp(base_dereference_index<0>(idx), base_dereference_index<1>(idx)));
+					if(std::is_lt(idx.m_order)) {
+						tc::get<1>(idx) = tc::get<1>(tc_move(idxOriginal));
+					} else if(std::is_gt(idx.m_order)) {
+						tc::get<0>(idx) = tc::get<0>(tc_move(idxOriginal));
 					} else {
-						_ASSERTDEBUG(tc::is_eq(*idx.m_oorder));
+						_ASSERTDEBUG(tc::is_eq(idx.m_order));
+						_ASSERT(!bDisjoint);
 					}
 				}
 			}
 
 			// partition_point would be a more efficient customization point
 			STATIC_FINAL(middle_point)(tc_index& idx, tc_index const& idxEnd) const& noexcept -> void {
-				if (tc::get<0>(idx.m_tplindex) == tc::get<0>(idxEnd.m_tplindex)) {
-					tc::middle_point(tc::get<1>(this->m_tupleadaptbaserng).base_range(), tc::get<1>(idx.m_tplindex), tc::get<1>(idxEnd.m_tplindex));
-					idx.m_oorder = std::weak_ordering::greater;
+				if (tc::get<0>(idx) == tc::get<0>(idxEnd)) {
+					tc::middle_point(tc::get<1>(this->m_tupleadaptbaserng).base_range(), tc::get<1>(idx), tc::get<1>(idxEnd));
+					idx.m_order = std::weak_ordering::greater;
 				} else {
-					auto idx0Begin = tc::get<0>(idx.m_tplindex);
-					tc::middle_point(tc::get<0>(this->m_tupleadaptbaserng).base_range(), tc::get<0>(idx.m_tplindex), tc::get<0>(idxEnd.m_tplindex));
-					auto&& ref0 = dereference_index_fwd<0>(idx);
-					tc::get<1>(idx.m_tplindex) = tc::iterator2index<Rng1>(
+					auto idx0Begin = tc::get<0>(idx);
+					tc::middle_point(tc::get<0>(this->m_tupleadaptbaserng).base_range(), tc::get<0>(idx), tc::get<0>(idxEnd));
+					auto&& ref0 = base_dereference_index<0>(idx);
+					tc::get<1>(idx) = tc::iterator2index<Rng1>(
 						tc::lower_bound(
-							tc::make_iterator(tc::get<1>(tc::as_mutable(this->m_tupleadaptbaserng)).base_range(), tc::get<1>(idx.m_tplindex)),
-							tc::make_iterator(tc::get<1>(tc::as_mutable(this->m_tupleadaptbaserng)).base_range(), tc::get<1>(idxEnd.m_tplindex)),
+							tc::make_iterator(tc::get<1>(tc::as_mutable(this->m_tupleadaptbaserng)).base_range(), tc::get<1>(idx)),
+							tc::make_iterator(tc::get<1>(tc::as_mutable(this->m_tupleadaptbaserng)).base_range(), tc::get<1>(idxEnd)),
 							ref0,
 							tc::greaterfrom3way([&](auto const& _1, auto const& _2) noexcept { return this->m_comp(_2, _1); })
 						)
 					);
 
-					if (at_end_index_fwd<1>(idx)) {
-						idx.m_oorder = std::weak_ordering::less;
+					if (base_at_end_index<1>(idx)) {
+						idx.m_order = std::weak_ordering::less;
 					} else {
-						auto&& ref1 = dereference_index_fwd<1>(idx);
+						auto&& ref1 = base_dereference_index<1>(idx);
 
-						idx.m_oorder = this->m_comp(ref0, ref1);
-						_ASSERT(std::is_lteq(*idx.m_oorder));
+						idx.m_order = this->m_comp(ref0, ref1);
+						_ASSERT(std::is_lteq(idx.m_order));
 
-						if (tc::is_eq(*idx.m_oorder)) {
-							auto idx0 = tc::get<0>(idx.m_tplindex);
+						if (tc::is_eq(idx.m_order)) {
+							auto idx0 = tc::get<0>(idx);
 							typename boost::range_size<Rng0>::type n = 0;
 							while (idx0Begin != idx0) {
 								tc::decrement_index(tc::get<0>(this->m_tupleadaptbaserng).base_range(), idx0);
 
 								if (tc::is_neq(this->m_comp(tc::dereference_index(tc::get<0>(this->m_tupleadaptbaserng).base_range(), idx0), ref1))) {
+									_ASSERT(!bDisjoint);
 									break;
 								}
 								++n;
 							}
 							while (0<n) {
-								increment_index_fwd<1>(idx);
+								base_increment_index<1>(idx);
 								--n;
 
-								if (at_end_index_fwd<1>(idx) || std::is_lt(this->m_comp(ref0, dereference_index_fwd<1>(idx)))) {
-									idx.m_oorder = std::weak_ordering::less;
+								if (base_at_end_index<1>(idx) || std::is_lt(this->m_comp(ref0, base_dereference_index<1>(idx)))) {
+									idx.m_order = std::weak_ordering::less;
 									break;
 								}
 							}
@@ -291,25 +280,27 @@ namespace tc {
 	}
 	using union_adaptor_adl::union_adaptor;
 
-	template<typename Comp, typename Rng0, typename Rng1>
-	[[nodiscard]] auto split_union(subrange<union_adaptor<Comp, Rng0, Rng1> &> const& rngsubunion) return_decltype_NOEXCEPT( // make_tuple is noexcept(false); the rest of this should only throw bad_alloc
+	template<typename Comp, typename Rng0, typename Rng1, bool bDisjoint>
+	constexpr auto enable_stable_index_on_move<tc::union_adaptor<Comp, Rng0, Rng1, bDisjoint, true>>
+		= tc::stable_index_on_move<Rng0> && tc::stable_index_on_move<Rng1>;
+
+	template<typename Comp, typename Rng0, typename Rng1, bool bDisjoint>
+	[[nodiscard]] auto split_union(subrange<union_adaptor<Comp, Rng0, Rng1, bDisjoint> &> const& rngsubunion) return_decltype_NOEXCEPT( // make_tuple is noexcept(false); the rest of this should only throw bad_alloc
 		tc::make_tuple(
-			tc::slice(tc::get<0>(rngsubunion.base_range().m_tupleadaptbaserng).base_range(), tc::get<0>(rngsubunion.begin_index().m_tplindex), tc::get<0>(rngsubunion.end_index().m_tplindex)),
-			tc::slice(tc::get<1>(rngsubunion.base_range().m_tupleadaptbaserng).base_range(), tc::get<1>(rngsubunion.begin_index().m_tplindex), tc::get<1>(rngsubunion.end_index().m_tplindex))
+			tc::slice(tc::get<0>(rngsubunion.base_range().m_tupleadaptbaserng).base_range(), tc::get<0>(rngsubunion.begin_index()), tc::get<0>(rngsubunion.end_index())),
+			tc::slice(tc::get<1>(rngsubunion.base_range().m_tupleadaptbaserng).base_range(), tc::get<1>(rngsubunion.begin_index()), tc::get<1>(rngsubunion.end_index()))
 		)
 	)
 
 	template<typename Rng0, typename Rng1, typename Comp = tc::fn_compare>
 	[[nodiscard]] auto union_range(Rng0&& rng0, Rng1&& rng1, Comp&& comp = Comp()) return_ctor_noexcept(
-		TC_FWD(union_adaptor< tc::decay_t<Comp>, Rng0, Rng1>),
+		TC_FWD(union_adaptor< tc::decay_t<Comp>, Rng0, Rng1, /*bDisjoint*/false>),
 		(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1), std::forward<Comp>(comp))
 	)
 
-	namespace no_adl {
-		template<typename Comp, typename Rng0, typename Rng1>
-		struct is_index_valid_for_move_constructed_range<tc::union_adaptor<Comp, Rng0, Rng1, true>>: std::conjunction<
-			is_index_valid_for_move_constructed_range<Rng0>,
-			is_index_valid_for_move_constructed_range<Rng1>
-		> {};
-	}
+	template<typename Rng0, typename Rng1, typename Comp = tc::fn_compare>
+	[[nodiscard]] auto disjoint_union_range(Rng0&& rng0, Rng1&& rng1, Comp&& comp = Comp()) return_ctor_noexcept(
+		TC_FWD(union_adaptor< tc::decay_t<Comp>, Rng0, Rng1, /*bDisjoint*/true>),
+		(std::forward<Rng0>(rng0), std::forward<Rng1>(rng1), std::forward<Comp>(comp))
+	)
 }
diff --git a/tc/range/unique_range_adaptor.h b/tc/range/unique_range_adaptor.h
index 19e393d..9f474aa 100644
--- a/tc/range/unique_range_adaptor.h
+++ b/tc/range/unique_range_adaptor.h
@@ -12,7 +12,6 @@
 #include "../base/static_polymorphism.h"
 #include "../algorithm/compare.h"
 #include "../algorithm/empty.h"
-#include "range_fwd.h"
 #include "range_adaptor.h"
 #include "meta.h"
 #include "subrange.h"
@@ -157,7 +156,7 @@ namespace tc {
 							return self.m_equals(valLast, tc::as_const(elem)); // MAYTHROW
 						});
 						ovalLast.emplace(tc_move_if_owned(elem));
-						return CONDITIONAL_PRVALUE_AS_VAL(bSkip, tc::constant<tc::continue_>(), tc::continue_if_not_break(sink, *ovalLast) /*MAYTHROW*/);
+						return tc_conditional_prvalue_as_val(bSkip, tc::constant<tc::continue_>(), tc::continue_if_not_break(sink, *ovalLast) /*MAYTHROW*/);
 					});
 				}
 			}
@@ -225,10 +224,8 @@ namespace tc {
 	}
 	using unique_adaptor_adl::unique_adaptor;
 
-	namespace no_adl {
-		template<typename Rng, typename Equals>
-		struct is_index_valid_for_move_constructed_range<unique_adaptor<Rng, Equals, true>> : tc::is_index_valid_for_move_constructed_range<Rng> {};
-	}
+	template<typename Rng, typename Equals>
+	constexpr auto enable_stable_index_on_move<unique_adaptor<Rng, Equals, true>> = tc::stable_index_on_move<Rng>;
 
 	namespace subrange_range_adaptor_detail::no_adl {
 		template<typename IndexBase>
@@ -285,7 +282,7 @@ namespace tc {
 		private:
 			using this_type = partition_range_adaptor;
 		protected:
-			STATIC_VIRTUAL_CONSTEXPR(FindPartitionEnd) // (index_t<Rng>&) -> void
+			STATIC_VIRTUAL(FindPartitionEnd) // (index_t<Rng>&) -> void
 		private:
 			STATIC_OVERRIDE_MOD(constexpr, begin_index)() const& noexcept -> tc_index {
 				auto const idxBegin = this->base_begin_index();
@@ -359,9 +356,6 @@ namespace tc {
 			}
 		};
 
-		template<typename Rng, typename Equals>
-		struct is_index_valid_for_move_constructed_range<unique_range_front_adaptor<Rng, Equals>> : tc::is_index_valid_for_move_constructed_range<Rng> {};
-
 		template<typename Rng, typename Equals>
 		struct [[nodiscard]] unique_range_adjacent_adaptor : partition_range_adaptor<unique_range_adjacent_adaptor<Rng, Equals>, Rng>
 		{
@@ -392,25 +386,27 @@ namespace tc {
 				unique_adaptor_detail::decrement_index(this->base_range(), idx.m_idxBegin, m_equals);
 			}
 		};
-
-		template<typename Rng, typename Equals>
-		struct is_index_valid_for_move_constructed_range<unique_range_adjacent_adaptor<Rng, Equals>> : tc::is_index_valid_for_move_constructed_range<Rng> {};
 	}
 
 	using no_adl::unique_range_front_adaptor;
 	using no_adl::unique_range_adjacent_adaptor;
 
+	template<typename Rng, typename Equals>
+	constexpr auto enable_stable_index_on_move<unique_range_front_adaptor<Rng, Equals>> = tc::stable_index_on_move<Rng>;
+	template<typename Rng, typename Equals>
+	constexpr auto enable_stable_index_on_move<unique_range_adjacent_adaptor<Rng, Equals>> = tc::stable_index_on_move<Rng>;
+
 	template<
 		typename Rng,
 		typename Equals
 	>
-	auto front_unique_range(Rng&& rng, Equals&& equals) return_ctor_noexcept(
+	constexpr auto front_unique_range(Rng&& rng, Equals&& equals) return_ctor_noexcept(
 		TC_FWD(unique_range_front_adaptor< Rng, tc::decay_t<Equals> >),
 		(std::forward<Rng>(rng), std::forward<Equals>(equals))
 	)
 
 	template< typename Rng >
-	auto front_unique_range(Rng&& rng) return_decltype_noexcept(
+	constexpr auto front_unique_range(Rng&& rng) return_decltype_noexcept(
 		front_unique_range(std::forward<Rng>(rng),tc::fn_equal_to())
 	)
 
diff --git a/tc/range/zip_range.h b/tc/range/zip_range.h
index e0d237e..5845255 100644
--- a/tc/range/zip_range.h
+++ b/tc/range/zip_range.h
@@ -11,10 +11,12 @@
 #include "../base/functors.h"
 #include "../base/utility.h"
 #include "../algorithm/quantifier.h"
-#include "../algorithm/algorithm.h"
 #include "../algorithm/element.h"
 #include "../algorithm/size_linear.h"
+#include "../algorithm/empty.h"
+#include "filter_adaptor.h"
 #include "range_adaptor.h"
+#include "reverse_adaptor.h"
 #include "iota_range.h"
 
 namespace tc {
@@ -112,6 +114,11 @@ namespace tc {
 		template<typename Rng, typename Self>
 		using apply_cvref_to_base_range_t = decltype(std::declval<tc::apply_cvref_t<tc::range_adaptor_base_range<Rng>, Self>>().base_range());
 
+		namespace trait_from_concept_workaround { // workaround Xcode14.1 segmentation fault
+			template<typename Rng>
+			using has_constexpr_size = tc::constant<tc::has_constexpr_size<Rng>>;
+		}
+
 		template<
 			bool HasIterator,
 			typename... Rng
@@ -229,9 +236,20 @@ namespace tc {
 			}
 
 		public:
-			// TODO: Enable size() when any range supports constant-time size().
-			constexpr auto size() const& noexcept requires tc::has_size<tc::type::front_t<tc::type::list<Rng...>>> {
-				return tc::size_raw(tc::get<0>(m_tupleadaptbaserng).base_range());
+			constexpr auto size() const& MAYTHROW requires (... || tc::has_size<Rng>) && (!(... || tc::has_constexpr_size<Rng>)) {
+				return tc::all_same_element<tc::return_value>(tc::generator_range_output<std::size_t>(tc::transform(
+					tc::filter(m_tupleadaptbaserng, [](auto const& rng) noexcept {
+						return tc::constant<tc::has_size<decltype(rng.base_range())>>{};
+					}),
+					[](auto const& rng) noexcept {
+						return tc::size_raw(rng.base_range());
+					}
+				)));
+			}
+
+			constexpr auto size() const& noexcept requires (... || tc::has_constexpr_size<Rng>) {
+				using sized_rng = tc::type::front_t<tc::type::filter_t<tc::type::list<Rng...>, trait_from_concept_workaround::has_constexpr_size>>;
+				return tc::constexpr_size<sized_rng>;
 			}
 		};
 
@@ -267,7 +285,7 @@ namespace tc {
 
 			STATIC_FINAL_MOD(constexpr, at_end_index)(tc_index const& idx) const& noexcept -> bool {
 				auto MemberRangeAtEnd = 
-					[&](auto nconstIndex) noexcept {
+					[&](auto const nconstIndex) noexcept {
 						return tc::at_end_index(tc::get<nconstIndex()>(this->m_tupleadaptbaserng).base_range(), tc::get<nconstIndex()>(idx));
 					};
 
@@ -275,7 +293,7 @@ namespace tc {
 
 				_ASSERT(tc::all_of(
 					tc::make_integer_sequence<std::size_t, 1, sizeof...(Rng)>(),
-					[&](auto nconstIndex) noexcept { return MemberRangeAtEnd(nconstIndex) == bAtEnd; }
+					[&](auto const nconstIndex) noexcept { return MemberRangeAtEnd(nconstIndex) == bAtEnd; }
 				));
 
 				return bAtEnd;
@@ -319,25 +337,12 @@ namespace tc {
 				tc_return_cast(tc::distance_to_index(tc::get<0>(this->m_tupleadaptbaserng).base_range(), tc::get<0>(idxLhs), tc::get<0>(idxRhs)));
 			}
 		};
-
-		namespace trait_from_concept_workaround { // workaround Xcode14.1 segmentation fault
-			template<typename Rng>
-			using has_constexpr_size = tc::constant<tc::has_constexpr_size<Rng>>;
-		}
-
-		template<bool HasIterator, typename... Rng> requires tc::type::any_of<tc::type::list<Rng...>, trait_from_concept_workaround::has_constexpr_size>::value
-		struct constexpr_size_impl<zip_adaptor<HasIterator, Rng...>>
-			: tc::constexpr_size<tc::type::front_t<tc::type::filter_t<
-				tc::type::list<Rng...>,
-				trait_from_concept_workaround::has_constexpr_size
-			>>>
-		{};
-
-		template<bool HasIterator, typename... Rng>
-		struct is_index_valid_for_move_constructed_range<zip_adaptor<HasIterator, Rng...>>
-			: std::conjunction<tc::is_index_valid_for_move_constructed_range<Rng>...>
-		{};
 	}
+	using no_adl::zip_adaptor;
+
+	template<bool HasIterator, typename... Rng>
+	constexpr auto enable_stable_index_on_move<zip_adaptor<HasIterator, Rng...>>
+		= (tc::stable_index_on_move<Rng> && ...);
 
 	template<typename... Rng>
 	constexpr no_adl::zip_adaptor</*HasIterator*/(... && tc::range_with_iterators<Rng>), Rng...> zip(Rng&&... rng) noexcept {
@@ -430,7 +435,7 @@ namespace tc {
 	*/
 	template<typename RngRng>
 	auto zip_ranges(RngRng&& rngrng) noexcept { // for random access ranges
-		_ASSERT(tc::all_same(tc::transform(rngrng, tc_fn(tc::size))));
+		_ASSERT(tc::all_same_element<tc::return_bool>(tc::transform(rngrng, tc_fn(tc::size))));
 		auto const n = tc::empty(rngrng) ? 0 : tc::size(tc::front(rngrng)); // Do not inline, function evaluation order undefined
 		return tc::transform(
 			tc::iota(0, n),
diff --git a/tc/range/zip_range.t.cpp b/tc/range/zip_range.t.cpp
index dd7d014..96fb1f9 100644
--- a/tc/range/zip_range.t.cpp
+++ b/tc/range/zip_range.t.cpp
@@ -13,9 +13,36 @@
 
 namespace
 {
-	template<typename BaseRange, typename Traversal>
-	struct traversal_override_adaptor : tc::index_range_adaptor<traversal_override_adaptor<BaseRange, Traversal>, BaseRange &, tc::range_adaptor_base_range<BaseRange>, Traversal> {
-		traversal_override_adaptor(BaseRange & base_range) : traversal_override_adaptor::index_range_adaptor(tc::aggregate_tag, base_range) {}
+	template<typename Rng, typename Traversal>
+	struct traversal_override_adaptor
+		: tc::index_range_adaptor<traversal_override_adaptor<Rng, Traversal>, Rng&, tc::index_range_adaptor_flags::inherit_all>
+	{
+		using this_type = traversal_override_adaptor;
+		using base_ = typename traversal_override_adaptor::index_range_adaptor;
+		using tc_index = typename base_::tc_index;
+
+		traversal_override_adaptor(Rng& rng) : base_(tc::aggregate_tag, rng) {}
+
+		STATIC_FINAL(decrement_index)(tc_index& idx) const& MAYTHROW
+			requires tc::has_decrement_index<Rng>
+				&& boost::iterators::detail::is_traversal_at_least<Traversal, boost::iterators::bidirectional_traversal_tag>::value
+		{
+			tc::decrement_index(this->base_range(), idx);
+		}
+
+		STATIC_FINAL_MOD(constexpr, advance_index)(tc_index& idx, typename boost::range_difference<Rng>::type d) const& MAYTHROW -> void
+			requires tc::has_advance_index<Rng>
+				&& boost::iterators::detail::is_traversal_at_least<Traversal, boost::iterators::random_access_traversal_tag>::value
+		{
+			tc::advance_index(this->base_range(),idx,d);
+		}
+
+		STATIC_FINAL_MOD(constexpr, distance_to_index)(tc_index const& idxLhs, tc_index const& idxRhs) const& noexcept
+			requires tc::has_distance_to_index<Rng>
+				&& boost::iterators::detail::is_traversal_at_least<Traversal, boost::iterators::random_access_traversal_tag>::value
+		{
+			return tc::distance_to_index(this->base_range(),idxLhs,idxRhs);
+		}
 	};
 }
 
@@ -63,6 +90,11 @@ UNITTESTDEF(zip_range_supported_ops) {
 	static_assert(tc::has_advance_index<decltype(zip_rr)>);
 	static_assert(tc::has_distance_to_index<decltype(zip_rr)>);
 
+	_ASSERTEQUAL(tc::size(zip_fr), 5);
+	_ASSERTEQUAL(tc::size(zip_br), 5);
+	_ASSERTEQUAL(tc::size(zip_rr), 5);
+	_ASSERTEQUAL(tc::size(zip_rfgf), 5);
+
 	static_assert(!tc::range_with_iterators<decltype(zip_rfgf)>);
 }
 
diff --git a/tc/restricted_enum.h b/tc/restricted_enum.h
new file mode 100644
index 0000000..94b2d68
--- /dev/null
+++ b/tc/restricted_enum.h
@@ -0,0 +1,188 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "base/type_traits.h"
+#include "base/safe_comparison.h"
+#include "base/casts.h"
+#include "base/explicit_cast.h"
+#include "algorithm/binary_operators.h"
+
+// restricted_enum restricts an enum or char type to a subinterval.
+// It provides the following operations:
+// * implicit (checked) conversion to/from base type
+// * forwarding of to/from_underlying
+// * full comparison
+// Additionally, for types other than enum class, it also has affine arithmetic:
+// * value += integer, value + integer
+// * value -= integer, value - integer
+// * value - value resulting in integer
+
+namespace tc {
+	namespace restricted_enum_adl {
+		namespace detail {
+			template <tc::char_type T>
+			constexpr bool is_only_ascii(T, T tLast) noexcept
+			{
+				// No need to check tFirst, it's underlying is <= tLast and the underlying type is unsigned.
+				return tc::to_underlying(tLast) <= 0x7F;
+			}
+			
+			// Workaround clang by providing an overload for non-char types.
+			// This will never actually be called as it is after a `tc::char_type<T>` check, but has to exist.
+			template <typename T>
+			constexpr std::false_type is_only_ascii(T, T) noexcept { return {}; }
+		}
+
+		template<typename T, T tFirst, T tLast>
+		struct restricted_enum final : tc::additive<> {
+		// private: TODO: inhibits usage as template parameter
+			static_assert(tc::decayed<T>);
+			static_assert(std::is_enum<T>::value || tc::char_type<T>);
+			static_assert(tc::to_underlying(tFirst) <= tc::to_underlying(tLast));
+
+			T m_t;
+
+		public:
+			static constexpr T c_tFirst = tFirst;
+			static constexpr T c_tLast = tLast;
+
+			constexpr restricted_enum() noexcept = default;
+
+			template<typename U>
+				requires tc::explicit_castable_from<T, U const&>
+			explicit constexpr restricted_enum(U const& u) noexcept : tc_member_init_cast(m_t, u) {
+				_ASSERTE(tc::to_underlying(c_tFirst) <= tc::to_underlying(m_t) && tc::to_underlying(m_t) <= tc::to_underlying(c_tLast));
+			}
+
+			// Implicit ctor from a more restrictive type.
+			template<typename U, U uFirst, U uLast>
+				requires std::convertible_to<U, T> && (tc::cmp_less_equal(tc::to_underlying(c_tFirst), tc::to_underlying(uFirst)) && tc::cmp_less_equal(tc::to_underlying(uLast), tc::to_underlying(c_tLast)))
+			constexpr restricted_enum(restricted_enum<U, uFirst, uLast> const rhs) noexcept : m_t(tc::implicit_cast<U>(rhs)) {}
+
+			// Explicit ctor otherwise.
+			template<typename U, U uFirst, U uLast>
+				requires std::convertible_to<U, T>
+			explicit constexpr restricted_enum(restricted_enum<U, uFirst, uLast> const rhs) noexcept : restricted_enum(tc::implicit_cast<U>(rhs)) {}
+
+			// Assignment allows explicit constructors as well.
+			// This is needed for spirit: it needs to assign to a restricted_enum attribute.
+			template<typename U>
+				requires std::is_constructible<restricted_enum<T, tFirst, tLast>, U const&>::value
+			constexpr restricted_enum& operator=(U const& rhs) & noexcept {
+				tc::renew(*this, rhs);
+				return *this;
+			}
+
+			template <typename U>
+				requires std::same_as<U, T>
+					|| (tc::char_type<T> && tc::char_type<U> && detail::is_only_ascii(tFirst, tLast))
+			constexpr operator U() const& noexcept {
+				return tc::explicit_cast<U>(m_t);
+			}
+
+			template<tc::actual_integer Integral>
+				requires requires (T& value, Integral n) { value += n; }
+			constexpr restricted_enum& operator+=(Integral const n) noexcept {
+				_ASSERTE(tc::cmp_less_equal(c_tFirst - m_t, n) && tc::cmp_less_equal(n, c_tLast - m_t));
+				m_t = static_cast<T>(m_t + n);
+				return *this;
+			}
+
+			template<tc::actual_integer Integral>
+				requires requires (T& value, Integral n) { value -= n; }
+			constexpr restricted_enum& operator-=(Integral const n) noexcept {
+				_ASSERTE(tc::cmp_less_equal(m_t - c_tLast, n) && tc::cmp_less_equal(n, m_t - c_tFirst));
+				m_t = static_cast<T>(m_t - n);
+				return *this;
+			}
+		};
+
+		namespace detail
+		{
+			template <typename T>
+			constexpr bool is_restricted_enum = false;
+			template <typename T, T tFirst, T tLast>
+			constexpr bool is_restricted_enum<restricted_enum<T, tFirst, tLast>> = true;
+		}
+
+		template<typename T, T tFirst, T tLast>
+		constexpr auto to_underlying_impl(restricted_enum<T, tFirst, tLast> const t) return_decltype_noexcept(
+			tc::to_underlying(tc::implicit_cast<T>(t))
+		)
+
+		template<typename T, T tFirst, T tLast>
+		constexpr auto from_underlying_impl(tc::type::identity<restricted_enum<T, tFirst, tLast>>, tc::underlying_type_t<restricted_enum<T, tFirst, tLast>> const t) return_decltype_noexcept(
+			// Range check for T done in its from_underlying implementation.
+			// Range check for [tFirst, tLast] done in constructor.
+			restricted_enum<T, tFirst, tLast>(tc::from_underlying<T>(t))
+		)
+
+#pragma push_macro("DEFINE_COMPARISON_OP")
+#define DEFINE_COMPARISON_OP(op, type, trait) \
+		template<typename T, T tFirst, T tLast, typename U> \
+			requires (!detail::is_restricted_enum<U> && trait<T, U>) \
+		constexpr type operator op(restricted_enum<T, tFirst, tLast> const lhs, U const& rhs) noexcept { \
+			return tc::implicit_cast<T>(lhs) op rhs; \
+		} \
+		template<tc::char_type T, T tFirst, T tLast, tc::char_type U> \
+			requires (!detail::is_restricted_enum<U> && !trait<T, U> && detail::is_only_ascii(tFirst, tLast)) \
+		constexpr type operator op(restricted_enum<T, tFirst, tLast> const lhs, U const& rhs) noexcept { \
+			return static_cast<U>(tc::implicit_cast<T>(lhs)) op rhs; \
+		} \
+		template<typename T, T tFirst, T tLast, typename U, U uFirst, U uLast> \
+			requires trait<T, U> \
+		constexpr type operator op(restricted_enum<T, tFirst, tLast> const lhs, restricted_enum<U, uFirst, uLast> const rhs) noexcept { \
+			return tc::implicit_cast<T>(lhs) op tc::implicit_cast<U>(rhs); \
+		} \
+		template<tc::char_type T, T tFirst, T tLast, tc::char_type U, U uFirst, U uLast> \
+			requires (!trait<T, U> && detail::is_only_ascii(tFirst, tLast) && detail::is_only_ascii(uFirst, uLast)) \
+		constexpr type operator op(restricted_enum<T, tFirst, tLast> const lhs, restricted_enum<U, uFirst, uLast> const rhs) noexcept { \
+			return char32_t(tc::implicit_cast<T>(lhs)) op char32_t(tc::implicit_cast<U>(rhs)); \
+		}
+
+		DEFINE_COMPARISON_OP(==, bool, tc::safely_equality_comparable_with)
+		DEFINE_COMPARISON_OP(<=>, std::weak_ordering, tc::safely_totally_ordered_with)
+#pragma pop_macro("DEFINE_COMPARISON_OP")
+
+		template <typename T, T tFirst, T tLast, typename U>
+			requires requires (T const& lhs, U const& rhs) { lhs - rhs; }
+		constexpr auto operator-(restricted_enum<T, tFirst, tLast> const lhs, U const& rhs) noexcept {
+			return tc::implicit_cast<T>(lhs) - rhs;
+		}
+		template <typename T, typename U, U uFirst, U uLast>
+			requires requires (T const& lhs, U const& rhs) { lhs - rhs; }
+		constexpr auto operator-(T const& lhs, restricted_enum<U, uFirst, uLast> const rhs) noexcept {
+			return lhs - tc::implicit_cast<U>(rhs);
+		}
+		template <typename T, T tFirst, T tLast, typename U, U uFirst, U uLast>
+			requires requires (T const& lhs, U const& rhs) { lhs - rhs; }
+		constexpr auto operator-(restricted_enum<T, tFirst, tLast> const lhs, restricted_enum<U, uFirst, uLast> const rhs) noexcept {
+			return tc::implicit_cast<T>(lhs) - tc::implicit_cast<U>(rhs);
+		}
+	}
+	using restricted_enum_adl::restricted_enum;
+
+	namespace char_like_detail {
+		template<typename T, T tFirst, T tLast>
+		inline constexpr bool char_like_impl<tc::restricted_enum<T, tFirst, tLast>> = tc::char_like<T>;
+	}
+	namespace no_adl {
+		template<tc::char_type Char, Char chFirst, Char chLast>
+			requires (restricted_enum_adl::detail::is_only_ascii(chFirst, chLast))
+		struct char_limits<tc::restricted_enum<Char, chFirst, chLast>> {
+			static constexpr std::size_t c_nMaxCodeUnitsPerCodePoint = 1;
+
+			[[nodiscard]] static constexpr bool interval_in_range(unsigned int nFirst, unsigned int nLast) noexcept {
+				return static_cast<unsigned>(chFirst) <= nFirst && nLast <= static_cast<unsigned>(chLast);
+			}
+		};
+	}
+
+}
diff --git a/tc/restricted_enum.t.cpp b/tc/restricted_enum.t.cpp
new file mode 100644
index 0000000..3496053
--- /dev/null
+++ b/tc/restricted_enum.t.cpp
@@ -0,0 +1,114 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "unittest.h"
+#include "restricted_enum.h"
+#include "string/char.h"
+#include "base/assert_defs.h"
+
+namespace {
+	// It's safe to compare when the character type can represent all allowed values with a single code point.
+	using char16_ascii = tc::restricted_enum<tc::char16, 0, 127>;
+	using char32_ascii = tc::restricted_enum<char32_t, 0, 127>;
+	static_assert(char16_ascii('0') == '0');
+	static_assert(char16_ascii('0') == tc_utf16('0'));
+	static_assert(char16_ascii('0') == U'0');
+	static_assert(char32_ascii('0') == '0');
+	static_assert(char32_ascii('0') == tc_utf16('0'));
+	static_assert(char32_ascii('0') == U'0');
+
+	using char16_cyrillic = tc::restricted_enum<tc::char16, 0x400, 0x4ff>;
+	// static_assert(char16_cyrillic(tc_utf16('\u0410')) == 'A');
+	static_assert(char16_cyrillic(tc_utf16('\u0410')) == tc_utf16('\u0410'));
+
+	using char32_cyrillic = tc::restricted_enum<char32_t, 0x400, 0x4ff>;
+	// static_assert(char32_cyrillic(U'\u0410') == 'A');
+	static_assert(char32_cyrillic(U'\u0410') == U'\u0410');
+
+	using char32_miscellaneous_symbols_and_pictographs = tc::restricted_enum<char32_t, 0x1f300, 0x1f5ff>;
+	// static_assert(char32_miscellaneous_symbols_and_pictographs(U'\U0001f47e') == '0');
+	// static_assert(char32_miscellaneous_symbols_and_pictographs(U'\U0001f47e') == tc_utf16('0'));
+	static_assert(char32_miscellaneous_symbols_and_pictographs(U'\U0001f47e') == U'\U0001f47e');
+
+
+	void implicit_cast() noexcept {
+		// Should implicitly convert to less restrictive ranges.
+		using char16_asciilower = tc::restricted_enum<tc::char16, tc_utf16('a'), tc_utf16('z')>;
+		char16_asciilower chAsciiLower('a');
+		{
+			char16_ascii chAscii(chAsciiLower);
+		}
+		{
+			char16_ascii chAscii = chAsciiLower;
+			chAscii = chAsciiLower;
+		}
+	}
+
+	void test() {
+		using char16_including_surrogates = tc::restricted_enum<tc::char16, tc_utf16('\0'), tc_utf16('\uffff')>;
+		// char16_including_surrogates ch; // Doesn't compile: there are code units in this range that are not a code point
+	}
+}
+
+namespace {
+	TC_DEFINE_ENUM(ELetter, eletter, (A)(B)(C));
+
+	using ELetterAB = tc::restricted_enum<ELetter, eletterA, eletterB>;
+	using ELetterB = tc::restricted_enum<ELetter, eletterB, eletterB>;
+	using ELetterBC = tc::restricted_enum<ELetter, eletterB, eletterC>;
+	void restricted_enums() noexcept {
+		static constexpr ELetterAB eletterabA(eletterA);
+		static constexpr ELetterAB eletterabB(eletterB);
+		ELetterAB eletterabOutput;
+		eletterabOutput = eletterabA;
+		eletterabOutput = eletterA;
+		ELetterBC eletterbcOutput;
+		eletterbcOutput = eletterabA;
+		_ASSERTEQUAL(eletterabOutput, eletterbcOutput);
+		// _ASSERTEQUAL(eletterabOutput, tc::char_ascii('0')); // Doesn't compile: nonsensical comparison.
+		static constexpr ELetterB eletterb(eletterB);
+		_ASSERTEQUAL(eletterabA - eletterabOutput, 0);
+		_ASSERTEQUAL(eletterabOutput + (eletterabB - eletterabOutput), eletterabB);
+
+		[](ELetter) noexcept {}(eletterA);
+		[](ELetter) noexcept {}(eletterabA);
+
+		// [](ELetterAB) noexcept {}(eletterA); // Doesn't compile: can't be implicit
+		// [](ELetterAB) noexcept {}(tc::implicit_cast<ELetterAB>(eletterA)); // Doesn't compile: can't be implicit
+		[](ELetterAB) noexcept {}(tc::explicit_cast<ELetterAB>(eletterA)); // Compiles: it's explicit
+		[](ELetterAB) noexcept {}(eletterb); // Compiles: it's more specific
+
+		[](ELetterB) noexcept {}(tc::explicit_cast<ELetterB>(eletterabA)); // Compiles: it's explicit
+		[](ELetterB) noexcept {}(tc::explicit_cast<ELetterB>(eletterA)); // Compiles: it's explicit
+
+		[](ELetterBC) noexcept {}(tc::explicit_cast<ELetterBC>(eletterB)); // Compiles: it's explicit
+		[](ELetterBC) noexcept {}(eletterb); // Compiles: it's more specific
+	}
+}
+
+UNITTESTDEF(restricted_enum_arithmetic) {
+	char16_ascii ch('b');
+	ch += 1;
+	_ASSERTEQUAL(ch, 'c');
+	ch -= 2;
+	_ASSERTEQUAL(ch, 'a');
+
+	_ASSERTEQUAL(char16_ascii('a') + 2, 'c');
+	_ASSERTEQUAL(char16_ascii('c') - 2, 'a');
+	_ASSERTEQUAL(char16_ascii('c') - char16_ascii('a'), 2);
+
+	ELetterAB eletterab(eletterA);
+	eletterab += 1;
+	_ASSERTEQUAL(eletterab, eletterB);
+	eletterab -= 1;
+	_ASSERTEQUAL(eletterab, eletterA);
+
+	_ASSERTEQUAL(ELetterAB(eletterA) + 1, eletterB);
+	_ASSERTEQUAL(ELetterAB(eletterB) - 1, eletterA);
+	_ASSERTEQUAL(ELetterAB(eletterB) - ELetterAB(eletterA), 1);
+}
diff --git a/tc/static_vector.h b/tc/static_vector.h
index 6332468..4372257 100644
--- a/tc/static_vector.h
+++ b/tc/static_vector.h
@@ -72,7 +72,7 @@ namespace tc {
 					throw;
 				}
 			}
-
+		protected:
 			[[nodiscard]] constexpr T* data() & noexcept {
 				return m_aot[0].uninitialized_addressof();
 			}
@@ -134,7 +134,7 @@ namespace tc {
 					throw;
 				}
 			}
-
+		protected:
 			[[nodiscard]] constexpr T* data() & noexcept {
 				return std::addressof(m_a.m_at[0]);
 			}
diff --git a/tc/storage_for.h b/tc/storage_for.h
index 233c0c8..00f52ee 100644
--- a/tc/storage_for.h
+++ b/tc/storage_for.h
@@ -32,7 +32,7 @@ namespace tc {
 		template<typename T>
 		struct storage_for_select_dtor_base<T, false> {
 			constexpr storage_for_select_dtor_base() noexcept {}
-			constexpr ~storage_for_select_dtor_base() noexcept {}
+			constexpr ~storage_for_select_dtor_base() {}
 
 			union {
 				uninitalized_storage_dummy m_dummy;
@@ -43,7 +43,7 @@ namespace tc {
 		template<typename T>
 		struct storage_for_select_dtor_base<T, /*is_trivially_destructible*/true> {
 			constexpr storage_for_select_dtor_base() noexcept {}
-			constexpr ~storage_for_select_dtor_base() noexcept = default;
+			constexpr ~storage_for_select_dtor_base() = default;
 
 			union {
 				uninitalized_storage_dummy m_dummy;
@@ -125,8 +125,7 @@ namespace tc {
 				tc::dtor_static(tc::as_mutable(this->m_buffer));
 			}
 		protected:
-			STATIC_VIRTUAL_CONSTEXPR(dereference)
-			STATIC_OVERRIDE_MOD(constexpr, dereference)() const& -> T const& {
+			STATIC_VIRTUAL_WITH_DEFAULT_IMPL_MOD(constexpr, dereference)() const& -> T const& {
 				STATICASSERTEQUAL( sizeof(storage_for_base), sizeof(T) ); // no extra members, important for arrays
 				return this->m_buffer;
 			}
@@ -139,8 +138,7 @@ namespace tc {
 			using this_type = storage_for_base<Derived, T&>;
 			T* m_buffer;
 
-			STATIC_VIRTUAL_CONSTEXPR(dereference)
-			STATIC_OVERRIDE_MOD(constexpr, dereference)() const& -> T& {
+			STATIC_VIRTUAL_WITH_DEFAULT_IMPL_MOD(constexpr, dereference)() const& -> T& {
 				return *m_buffer;
 			}
 		public:
@@ -169,8 +167,7 @@ namespace tc {
 			using this_type = storage_for_base<Derived, T&&>;
 			T* m_buffer;
 
-			STATIC_VIRTUAL_CONSTEXPR(dereference)
-			STATIC_OVERRIDE_MOD(constexpr, dereference)() const& -> T&& {
+			STATIC_VIRTUAL_WITH_DEFAULT_IMPL_MOD(constexpr, dereference)() const& -> T&& {
 				return static_cast<T&&>(*m_buffer);
 			}
 		public:
diff --git a/tc/string/ascii.h b/tc/string/ascii.h
index 0729378..42c2f70 100644
--- a/tc/string/ascii.h
+++ b/tc/string/ascii.h
@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "value_restrictive.h"
+#include "char.h"
 #include "../base/assert_defs.h"
 #include "../base/explicit_cast.h"
 #include "../range/meta.h"
@@ -48,13 +48,23 @@ namespace tc {
 
 	template< typename T >
 	[[nodiscard]] constexpr bool isasciiblank( T ch ) noexcept {
+		// in C locale, it is:
+		// ' '	(0x20) space (SPC)
+		// '\t'	(0x09) horizontal tab (TAB)
 		return tc::char_ascii('\t')==ch || tc::char_ascii(' ')==ch;
 	}
 
 	template< typename T >
 	[[nodiscard]] constexpr bool isasciispace( T ch ) noexcept {
+		// in C locale, it is:
+		// ' '	(0x20) space (SPC)
+		// '\t'	(0x09) horizontal tab (TAB)
+		// '\n'	(0x0a) newline (LF)
+		// '\v'	(0x0b) vertical tab (VT)
+		// '\f'	(0x0c) feed (FF)
+		// '\r'	(0x0d) carriage return (CR)
 		return tc::isasciiblank(ch) ||
-			(tc::char_ascii('\xa')<=ch && ch<=tc::char_ascii('\xd')); // \n, \v, \f, \r
+			(tc::char_ascii('\xa')<=ch && ch<=tc::char_ascii('\xd'));
 	}
 
 	template< typename T >
@@ -127,7 +137,7 @@ namespace tc {
 	}
 
 	namespace ascii_byte_literals {
-		constexpr auto operator "" _asc(char ch) noexcept {
+		constexpr auto operator "" _asc(char const ch) noexcept {
 			// Don't use hex or octal escapes; use the char code directly. For example, use 0x80 instead of '\x80'_asc
 			// Other ASCII control characters may be added here as exceptions.
 			_ASSERTE((ch >= 0x20 && ch <= 0x7E) || ch == '\r' || ch == '\n' || ch == '\t');
diff --git a/tc/string/char.h b/tc/string/char.h
new file mode 100644
index 0000000..2464a88
--- /dev/null
+++ b/tc/string/char.h
@@ -0,0 +1,175 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "../base/string_template_param.h"
+#include "../range/literal_range.h"
+#include "../array.h"
+#include "../restricted_enum.h"
+
+namespace tc {
+	using char_ascii = tc::restricted_enum<char, '\0', '\x7f'>;
+	using char_asciidigit = tc::restricted_enum<char, '0', '9'>;
+	using char_asciilower = tc::restricted_enum<char, 'a', 'z'>;
+	using char_asciiupper = tc::restricted_enum<char, 'A', 'Z'>;
+
+	namespace no_adl {
+#pragma push_macro("CUSTOMIZE_COMMON_TYPE_CHAR_ASCII")
+#define CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char_type) \
+		template<> \
+		struct common_type_decayed<tc::char_ascii, char_type> { \
+			using type = char_type; \
+		}; \
+		template<> \
+		struct common_type_decayed<char_type, tc::char_ascii> { \
+			using type = char_type; \
+		};
+
+		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char)
+		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(wchar_t)
+		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char16_t)
+		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char32_t)
+#pragma pop_macro("CUSTOMIZE_COMMON_TYPE_CHAR_ASCII")
+	}
+}
+
+template<tc::char_type Char, Char chFirst, Char chLast>
+struct std::char_traits<tc::restricted_enum<Char, chFirst, chLast>> final {
+	using char_type = tc::restricted_enum<Char, chFirst, chLast>;
+	using int_type = typename tc::char_traits<Char>::int_type;
+	using off_type = typename tc::char_traits<Char>::off_type;
+	using pos_type = typename tc::char_traits<Char>::pos_type;
+	using state_type = typename tc::char_traits<Char>::state_type;
+
+	static constexpr void assign(char_type& r, const char_type& a) noexcept {
+		r = a;
+	}
+
+	static char_type* assign(char_type* p, std::size_t count, char_type a) {
+		std::fill(p, p+count, a);
+		return p;
+	}
+
+	static constexpr bool eq(char_type a, char_type b) noexcept {
+		return a == b;
+	}
+
+	static constexpr bool lt(char_type a, char_type b) noexcept {
+		return a < b;
+	}
+
+	static constexpr std::size_t length(const char_type* s) {
+		std::size_t n = 0;
+		if(s) {
+			while(char_type() != *s++)
+				++n;
+		}
+		return n;
+	}
+
+	static constexpr const char_type* find(const char_type* p, std::size_t count, const char_type& ch) {
+		while(0<count) {
+			if(*p == ch) {
+				return p;
+			} else {
+				++p;
+				--count;
+			}
+		}
+		return nullptr;
+	}
+
+	static constexpr int compare(const char_type* s1, const char_type* s2, std::size_t count) {
+		for(std::size_t i=0; i<count; ++i) {
+			if (*s1<*s2) return -1;
+			else if (*s2<*s1) return 1;
+		}
+		return 0;
+	}
+
+	static char_type* move(char_type* dest, const char_type* src, std::size_t count) {
+		if (src <= dest && dest < src+count) {
+			std::copy_backward(src, src+count, dest+count);
+		} else {
+			std::copy(src, src+count, dest);
+		}
+		return dest;
+	}
+
+	static char_type* copy(char_type* dest, const char_type* src, std::size_t count) {
+		return move(dest, src, count); // copy works correctly just like move in clang and gcc's implementation
+	}
+};
+
+namespace tc {
+#if WCHAR_MAX == 0xFFFF // == 2 bytes unsigned: We want tc::char16 to be unsigned. wchar_t is unsigned on MSVC, but that's implementation-specific.
+	using char16 = wchar_t;
+	#define tc_raw_utf16_(x) L ## x
+#else
+	using char16 = char16_t;
+	#define tc_raw_utf16_(x) u ## x
+#endif
+#define tc_raw_utf16(x) tc_raw_utf16_(x)
+#define tc_utf16(x) tc_raw_utf16(x)
+}
+
+#define tc_ascii_val(str) tc::make_array<tc::char_ascii>(str)  // avoid copy
+#define tc_ascii(str) tc_as_constexpr(tc_ascii_val(str))
+
+namespace tc {
+	template <tc::string_template_param String>
+	constexpr bool is_ascii_string_literal = []{
+		// Simple for loop to avoid any cyclic dependencies.
+		for (auto c : String) {
+			if (static_cast<unsigned>(tc::to_underlying(c)) > 0x7F) return false;
+		}
+		return true;
+	}();
+
+	template <tc::string_template_param String>
+	constexpr auto string_literal = []<std::size_t ... I>(std::index_sequence<I...>){
+		using char_type = tc::range_value_t<decltype(String)>;
+		static_assert(!std::same_as<char_type, wchar_t>, "use either u or U prefix to force UTF-16 or UTF-32; not L");
+
+		if constexpr (std::same_as<char_type, char>) {
+			return tc::literal_range<tc::char_ascii, String[I]...>{};
+		} else if constexpr (std::same_as<char_type, char8_t>) {
+			return tc::literal_range<char, String[I]...>{};
+		} else if constexpr (std::same_as<char_type, char16_t>) {
+			return tc::literal_range<tc::char16, String[I]...>{};
+		} else {
+			return tc::literal_range<char_type, String[I]...>{};
+		}
+	}(std::make_index_sequence<tc::constexpr_size<decltype(String)>()>());
+}
+
+// "abc"_tc -> ASCII-8 string with char type tc::char_ascii
+// u8"abc"_tc -> UTF-8 string with char type char
+// u"abc"_tc -> UTF-16 string with char type tc::char16
+// U"abc"_tc -> UTF-32 string with char type char32_t
+template <tc::string_template_param String>
+[[nodiscard]] constexpr auto operator""_tc() noexcept {
+	return tc::string_literal<String>;
+}
+
+// 8-bit character literal is always ASCII.
+[[nodiscard]] constexpr auto operator""_tc(char const c) noexcept {
+	return tc::char_ascii(c);
+}
+[[nodiscard]] constexpr auto operator""_tc(char8_t const c) noexcept {
+	return char(c);
+}
+[[nodiscard]] constexpr auto operator""_tc(char16_t const c) noexcept {
+	return tc::char16(c);
+}
+[[nodiscard]] constexpr auto operator""_tc(char32_t const c) noexcept {
+	return c;
+}
+// This is not portable.
+void operator""_tc(wchar_t) = delete;
diff --git a/tc/string/value_restrictive.t.cpp b/tc/string/char.t.cpp
similarity index 51%
rename from tc/string/value_restrictive.t.cpp
rename to tc/string/char.t.cpp
index 2a394be..4d0ae0c 100644
--- a/tc/string/value_restrictive.t.cpp
+++ b/tc/string/char.t.cpp
@@ -11,7 +11,7 @@
 #include "../algorithm/append.h"
 #include "../container/insert.h"
 #include "../container/cont_assign.h"
-#include "value_restrictive.h"
+#include "char.h"
 
 static_assert(std::is_trivial<tc::char_ascii>::value);
 static_assert(std::is_trivially_copyable<tc::char_ascii>::value);
@@ -26,8 +26,6 @@ static_assert(is_convertible_to_ascii_supporting_types<tc::char_asciilower>::val
 static_assert(is_convertible_to_ascii_supporting_types<tc::char_asciiupper>::value);
 static_assert(is_convertible_to_ascii_supporting_types<tc::char_asciidigit>::value);
 
-template <auto V> struct print;
-
 static_assert(tc::char_ascii('a') == 'a' && 'a' == tc::char_ascii('a'));
 static_assert(tc::char_ascii('a') == u'a' && u'a' == tc::char_ascii('a'));
 static_assert(tc::size("abc"_tc) == 3);
@@ -48,103 +46,6 @@ static_assert(tc::char_ascii('9') == tc::char_asciidigit('9') && tc::char_asciid
 static_assert(tc::char_ascii('9') != tc::char_asciidigit('0') && tc::char_asciidigit('0') != tc::char_ascii('9'));
 static_assert(tc::char_ascii(' ') != tc::char_asciidigit('0') && tc::char_asciidigit('0') != tc::char_ascii(' '));
 
-namespace {
-	// It's safe to compare when the character type can represent all allowed values with a single code point.
-	using char16_ascii = tc::value_restrictive<tc::char16, 0, 127>;
-	using char32_ascii = tc::value_restrictive<char32_t, 0, 127>;
-	static_assert(char16_ascii('0') == '0');
-	static_assert(char16_ascii('0') == UTF16('0'));
-	static_assert(char16_ascii('0') == U'0');
-	static_assert(char32_ascii('0') == '0');
-	static_assert(char32_ascii('0') == UTF16('0'));
-	static_assert(char32_ascii('0') == U'0');
-
-	using char16_cyrillic = tc::value_restrictive<tc::char16, 0x400, 0x4ff>;
-	// static_assert(char16_cyrillic(UTF16('\u0410')) == 'A');
-	static_assert(char16_cyrillic(UTF16('\u0410')) == UTF16('\u0410'));
-
-	using char32_cyrillic = tc::value_restrictive<char32_t, 0x400, 0x4ff>;
-	// static_assert(char32_cyrillic(U'\u0410') == 'A');
-	static_assert(char32_cyrillic(U'\u0410') == UTF16('\u0410'));
-	static_assert(char32_cyrillic(U'\u0410') == U'\u0410');
-
-	using char32_miscellaneous_symbols_and_pictographs = tc::value_restrictive<char32_t, 0x1f300, 0x1f5ff>;
-	// static_assert(char32_miscellaneous_symbols_and_pictographs(U'\U0001f47e') == '0');
-	// static_assert(char32_miscellaneous_symbols_and_pictographs(U'\U0001f47e') == UTF16('0'));
-	static_assert(char32_miscellaneous_symbols_and_pictographs(U'\U0001f47e') == U'\U0001f47e');
-
-
-	void implicit_cast() noexcept {
-		// Should implicitly convert to less restrictive ranges.
-		using char16_asciilower = tc::value_restrictive<tc::char16, UTF16('a'), UTF16('z')>;
-		char16_asciilower chAsciiLower('a');
-		{
-			char16_ascii chAscii(chAsciiLower);
-		}
-		{
-			char16_ascii chAscii = chAsciiLower;
-			chAscii = chAsciiLower;
-		}
-	}
-
-	void test() {
-		using char16_including_surrogates = tc::value_restrictive<tc::char16, UTF16('\0'), UTF16('\uffff')>;
-		// char16_including_surrogates ch; // Doesn't compile: there are code units in this range that are not a code point
-	}
-}
-
-namespace {
-	TC_DEFINE_ENUM(ELetter, eletter, (A)(B)(C));
-}
-
-namespace {
-	using ELetterAB = tc::value_restrictive<ELetter, eletterA, eletterB>;
-	using ELetterB = tc::value_restrictive<ELetter, eletterB, eletterB>;
-	using ELetterBC = tc::value_restrictive<ELetter, eletterB, eletterC>;
-	void restricted_enums() noexcept {
-		static constexpr ELetterAB eletterabA(eletterA);
-		static constexpr ELetterAB eletterabB(eletterB);
-		ELetterAB eletterabOutput;
-		eletterabOutput = eletterabA;
-		eletterabOutput = eletterA;
-		ELetterBC eletterbcOutput;
-		eletterbcOutput = eletterabA;
-		_ASSERTEQUAL(eletterabOutput, eletterbcOutput);
-		// _ASSERTEQUAL(eletterabOutput, tc::char_ascii('0')); // Doesn't compile: nonsensical comparison.
-		static constexpr ELetterB eletterb(eletterB);
-		_ASSERTEQUAL(eletterabA - eletterabOutput, 0);
-		_ASSERTEQUAL(eletterabOutput + (eletterabB - eletterabOutput), eletterabB);
-
-		[](ELetter) noexcept {}(eletterA);
-		[](ELetter) noexcept {}(eletterabA);
-
-		// [](ELetterAB) noexcept {}(eletterA); // Doesn't compile: no conversion operator
-		// [](ELetterAB) noexcept {}(tc::implicit_cast<ELetterAB>(eletterA)); // Doesn't compile: can't be implicit
-		[](ELetterAB) noexcept {}(tc::explicit_cast<ELetterAB>(eletterA)); // Compiles: it's explicit
-		[](ELetterAB) noexcept {}(eletterb); // Compiles: it's more specific
-
-		[](ELetterB) noexcept {}(tc::explicit_cast<ELetterB>(eletterabA)); // Compiles: it's explicit
-		[](ELetterB) noexcept {}(tc::explicit_cast<ELetterB>(eletterA)); // Compiles: it's explicit
-
-		[](ELetterBC) noexcept {}(tc::explicit_cast<ELetterBC>(eletterB)); // Compiles: it's explicit
-		[](ELetterBC) noexcept {}(eletterb); // Compiles: it's more specific
-	}
-}
-
-UNITTESTDEF(value_restrictive_arithmetic) {
-	tc::char_ascii ch('b');
-	ch += 1;
-	_ASSERTEQUAL(ch, 'c');
-	ch -= 2;
-	_ASSERTEQUAL(ch, 'a');
-
-	ELetterAB eletterab(eletterA);
-	eletterab += 1;
-	_ASSERTEQUAL(eletterab, eletterB);
-	eletterab -= 1;
-	_ASSERTEQUAL(eletterab, eletterA);
-}
-
 UNITTESTDEF(append_char_ascii) {
 	tc::string<char> str1;
 	tc::cont_emplace_back(str1, tc::char_ascii('a'));
@@ -191,3 +92,36 @@ static_assert(std::is_same<char, tc::common_type_t<char, tc::char_ascii>>::value
 static_assert(std::is_same<char, tc::common_type_t<tc::char_ascii, char>>::value);
 static_assert(std::is_same<wchar_t, tc::common_type_t<wchar_t, tc::char_ascii>>::value);
 static_assert(std::is_same<wchar_t, tc::common_type_t<tc::char_ascii, wchar_t>>::value);
+
+static_assert(0 == std::numeric_limits<tc::char16>::lowest() && 0xFFFF == std::numeric_limits<tc::char16>::max());
+
+UNITTESTDEF(string_literal) {
+	auto ascii = "abc"_tc;
+	STATICASSERTSAME(decltype(ascii), (tc::literal_range<tc::char_ascii, 'a', 'b', 'c'>));
+
+	// Due to the bug shown in https://godbolt.org/z/Kzc8orP4j, we can't use the same characters as the ASCII string.
+	// (MSVC thinks u8"abc" is the same instantiation as "abc" and re-uses the same result.)
+	// It is already fixed in newer versions of MSVC and shouldn't affect our codebase - why would we have an ASCII and a UTF-8 string with the same characters.
+	auto utf8 = u8"ABC"_tc;
+	STATICASSERTSAME(decltype(utf8), (tc::literal_range<char, u8'A', u8'B', u8'C'>));
+
+	auto utf16 = u"abc"_tc;
+	STATICASSERTSAME(decltype(utf16), (tc::literal_range<tc::char16, u'a', u'b', u'c'>));
+
+	auto utf32 = U"abc"_tc;
+	STATICASSERTSAME(decltype(utf32), (tc::literal_range<char32_t, U'a', U'b', U'c'>));
+}
+
+UNITTESTDEF(char_literal) {
+	std::same_as<tc::char_ascii> auto ascii = 'a'_tc;
+	_ASSERTEQUAL(ascii, 'a');
+
+	std::same_as<char> auto utf8 = u8'a'_tc;
+	_ASSERTEQUAL(utf8, 'a');
+
+	std::same_as<tc::char16> auto utf16 = u'a'_tc;
+	_ASSERTEQUAL(utf16, static_cast<tc::char16>('a'));
+
+	std::same_as<char32_t> auto utf32 = U'a'_tc;
+	_ASSERTEQUAL(utf32, U'a');
+}
diff --git a/tc/string/convert_enc.h b/tc/string/convert_enc.h
index 11ab2f9..dbebf06 100644
--- a/tc/string/convert_enc.h
+++ b/tc/string/convert_enc.h
@@ -15,11 +15,51 @@
 #include "../algorithm/compare.h"
 #include "../range/range_adaptor.h"
 
-#include "value_restrictive.h"
+#include "char.h"
 
 namespace tc {
+	// Code unit predicates
+	//
+	// These names are based on the terminology used in the Unicode Standard: https://www.unicode.org/versions/Unicode13.0.0/UnicodeStandard-13.0.pdf
+	// "(...) reserved for the first, or leading, element of a UTF-8 code unit sequences, (...) reserved for the subsequent, or trailing, elements of such sequences;"
+	// "(...) for the lead, trail, or single code units in any of those encoding forms overlap."
+	[[nodiscard]] constexpr bool is_leading_codeunit(char const ch) noexcept {
+		return 0xc0 == (ch & 0xc0); // matches 11xxxxxx
+	}
+	[[nodiscard]] constexpr bool is_leading_codeunit(tc::char16 const ch) noexcept {
+		return 0xd800u == (ch & 0xfc00u); // high surrogate
+	}
+	template <tc::char_type Char, Char chFirst, Char chLast>
+	[[nodiscard]] constexpr auto is_leading_codeunit(tc::restricted_enum<Char, chFirst, chLast> const ch) noexcept {
+		if constexpr(chLast < 0x80) {
+			return tc::constant<false>{};
+		} else {
+			return is_leading_codeunit(tc::implicit_cast<Char>(ch));
+		}
+	}
+
+	[[nodiscard]] constexpr bool is_trailing_codeunit(char const ch) noexcept {
+		return 0x80 == (ch & 0xc0); // matches 10xxxxxx
+	}
+	[[nodiscard]] constexpr bool is_trailing_codeunit(tc::char16 const ch) noexcept {
+		return 0xdc00u == (ch & 0xfc00u); // low surrogate
+	}
+	template <tc::char_type Char, Char chFirst, Char chLast>
+	[[nodiscard]] constexpr auto is_trailing_codeunit(tc::restricted_enum<Char, chFirst, chLast> const ch) noexcept {
+		if constexpr(chLast < 0x80) {
+			return tc::constant<false>{};
+		} else {
+			return is_trailing_codeunit(tc::implicit_cast<Char>(ch));
+		}
+	}
+
+	template<typename T>
+	[[nodiscard]] constexpr bool is_single_codeunit(T const ch) noexcept {
+		return char_in_range<T>(tc::to_underlying(ch));
+	}
+
 	namespace codeunit_sequence_size_detail {
-		[[nodiscard]] constexpr inline std::optional<int> codeunit_sequence_size_raw(char ch) noexcept {
+		[[nodiscard]] constexpr inline std::optional<int> codeunit_sequence_size_raw(char const ch) noexcept {
 			if( auto const n=0xffu & ~tc::to_underlying(ch); 0!=n ) { // code unit 0xff is invalid
 				switch(tc::index_of_most_significant_bit(n)) {
 					case 7: return 1;
@@ -33,13 +73,13 @@ namespace tc {
 		}
 
 		// tc::make_interval not used to avoid dependency cycle
-		[[nodiscard]] constexpr std::optional<int> codeunit_sequence_size_raw(tc::char16 ch) noexcept {
+		[[nodiscard]] constexpr std::optional<int> codeunit_sequence_size_raw(tc::char16 const ch) noexcept {
 			if( auto const n=tc::to_underlying(ch); n<0xd800u || 0xdfffu<n) return 1;
 			else if( n<0xdc00u ) return 2; // high-surrogate
 			else return std::nullopt; // low-surrogate, continuation
 		}
 
-		[[nodiscard]] constexpr std::optional<int> codeunit_sequence_size_raw(tc::char_ascii ch) noexcept {
+		[[nodiscard]] constexpr std::optional<int> codeunit_sequence_size_raw(tc::char_ascii const ch) noexcept {
 			return 1;
 		}
 
@@ -190,7 +230,7 @@ namespace tc {
 	}
 
 	template<typename Char>
-	constexpr Char codepoint_codeunit_at(unsigned int nCodePoint, int nCodeUnitIndex) noexcept {
+	constexpr Char codepoint_codeunit_at(unsigned int nCodePoint, int const nCodeUnitIndex) noexcept {
 		_ASSERTDEBUG(nCodePoint<0x110000u);
 		auto const nLastIndex=tc::codepoint_codeunit_count<Char>(nCodePoint) - 1;
 		if constexpr( std::same_as<char, Char> ) {
@@ -469,18 +509,18 @@ namespace tc {
 				return tc::for_each(*src, no_adl::convert_enc_sink<decltype(sink), Dst>(tc_move_if_owned(sink)));
 			});
 		}
-	}
 
-	template <typename T>
-	void foo() {
-			static_assert(tc::char_like<T>);
+		template <tc::char_like Dst, auto ... Cs>
+		[[nodiscard]] constexpr auto convert_literal(tc::literal_range<tc::char_ascii, Cs...>) noexcept {
+			// We cast the Cs to char, to keep a simple type as NTTP and because presumably every char_like type is constructible from char.
+			return tc::literal_range<Dst, tc::implicit_cast<char>(Cs)...>{};
+		}
 	}
 
-	template<tc::char_like Dst, typename Src> requires (!tc::instance_or_derived<std::remove_reference_t<Src>, convert_enc_impl::SStringConversionRange>)
+	template<tc::char_like Dst, typename Src>
 	[[nodiscard]] decltype(auto) convert_enc(Src&& src) noexcept {
 		if constexpr(tc::has_range_value<Src>::value) {
-			foo<tc::range_value_t<Src>>();
-			//static_assert(tc::char_like<tc::range_value_t<Src>>);
+			static_assert(tc::char_like<tc::range_value_t<Src>>);
 			if constexpr(tc::safely_convertible_to<tc::range_value_t<Src>, Dst>) {
 				return std::forward<Src>(src);
 			} else if constexpr(tc::char_type<Dst> && tc::char_type<tc::range_value_t<Src>> && tc::range_with_iterators<Src>) {
@@ -495,11 +535,16 @@ namespace tc {
 		}
 	}
 
-	template<tc::char_type Dst, typename Src> requires tc::instance_or_derived<std::remove_reference_t<Src>, convert_enc_impl::SStringConversionRange>
+	template<tc::char_like Dst, typename Src> requires tc::instance_or_derived<std::remove_reference_t<Src>, convert_enc_impl::SStringConversionRange>
 	[[nodiscard]] auto convert_enc(Src&& src) noexcept {
 		return tc::convert_enc<Dst>(tc_move_if_owned(src).base_range());
 	}
 
+	template<tc::char_like Dst, typename Src> requires tc::is_literal_range<Src> && std::same_as<tc::range_value_t<Src>, tc::char_ascii>
+	[[nodiscard]] auto convert_enc(Src&& src) noexcept {
+		return convert_enc_detail::convert_literal<Dst>(src);
+	}
+
 	namespace no_adl {
 		template<typename Sink, tc::char_like Dst>
 		struct convert_enc_sink /*final*/ {
@@ -522,10 +567,5 @@ namespace tc {
 			)
 		};
 	}
-
-	template<typename T>
-	[[nodiscard]] constexpr bool is_single_codeunit(T const ch) noexcept {
-		return char_in_range<T>(tc::to_underlying(ch));
-	}
 }
 
diff --git a/tc/string/convert_enc.t.cpp b/tc/string/convert_enc.t.cpp
index 35254c0..478f19c 100644
--- a/tc/string/convert_enc.t.cpp
+++ b/tc/string/convert_enc.t.cpp
@@ -44,8 +44,8 @@ static_assert(IsLeading(static_cast<char>("\u200B"[0])) && IsTrailing(static_cas
 
 // UTF-16
 
-static_assert(IsSingle(UTF16('\x7FFF')));
-static_assert(IsLeading(UTF16('\xD800')));
-static_assert(IsLeading(UTF16('\xDBFF')));
-static_assert(IsTrailing(UTF16('\xDC00')));
-static_assert(IsTrailing(UTF16('\xDFFF')));
+static_assert(IsSingle(tc_utf16('\x7FFF')));
+static_assert(IsLeading(tc_utf16('\xD800')));
+static_assert(IsLeading(tc_utf16('\xDBFF')));
+static_assert(IsTrailing(tc_utf16('\xDC00')));
+static_assert(IsTrailing(tc_utf16('\xDFFF')));
diff --git a/tc/string/format.h b/tc/string/format.h
index 20fac1e..97cce61 100644
--- a/tc/string/format.h
+++ b/tc/string/format.h
@@ -16,7 +16,7 @@
 #include "../range/subrange.h"
 #include "../range/concat_adaptor.h"
 #include "../range/repeat_n.h"
-#include "value_restrictive.h"
+#include "char.h"
 
 #ifdef __clang__
 #pragma clang diagnostic push
@@ -68,7 +68,8 @@ namespace tc {
 
 			template<typename Sink>
 			auto operator()(Sink&& sink) const& MAYTHROW {
-				return tc::for_each(tc::transform(tc::ptr_begin( boost::lexical_cast< std::array<char,50> >(m_n+0/*force integral promotion, otherwise unsigned/signed char gets printed as character*/) ), tc::fn_explicit_cast<tc::char_ascii>()), std::forward<Sink>(sink));
+				tc_auto_cref(str, boost::lexical_cast< std::array<char,50> >(m_n+0/*force integral promotion, otherwise unsigned/signed char gets printed as character*/));
+				return tc::for_each(tc::transform(tc::ptr_begin(str), tc::fn_explicit_cast<tc::char_ascii>()), std::forward<Sink>(sink));
 			}
 
 			constexpr bool empty() const& noexcept { return false; }
@@ -264,7 +265,7 @@ MODIFY_WARNINGS_END
 		};
 	}
 
-	template< typename T > requires tc::instance<std::remove_reference_t<T>, std::optional>
+	template< typename T > requires tc::instance<std::remove_reference_t<T>, std::optional> || tc::instance<std::remove_reference_t<T>, tc::optional>
 	auto bool_prefixed(T&& t) return_ctor_noexcept(
 		no_adl::bool_prefixed_impl<T>,
 		(aggregate_tag, std::forward<T>(t))
diff --git a/tc/string/jsonparser.h b/tc/string/jsonparser.h
new file mode 100644
index 0000000..8a31900
--- /dev/null
+++ b/tc/string/jsonparser.h
@@ -0,0 +1,1039 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "../interval.h"
+#include "char.h"
+#include "named.h"
+#include "spirit_algorithm.h"
+#include "parserbase.h"
+
+#include <boost/predef/architecture.h>
+#if BOOST_ARCH_X86
+# define TC_JSON_SIMD 1
+# include <emmintrin.h>
+#elif BOOST_ARCH_ARM
+# define TC_JSON_SIMD 1
+# ifdef TC_WIN
+#  include <arm64_neon.h> // https://developercommunity.visualstudio.com/t/ARM64EC-should-be-considered-in-arm_neon/1477300
+# else
+#  include <arm_neon.h>
+# endif
+#else
+# define TC_JSON_SIMD 0
+#endif
+
+namespace tc::json {
+	namespace no_adl {
+		template<typename Func>
+		struct simple_error_handler {
+			explicit simple_error_handler(Func func) noexcept
+				: m_func(tc_move(func))
+			{}
+
+			template<typename... Args>
+			void semantic_error(auto const& strJson, auto const& itch, Args&&...) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void end_unexpected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void end_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void char_expected(auto const& strJson, auto const& itch, tc::char_ascii const ch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void null_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void boolean_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void number_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void object_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void key_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void array_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void element_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void value_expected(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void unescaped_control_character(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void invalid_escape(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void invalid_encoding(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void nesting_too_deep(auto const& strJson, auto const& itch) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void must_contain_one_of_keys(auto const& strJson, auto const& itch, auto const& astrNames) const& MAYTHROW {
+				m_func(strJson);
+			}
+			void may_contain_only_one_of_keys(auto const& strJson, auto const& itch, auto const& astrNames) const& MAYTHROW {
+				m_func(strJson);
+			}
+
+		private:
+			Func m_func;
+		};
+
+		template<typename Index, typename Char>
+		struct SDecodeAdaptorIndex final {
+			Index m_baseidx;
+
+			friend bool operator==(SDecodeAdaptorIndex const& lhs, SDecodeAdaptorIndex const& rhs) noexcept = default;
+		};
+
+		template<typename Index>
+		struct SDecodeAdaptorIndex<Index, char> final {
+			Index m_baseidx;
+			int m_nCodeUnitIndex;
+
+			friend bool operator==(SDecodeAdaptorIndex const& lhs, SDecodeAdaptorIndex const& rhs) noexcept = default;
+		};
+
+		template< typename Rng >
+		struct [[nodiscard]] decode_adaptor
+			: tc::range_iterator_from_index<
+				decode_adaptor<Rng>,
+				SDecodeAdaptorIndex<tc::index_t<std::remove_reference_t<Rng>>, tc::range_value_t<Rng>>
+			>
+			, tc::range_adaptor_base_range<Rng>
+		{
+			constexpr decode_adaptor() = default;
+			using tc::range_adaptor_base_range<Rng>::range_adaptor_base_range;
+			using typename decode_adaptor::range_iterator_from_index::tc_index;
+
+			static constexpr bool c_bHasStashingIndex=tc::has_stashing_index<std::remove_reference_t<Rng>>::value;
+
+		private:
+			using this_type = decode_adaptor;
+			using Char=tc::range_value_t<Rng>;
+
+			template<bool bIncrement>
+			tc::char16 ParseUTF16CodeUnit(tc::index_t<std::remove_reference_t<Rng>>& baseidx) const& MAYTHROW {
+				_ASSERT(!tc::at_end_index(this->base_range(), baseidx));
+				int n;
+				auto it = tc::make_iterator(this->base_range(), baseidx);
+				VERIFY(x3::parse(it, tc::end(this->base_range()), x3::uint_parser<int, 16, 4, 4>(), n ));
+				if constexpr(bIncrement) {
+					baseidx = tc::iterator2index<Rng>(it);
+				}
+				return static_cast<tc::char16>(n);
+			}
+
+			template<bool bIncrement, typename SinkChar, typename SinkCodepoint>
+			auto ProcessEscaped(tc::index_t<std::remove_reference_t<Rng>>& baseidx, SinkChar sinkch, SinkCodepoint sinkcp) const& MAYTHROW {
+				 // read_string should have ensured well-formed escaping, so we can _ASSERT for it.
+				auto& base=this->base_range();
+				tc::increment_index(base, baseidx);
+				_ASSERT(!tc::at_end_index(base, baseidx));
+				auto const ch=tc::dereference_index(base, baseidx);
+				switch_no_default(ch) {
+				case tc::explicit_cast<Char>('"'):
+				case tc::explicit_cast<Char>('\\'):
+				case tc::explicit_cast<Char>('/'):
+					if constexpr(bIncrement) tc::increment_index(base, baseidx);
+					return sinkch(ch);
+				case tc::explicit_cast<Char>('b'):
+					if constexpr(bIncrement) tc::increment_index(base, baseidx);
+					return sinkch(tc::explicit_cast<Char>('\b'));
+				case tc::explicit_cast<Char>('f'):
+					if constexpr(bIncrement) tc::increment_index(base, baseidx);
+					return sinkch(tc::explicit_cast<Char>('\f'));
+				case tc::explicit_cast<Char>('n'):
+					if constexpr(bIncrement) tc::increment_index(base, baseidx);
+					return sinkch(tc::explicit_cast<Char>('\n'));
+				case tc::explicit_cast<Char>('r'):
+					if constexpr(bIncrement) tc::increment_index(base, baseidx);
+					return sinkch(tc::explicit_cast<Char>('\r'));
+				case tc::explicit_cast<Char>('t'):
+					if constexpr(bIncrement) tc::increment_index(base, baseidx);
+					return sinkch(tc::explicit_cast<Char>('\t'));
+				case tc::explicit_cast<Char>('u'):
+					tc::increment_index(base, baseidx);
+					{
+						if constexpr(std::same_as<Char, tc::char16>) {
+							return sinkch(ParseUTF16CodeUnit<bIncrement>(baseidx));
+						} else {
+							char32_t ch32 = U'\uFFFD'; // REPLACEMENT CHARACTER
+							tc::char16 const ch0 = ParseUTF16CodeUnit<true>(baseidx);
+							if(tc::is_leading_codeunit(ch0)) {
+								if(!tc::at_end_index(base, baseidx) && tc::char_ascii('\\') == tc::dereference_index(base, baseidx)) {
+									std::conditional_t<bIncrement, tc::decay_t<decltype(baseidx)>, decltype(baseidx)> baseidxPeek = baseidx;
+									tc::increment_index(base, baseidxPeek);
+									_ASSERT(!tc::at_end_index(base, baseidxPeek));
+									if('u'_tc == tc::dereference_index(base, baseidxPeek)) {
+										tc::increment_index(base, baseidxPeek);
+										tc::char16 const ch1 = ParseUTF16CodeUnit<bIncrement>(baseidxPeek);
+										if(tc::is_trailing_codeunit(ch1)) {
+											if constexpr(bIncrement) baseidx = tc_move(baseidxPeek); // only consume subsequent UTF-16 escape sequence, if a valid UTF-16 code unit sequence is formed.
+											ch32 = tc::surrogate_pair_value(ch0, ch1);
+										}
+									}
+								}
+							} else if(!tc::is_trailing_codeunit(ch0)) {
+								tc::assign_explicit_cast(ch32, ch0);
+							}
+							if constexpr(std::same_as<Char, char32_t>) {
+								return sinkch(ch32);
+							} else {
+								return sinkcp(ch32);
+							}
+						}
+					}
+				}
+			}
+
+
+			STATIC_FINAL(begin_index)() const& return_MAYTHROW(
+				tc_index{this->base_begin_index()} // m_nCodeUnitIndex zero-initialized, if present
+			)
+
+			STATIC_FINAL(end_index)() const& MAYTHROW requires tc::has_end_index<Rng> {
+				return tc_index{this->base_end_index()}; // m_nCodeUnitIndex zero-initialized, if present
+			}
+
+			STATIC_FINAL(at_end_index)(tc_index const& idx) const& return_MAYTHROW(
+				tc::at_end_index(this->base_range(), idx.m_baseidx)
+			)
+
+			STATIC_FINAL(dereference_index)(tc_index const& idx) const& MAYTHROW {
+				auto& base=this->base_range();
+				auto t=tc::dereference_index(base, idx.m_baseidx); // we return characters, which we can always return by value
+				if(tc::char_ascii('\\')==t) {
+					return ProcessEscaped<false>(
+						tc::as_lvalue(tc::decay_copy(idx.m_baseidx)),
+						/*sinkch*/tc::identity(),
+						/*sinkcp*/[&](auto const ch32) noexcept {
+							STATICASSERTSAME(decltype(ch32), char32_t const);
+							return tc::codepoint_codeunit_at<Char>(static_cast<unsigned int>(ch32), idx.m_nCodeUnitIndex);
+						}
+					);
+				} else {
+					return t;
+				}
+			}
+
+			STATIC_FINAL(increment_index)(tc_index& idx) const& MAYTHROW -> void {
+				auto& base=this->base_range();
+				if(tc::char_ascii('\\')==tc::dereference_index(base, idx.m_baseidx)) {
+					auto baseidxOriginal = idx.m_baseidx;
+					ProcessEscaped<true>(
+						idx.m_baseidx,
+						/*sinkch*/tc::noop(),
+						/*sinkcp*/[&](auto const ch32) noexcept {
+							if constexpr(std::same_as<Char, char>) {
+								if(++idx.m_nCodeUnitIndex == tc::codepoint_codeunit_count<char>(static_cast<unsigned int>(ch32))) {
+									idx.m_nCodeUnitIndex = 0;
+								} else {
+									idx.m_baseidx = tc_move(baseidxOriginal);
+								}
+							}
+						}
+					);
+				} else {
+					tc::increment_index(base, idx.m_baseidx);
+					_ASSERTDEBUGEQUAL(idx.m_nCodeUnitIndex, 0);
+				}
+			}
+
+		public:
+			static constexpr auto border_base_index(tc_index const& idx) noexcept {
+				if constexpr( std::same_as<Char, char> ) {
+					_ASSERTEQUAL(idx.m_nCodeUnitIndex, 0);
+				}
+				return idx.m_baseidx;
+			}
+
+			template<ENABLE_SFINAE, typename Sink>
+			auto operator()(Sink sink) const& MAYTHROW -> tc::common_type_t<decltype(tc::continue_if_not_break(sink, tc::dereference_index(SFINAE_VALUE(this)->base_range(), std::declval<tc_index const&>))), tc::constant<tc::continue_>>{
+				auto& base=this->base_range();
+				auto idx=this->base_begin_index();
+				for(;;) {
+					if(tc::at_end_index(base, idx)) return tc::constant<tc::continue_>();
+					if(tc::char_ascii('\\')!=tc::dereference_index(base, idx)) {
+						auto idxBegin=idx;
+						do {
+							tc::increment_index(base, idx);
+							if(tc::at_end_index(base, idx)) {
+								return tc::for_each(tc::slice(base, idxBegin, idx), sink);
+							}
+						} while(tc::char_ascii('\\')!=tc::dereference_index(base, idx));
+						tc_return_if_break( tc::for_each(tc::slice(base, idxBegin, idx), sink) );
+					}
+					tc_return_if_break( ProcessEscaped<true>(
+						idx,
+						[&](auto const ch) MAYTHROW {
+							return tc::continue_if_not_break(sink, ch);
+						},
+						[&](auto const ch32) MAYTHROW {
+							return tc::for_each(tc::convert_enc<Char>(tc::single(tc::decay_copy(ch32))), sink);
+						}
+					) );
+				}
+			}
+		};
+	}
+}
+
+namespace tc {
+	template<typename Rng>
+	constexpr auto enable_stable_index_on_move<tc::json::no_adl::decode_adaptor<Rng>> = tc::stable_index_on_move<Rng>;
+}
+
+namespace tc::json {
+	template<typename Rng>
+	constexpr auto decode(Rng&& rng)
+		return_ctor_noexcept( no_adl::decode_adaptor<Rng>, (aggregate_tag, std::forward<Rng>(rng)) )
+
+	using no_adl::simple_error_handler;
+
+	template<typename T>
+	auto const assert_and_throw=tc::json::simple_error_handler([](tc::unused) THROW(T) {
+		_ASSERTNOTIFYFALSE; throw T();
+	});
+
+	namespace no_adl {
+		template<bool c_bRequired, typename... Keys>
+		struct group final {
+		private:
+			tc::tuple<Keys...> m_tplkey;
+
+			using ResultT = tc::common_type_t<decltype(std::declval<Keys>().m_t())...>;
+			using OptionalResultT = std::conditional_t<std::is_void<ResultT>::value, bool, std::optional<ResultT>>;
+			OptionalResultT m_oresult = {}; // value initialize: bool to false, optional to nullopt
+
+		public:
+			static constexpr auto c_bHasResult = !std::is_void<ResultT>::value;
+			static constexpr tc::span<tc::char_ascii const> c_astrKeys[]= { Keys::c_strName... };
+
+			explicit group(Keys... keys) noexcept : m_tplkey{keys...} {}
+
+			bool parse(auto& parser, auto const& strParsedName) & MAYTHROW {
+				return tc::any_of(m_tplkey, [&](auto const& key) MAYTHROW {
+					if (!tc::equal(strParsedName, key.c_strName)) return false;
+
+					if (m_oresult) {
+						parser.template may_contain_only_one_of_keys<c_astrKeys>(); // MAYTHROW
+					} else if constexpr (c_bHasResult) {
+						m_oresult.emplace(key.m_t());
+					} else {
+						key.m_t();
+						m_oresult = true;
+					}
+					return true;
+				});
+			}
+
+			void finalize(auto& parser) const& MAYTHROW {
+				if constexpr (c_bRequired) {
+					if (!m_oresult) {
+						parser.template must_contain_one_of_keys<c_astrKeys>(); // MAYTHROW
+					}
+				}
+			}
+
+			auto result() && noexcept(std::is_nothrow_move_constructible<ResultT>::value) {
+				if constexpr (c_bRequired) {
+					if constexpr (c_bHasResult) {
+						return *tc_move(m_oresult); // result is ResultT
+					} else {
+						return; // result is void
+					}
+				} else {
+					return tc_move(m_oresult); // result is std::optional<ResultT> / bool
+				}
+			}
+		};
+	}
+	template<typename... Keys>
+	constexpr auto required(Keys... keys) noexcept {
+		return no_adl::group<true,Keys...>(tc_move(keys)...);
+	}
+	template<typename... Keys>
+	constexpr auto optional(Keys... keys) noexcept {
+		return no_adl::group<false,Keys...>(tc_move(keys)...);
+	}
+
+	namespace no_adl {
+
+		struct skip_exception {};
+
+		template<typename String, typename ErrorHandler>
+		struct [[nodiscard]] parser : parser_base<String, ErrorHandler> {
+			using typename parser_base<String, ErrorHandler>::char_type;
+
+			explicit parser(String&& strInput, ErrorHandler errorhandler) MAYTHROW
+				: parser_base<String, ErrorHandler>(tc_move_if_owned(strInput), tc_move(errorhandler))
+			{
+				this->skip_whitespace(); // guarantees !end()
+			}
+
+			//-------------------------------------------------------------------------------------------------------------------------
+			// Primitive values
+			bool null() & MAYTHROW {
+				switch (this->unchecked_peek()) {
+				case 'n':
+					this->unchecked_increment();
+					this->expect_literal("ull"_tc);
+					this->skip_whitespace_maybe_end();
+					return true;
+
+				default:
+					return false;
+				}
+			}
+			void expect_null() & MAYTHROW {
+				if (!null()) {
+					this->template error<tc_mem_fn(.null_expected)>(); // MAYTHROW
+				}
+			}
+
+			std::optional<bool> boolean() & MAYTHROW {
+				switch (this->unchecked_peek()) {
+				case 't':
+					this->unchecked_increment();
+					this->expect_literal("rue"_tc);
+					this->skip_whitespace_maybe_end();
+					return true;
+
+				case 'f':
+					this->unchecked_increment();
+					this->expect_literal("alse"_tc);
+					this->skip_whitespace_maybe_end();
+					return false;
+
+				default:
+					return std::nullopt;
+				}
+			}
+			bool expect_boolean() & MAYTHROW {
+				if (auto ob = boolean()) {
+					return *ob;
+				} else {
+					this->template error<tc_mem_fn(.boolean_expected)>(); // MAYTHROW
+				}
+			}
+
+			template<typename T>
+			std::optional<T> number() & MAYTHROW {
+				static_assert(tc::common_range<String>, "Spirit requires common ranges"); // TODO?
+				if ( auto const ch = this->unchecked_peek(); '-'_tc != ch && !tc::make_interval('0'_tc, '9'_tc).contains_inclusive(ch) ) {
+					return std::nullopt;
+				}
+
+				// TODO: the x3 parsers don't follow the exact same grammar as JSON numbers
+				std::optional<T> ot(std::in_place);
+				if constexpr( std::floating_point<T> ) {
+					auto it = this->position();
+					if (!tc::parse_iterator(it, this->end_position(), x3::real_parser<T>(), *ot)) {
+						ot.reset();
+					}
+					this->set_position(it);
+					this->skip_whitespace_maybe_end();
+				} else {
+					static_assert( tc::actual_integer<T> );
+					auto it = this->position();
+					if (!tc::parse_iterator(it, this->end_position(), x3::int_parser<T>(), *ot)) {
+						ot.reset();
+					}
+					this->set_position(it);
+					this->skip_whitespace_maybe_end();
+				}
+				return ot;
+			}
+			template<typename T>
+			T expect_number() & MAYTHROW {
+				if (auto ot = number<T>()) {
+					return *tc_move(ot);
+				} else {
+					this->template error<tc_mem_fn(.number_expected)>(); // MAYTHROW
+				}
+			}
+			template<typename T>
+			void assign_expect_number(T& t) & MAYTHROW {
+				t = expect_number<T>();
+			}
+
+			auto number() & MAYTHROW {
+				using Result = std::optional<decltype(tc::slice(this->input(), this->position(), this->position()))>;
+
+				static auto constexpr digits = "0123456789"_tc;
+				auto const skip_one_or_more_digits = [&]() MAYTHROW {
+					if (!this->one_of(digits)) {
+						this->template error<tc_mem_fn(.number_expected)>(); // MAYTHROW
+					}
+					while (this->one_of(digits)) {}
+				};
+
+				auto const itchBegin = this->position();
+				auto bCommitted = false;
+
+				// Sign and integer.
+				integer: switch(this->unchecked_peek()) {
+				case '0':
+					this->unchecked_increment();
+					break;
+
+				case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+					this->unchecked_increment();
+					for (;;) {
+						if (this->end()) goto end;
+						switch (auto const ch = this->unchecked_peek()) {
+						case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+							this->unchecked_increment();
+							break;
+						case '.':
+							this->unchecked_increment();
+							goto fraction;
+						case 'e': case 'E':
+							this->unchecked_increment();
+							goto exponent;
+						default:
+							goto end;
+						}
+					}
+					_ASSERTFALSE;
+
+				case '-':
+					if (tc::change(bCommitted, true)) {
+						this->unchecked_increment();
+						this->expect_not_end();
+						goto integer;
+					}
+					// fallthrough
+				default:
+					if (bCommitted) {
+						this->template error<tc_mem_fn(.number_expected)>(); // MAYTHROW
+					} else {
+						return Result();
+					}
+				}
+
+				// Fraction and exponent.
+				if (!this->end()) {
+					switch (this->unchecked_peek()) {
+					case '.':
+						this->unchecked_increment();
+					fraction:
+						skip_one_or_more_digits();
+						if (this->one_of("eE"_tc)) {
+							goto exponent;
+						}
+						break;
+
+					case 'e': case 'E':
+						this->unchecked_increment();
+					exponent:
+						tc::discard(this->one_of("+-"_tc));
+						skip_one_or_more_digits();
+						break;
+					}
+				}
+
+			end:
+				auto const itchEnd = this->position();
+				this->skip_whitespace_maybe_end();
+				return Result(tc::slice(this->input(), itchBegin, itchEnd));
+			}
+			auto expect_number() & MAYTHROW {
+				if (auto on = number()) {
+					return *on;
+				} else {
+					this->template error<tc_mem_fn(.number_expected)>(); // MAYTHROW
+				}
+			}
+
+			auto string() & MAYTHROW {
+				using Result = std::optional<decltype(read_string())>;
+				switch(this->unchecked_peek()) {
+				case '"': {
+					this->unchecked_increment();
+					auto result = read_string(); // MAYTHROW
+					this->skip_whitespace_maybe_end();
+					return Result(result);
+				}
+
+				default:
+					return Result();
+				}
+			}
+			auto expect_string() & MAYTHROW {
+				this->expect_literal("\""_tc);
+				auto str = read_string();
+				this->skip_whitespace_maybe_end();
+				return str;
+			}
+			auto expect_string_or_null() & MAYTHROW {
+				if (null()) {
+					return decode(tc::slice(this->input(), this->position(), this->position()));
+				} else {
+					return expect_string();
+				}
+			}
+			auto expect_non_empty_string() & MAYTHROW {
+				auto str = expect_string();
+				if (tc::empty(str)) this->semantic_error();
+				return str;
+			}
+
+			//-------------------------------------------------------------------------------------------------------------------------
+			// Array
+			bool array()& MAYTHROW {
+				switch (this->unchecked_peek()) {
+				case '[':
+					this->unchecked_increment();
+					VERIFY(tc::change(this->m_bAtArrayOrObjectStart, true));
+					this->skip_whitespace(); // MAYTHROW
+					return true;
+
+				default:
+					return false;
+				}
+			}
+			void expect_array() & MAYTHROW {
+				if (!array()) {
+					this->template error<tc_mem_fn(.array_expected)>(); // MAYTHROW
+				}
+			}
+
+			bool element() & MAYTHROW {
+				// After some value (null/boolean/number/string/array/object) ends, we allow EOI by calling skip_whitespace_maybe_end()
+				// because it may be the root value. If it is not, another element() or key() must follow, so there, we must check for EOI.
+				this->expect_not_end(); // MAYTHROW
+
+				auto const ch = this->unchecked_peek();
+				if (']' == ch) {
+					this->unchecked_increment();
+					this->m_bAtArrayOrObjectStart = false;
+					this->skip_whitespace_maybe_end(); // MAYTHROW
+					return false;
+				} else {
+					if (!tc::change(this->m_bAtArrayOrObjectStart, false)) {
+						if (',' == ch) {
+							this->unchecked_increment();
+							this->skip_whitespace();
+						} else {
+							this->template error<tc_mem_fn(.char_expected)>(tc::char_ascii(',')); // MAYTHROW
+						}
+					}
+					return true;
+				}
+			}
+			void expect_element() & MAYTHROW {
+				if(!element()) {
+					this->template error<tc_mem_fn(.element_expected)>(); // MAYTHROW
+				}
+			}
+
+			template <typename Func> requires tc::invocable<Func&, std::size_t>
+			auto elements(Func func) & MAYTHROW {
+				using result_t = decltype(func(std::size_t(0)));
+				return tc::generator_range_output<result_t&&>([this, func=tc_move(func)](auto sink) MAYTHROW {
+					auto const invoke_sink = [&](std::size_t const idx) MAYTHROW {
+						try
+						{
+							return tc::continue_if_not_break(sink, func(idx));
+						} catch (skip_exception const&) {
+							while (element()) skip_value();
+							throw;
+						}
+					};
+
+					static auto constexpr bAlwaysBreaks = std::is_same<decltype(invoke_sink(0)), tc::constant<tc::break_>>::value;
+					static auto constexpr bNeverBreaks = std::is_same<decltype(invoke_sink(0)), tc::constant<tc::continue_>>::value;
+					if constexpr (bAlwaysBreaks) {
+						if (element()) {
+							tc::discard(invoke_sink(0));
+							while (element()) skip_value();
+							return tc::break_;
+						} else {
+							return tc::continue_;
+						}
+					} else if constexpr (bNeverBreaks) {
+						for (std::size_t idx = 0; element(); ++idx) {
+							tc::discard(invoke_sink(idx));
+						}
+						return tc::constant<tc::continue_>{};
+					} else {
+						for (std::size_t idx = 0; element(); ++idx) {
+							if (tc::break_ == invoke_sink(idx)) {
+								while (element()) skip_value();
+								return tc::break_;
+							}
+						}
+						return tc::continue_;
+					}
+				});
+			}
+			template<typename Func> requires tc::invocable<Func&> && (!tc::invocable<Func&, std::size_t>)
+			auto elements(Func func) & MAYTHROW {
+				return elements([func = tc_move(func)](std::size_t) return_decltype_xvalue_by_ref_MAYTHROW(func()));
+			}
+			template<typename Func> requires tc::invocable<Func&> || tc::invocable<Func&, std::size_t>
+			auto expect_array(Func func) & MAYTHROW {
+				expect_array();
+				return elements(tc_move(func));
+			}
+
+			void expect_array_end() & MAYTHROW {
+				this->expect_literal("]"_tc);
+				this->skip_whitespace_maybe_end();
+			}
+
+			template <typename Sink> requires tc::invocable<Sink const&, std::size_t>
+			auto for_each_element(Sink const sink) & MAYTHROW 
+				-> tc::common_type_t<decltype(tc::continue_if_not_break(std::declval<Sink const&>(), std::size_t(0))), tc::constant<tc::continue_>> {
+				for (std::size_t idx = 0; element(); ++idx) {
+					try {
+						tc_yield(sink, idx);
+					} catch (skip_exception const&) {
+						while (element()) skip_value();
+						throw;
+					}
+				}
+				return tc::constant<tc::continue_>();
+			}
+			template <typename Sink> requires tc::invocable<tc::decay_t<Sink> const&> && (!tc::invocable<tc::decay_t<Sink> const&, std::size_t>)
+			auto for_each_element(Sink&& sink) & MAYTHROW {
+				return for_each_element([sink = tc_move_if_owned(sink)](std::size_t) return_decltype_MAYTHROW(sink()));
+			}
+
+			template<typename Func>
+			auto optional_single_element(Func func) & MAYTHROW {
+				expect_array();
+				using T = decltype(func());
+				using OptT = std::conditional_t<std::is_void<T>::value, bool, std::optional<T>>;
+				OptT ot{}; // if bool, value-initialize to false, otherwise to std::nullopt
+				if (element()) {
+					try {
+						if constexpr (std::is_void<T>::value) {
+							func();
+							ot = true;
+						} else {
+							ot.emplace(func());
+						}
+					} catch (skip_exception const&) {
+						while (element()) skip_value();
+						throw;
+					}
+					expect_array_end();
+				}
+				return ot;
+			}
+			template<typename Func>
+			auto required_single_element(Func func) & MAYTHROW {
+				expect_array();
+				expect_element();
+				try {
+					if constexpr (std::is_void<decltype(func())>::value) {
+						func(); // MAYTHROW
+						expect_array_end();
+					} else {
+						auto t = func(); // MAYTHROW
+						expect_array_end();
+						return t;
+					}
+				} catch (skip_exception const&) {
+					while(element()) skip_value();
+					throw;
+				}
+			}
+
+			//-------------------------------------------------------------------------------------------------------------------------
+			// Object
+			bool object() & MAYTHROW {
+				switch (this->unchecked_peek()) {
+				case '{':
+					this->unchecked_increment();
+					VERIFY(tc::change(this->m_bAtArrayOrObjectStart, true));
+					this->skip_whitespace(); // MAYTHROW
+					return true;
+
+				default:
+					return false;
+				}
+			}
+			void expect_object() & MAYTHROW {
+				if (!object()) {
+					this->template error<tc_mem_fn(.object_expected)>(); // MAYTHROW
+				}
+			}
+
+			auto key() & MAYTHROW {
+				// After some value (object/array/number/boolean/...) ends, we allow EOI by calling skip_whitespace_maybe_end()
+				// because it may be the root value. If it is not, another element() or key() must follow, so there, we must check for EOI.
+				this->expect_not_end();
+
+				using Result = std::optional<decltype(read_string())>;
+				auto const ch = this->unchecked_peek();
+				if ('}' == ch) {
+					this->unchecked_increment();
+					this->m_bAtArrayOrObjectStart = false;
+					this->skip_whitespace_maybe_end();
+					return Result{};
+				} else {
+					if (!tc::change(this->m_bAtArrayOrObjectStart, false)) {
+						if (',' == ch) {
+							this->unchecked_increment();
+							this->skip_whitespace();
+						} else {
+							this->template error<tc_mem_fn(.char_expected)>(tc::char_ascii(',')); // MAYTHROW
+						}
+					}
+
+					if (!this->literal("\""_tc)) {
+						this->template error<tc_mem_fn(.key_expected)>(); // MAYTHROW
+					}
+					auto strKey = read_string();
+
+					this->skip_whitespace();
+					this->expect_literal(":"_tc);
+					this->skip_whitespace();
+
+					return tc::explicit_cast<Result>(tc_move(strKey));
+				}
+			}
+
+			template <typename... Groups> requires( 0<sizeof...(Groups) )
+			void members(Groups&&... group) & MAYTHROW {
+				static_assert(((std::is_lvalue_reference<Groups>::value || !std::remove_reference_t<Groups>::c_bHasResult) && ...),
+					"at least one member returns a value that we're discarding");
+
+				while (tc_auto_cref(ostr, key())) {
+					try {
+						if (!(group.parse(*this, *ostr) || ...)) {
+							skip_value();
+						}
+					} catch (skip_exception const&) {
+						while(key()) skip_value();
+						throw;
+					}
+				}
+				(group.finalize(*this), ...);
+			}
+			template <typename... Groups> requires( 0<sizeof...(Groups) )
+			void expect_object(Groups&&... group) & MAYTHROW {
+				expect_object();
+				members(tc_move_if_owned(group)...);
+			}
+
+			template <typename Group> requires std::is_rvalue_reference<Group&&>::value
+			[[nodiscard]] auto expect_single_member_object(Group&& group) & MAYTHROW {
+				expect_object(group);
+				return tc_move(group).result();
+			}
+
+			template<auto const& c_astrNames>
+			[[noreturn]] void must_contain_one_of_keys() & MAYTHROW {
+				this->template error<[](auto& error, auto const& rng, auto const& it) MAYTHROW {
+					error.must_contain_one_of_keys(rng, it, c_astrNames);
+				}>(); // MAYTHROW
+			}
+			template<auto const& c_astrNames>
+			[[noreturn]] void may_contain_only_one_of_keys() & MAYTHROW {
+				this->template error<[](auto& error, auto const& rng, auto const& it) MAYTHROW {
+					error.may_contain_only_one_of_keys(rng, it, c_astrNames);
+				}>(); // MAYTHROW
+			}
+
+			//-------------------------------------------------------------------------------------------------------------------------
+			// Any value.
+			void skip_value() & MAYTHROW {
+				std::bitset<256> bitsetIsArray; // (unnecessarily) zero-initialized.
+				std::size_t nNestingLevel = 0;
+				for(;;) {
+					// Optimization: we do one switch here to dispatch to the appropriate member function, instead of individual branches in each member function.
+					// After inlining of trivial functions like null or boolean, this is faster.
+					switch (this->unchecked_peek()) {
+					case 'n':
+						VERIFY(null()); // MAYTHROW
+						break;
+					case 't':
+					case 'f':
+						VERIFY(boolean()); // MAYTHROW
+						break;
+					case '-':
+					case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+						VERIFY(number()); // MAYTHROW
+						break;
+					case '"':
+						VERIFY(string()); // MAYTHROW
+						break;
+
+					case '[':
+						if (bitsetIsArray.size() <= nNestingLevel) {
+							this->template error<tc_mem_fn(.nesting_too_deep)>(); // MAYTHROW
+						}
+						VERIFY(array()); // MAYTHROW
+						bitsetIsArray.set(nNestingLevel++);
+						break;
+					case '{':
+						if (bitsetIsArray.size() <= nNestingLevel) {
+							this->template error<tc_mem_fn(.nesting_too_deep)>(); // MAYTHROW
+						}
+						VERIFY(object()); // MAYTHROW
+						bitsetIsArray.reset(nNestingLevel++);
+						break;
+
+					default:
+						this->template error<tc_mem_fn(.value_expected)>(); // MAYTHROW
+						break;
+					}
+					for(;;) {
+						if(0==nNestingLevel) return;
+						if(bitsetIsArray.test(nNestingLevel - 1) ? element() : tc::explicit_cast<bool>(key())) break;
+						--nNestingLevel;
+					}
+				}
+			}
+
+			using parser_base<String, ErrorHandler>::expect_end;
+
+		private:
+			// Precondition: We have just consumed the opening '"'.
+			auto read_string() & MAYTHROW {
+				auto itchBegin = this->position();
+
+				#if TC_JSON_SIMD
+				if constexpr (sizeof(char_type) == 1 && tc::contiguous_range<String> && tc::common_range<String>) {
+					// Quickly fast forward to first occurrence of byte values 0-0x1F (control characters), 0x22 ("), 0x5C (\) or 0x80-0xFF (non-ascii).
+					auto it = this->position();
+					auto const end = this->end_position();
+					for(;;) {
+						if (16 <= end - it) {
+						#if BOOST_ARCH_X86
+							auto const m128Chunk = _mm_loadu_si128(reinterpret_cast<__m128i const*>(std::to_address(it)));
+							auto const nSpecialCaseMask = static_cast<std::uint16_t>(_mm_movemask_epi8( // get 16 most significant bits as bitmask
+								_mm_or_si128(
+									_mm_or_si128(
+										_mm_cmpeq_epi8(m128Chunk, _mm_set1_epi8('"')), // sets lane to 0xFF, if quote
+										_mm_cmpeq_epi8(m128Chunk, _mm_set1_epi8('\\')) // sets lane to 0xFF, if backslash
+									),
+									_mm_cmplt_epi8(m128Chunk, _mm_set1_epi8(0x20)) // sets lane to 0xFF, if control character or non-ascii
+								)
+							));
+						#else
+							auto const s8x16Chunk = vld1q_s8(reinterpret_cast<std::int8_t const*>(std::to_address(it)));
+							// https://community.arm.com/arm-community-blogs/b/infrastructure-solutions-blog/posts/porting-x86-vector-bitmask-optimizations-to-arm-neon
+							auto const nSpecialCaseMask = vget_lane_u64(
+								vreinterpret_u64_u8( // treat 8 bytes as 64 bit word
+									vshrn_n_u16( // shift 16bit word right by 4, s.t., the low byte in each word contain a nibble of the original low byte and the original high byte, and return the 8 resulting low bytes
+										vreinterpretq_u16_u8(vorrq_u8(
+											vorrq_u8(
+												vceqq_s8(s8x16Chunk, vdupq_n_s8('"')), // sets lane to 0xFF, if quote
+												vceqq_s8(s8x16Chunk, vdupq_n_s8('\\')) // sets lane to 0xFF, if backslash
+											),
+											vcltq_s8(s8x16Chunk, vdupq_n_s8(0x20)) // sets lane to 0xFF, if control character or non-ascii
+										)),
+										4
+									)
+								),
+								0
+							);
+						#endif
+							if(0 != nSpecialCaseMask) {
+								it += tc::index_of_least_significant_bit(nSpecialCaseMask) / (BOOST_ARCH_ARM ? 4 : 1);
+								break;
+							} else {
+								it += 16;
+							}
+						} else /*not near EOI most of the time*/[[unlikely]] {
+							break;
+						}
+					}
+					this->set_position(it);
+				}
+				#endif
+
+				for (;;) {
+					this->expect_not_end();
+					switch (auto const ch = this->unchecked_peek()) {
+					case '"': {
+						auto itchEnd = this->position();
+						this->unchecked_increment();
+
+						return decode(tc::slice(this->input(), itchBegin, itchEnd));
+					}
+
+					case '\\':
+						this->unchecked_increment();
+						this->expect_not_end();
+						switch (this->unchecked_peek()) {
+						case '"':
+						case '\\':
+						case '/':
+						case 'b':
+						case 'f':
+						case 'n':
+						case 'r':
+						case 't':
+							this->unchecked_increment();
+							break;
+
+						case 'u':
+							this->unchecked_increment();
+							for (auto i = 0; i < 4; ++i) {
+								if (!this->char_class(tc_fn(tc::isasciixdigit))) {
+									this->template error<tc_mem_fn(.invalid_escape)>(); // MAYTHROW
+								}
+							}
+							break;
+
+						default:
+							this->template error<tc_mem_fn(.invalid_escape)>(); // MAYTHROW
+						}
+						break;
+
+					default:
+						if (tc::make_interval(0x00, 0x1F).contains_inclusive(ch)) {
+							// The control characters (U+0000 through U+001F) must be escaped (RFC 8259). U+007F is fine.
+							this->template error<tc_mem_fn(.unescaped_control_character)>(); // MAYTHROW
+						} else {
+							this->unchecked_increment();
+							if constexpr (sizeof(char_type) == 1) {
+								this->skip_utf8_code_point(ch);
+							}
+						}
+						break;
+					}
+				}
+			}
+
+			bool m_bAtArrayOrObjectStart = false;
+		};
+
+		template<typename String, typename ErrorHandler>
+		parser(String&&, ErrorHandler) -> parser<String, ErrorHandler>;
+	}
+	using no_adl::parser;
+	using no_adl::skip_exception;
+
+	// Json uses only UTF-8 encoding: https://tools.ietf.org/html/rfc8259#section-8.1
+	// ' JSON text exchanged between systems that are not part of a closed ecosystem MUST be encoded using UTF-8 [RFC3629].'
+	template<typename Rng>
+	decltype(auto) remove_bom(Rng&& rngbyte) {
+		return tc::starts_with<tc::return_drop_or_all>(tc_move_if_owned(rngbyte), tc_as_constexpr(tc::make_array<unsigned char>(tc::aggregate_tag, 0xef, 0xbb, 0xbf)));
+	}
+}
diff --git a/tc/string/jsonparser.t.cpp b/tc/string/jsonparser.t.cpp
new file mode 100644
index 0000000..0977877
--- /dev/null
+++ b/tc/string/jsonparser.t.cpp
@@ -0,0 +1,501 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "../base/assert_defs.h"
+#include "../unittest.h"
+#include "jsonparser.h"
+#include "../range/join_adaptor.h"
+#include "../range/repeat_n.h"
+
+#pragma push_macro("AS_ARRAY")
+#define AS_ARRAY(str) tc::end_prev<tc::return_take>(tc::as_array(str))
+
+namespace {
+	bool Accepts(auto const& str) noexcept {
+		struct ExFailure final {};
+		bool bAccepted = true;
+		try {
+			tc::json::parser parser(
+				str,
+				tc::json::simple_error_handler([](tc::unused) THROW(ExFailure) {
+					throw ExFailure();
+				})
+			);
+			parser.skip_value(); // THROW(ExFailure)
+			parser.expect_end(); // THROW(ExFailure)
+		} catch (ExFailure const&) {
+			bAccepted = false;
+		}
+		return bAccepted;
+	};
+}
+
+UNITTESTDEF(JSONTestSuite) {
+	// Create from https://github.com/nst/JSONTestSuite with the following code.
+	//
+	//	tc::temporaryfile tmpfile; // THROW(tc::file_failure)
+	//	tc::for_each(
+	//		tc::filesystem::file_range(FILESTR("/git/JSONTestSuite/test_parsing/")),
+	//		[&](auto const& pathTestCase) noexcept {
+	//			tc::readfile file(tc::as_c_str(pathTestCase)); // THROW(tc::file_failure)
+	//			auto str = tc::make_str(tc::repeat_n(tc::size(file), '0'));
+	//			tc::read(file, tc::ptr_begin(str), tc::size(str)); // THROW(tc::file_failure)
+	//			tc_auto_cref(strFilename, FilenameWithoutPath<tc::return_drop>(pathTestCase));
+	//			tc_auto_cref(chExpectation, tc::front(strFilename));
+	//			tc::append(
+	//				tc::make_typed_stream<char>(tmpfile),
+	//				tc_conditional_range(
+	//					FILESTR('i') != chExpectation,
+	//					tc::concat(
+	//						"_ASSERT(",
+	//						tc_conditional_range(
+	//							FILESTR('n') == chExpectation,
+	//							"!"
+	//						)
+	//					)
+	//				),
+	//				"Accepts(AS_ARRAY(\"",
+	//					tc_conditional_range(
+	//						tc::all_of(tc::codepoint_range(str), tc_fn(tc::codepoint_value)),
+	//						tc::as_cppstr(str),
+	//						tc::join(tc::transform(str, [](char const ch) noexcept {
+	//							return tc::concat("\\x", tc::as_padded_hex(tc::to_underlying(ch)));
+	//						}))
+	//					),
+	//				"\"))",
+	//				tc_conditional_range(
+	//					FILESTR('i') != chExpectation,
+	//					")"
+	//				),
+	//				"; // ", FileExtension<tc::return_take>(strFilename), "\n"
+	//			);
+	//		}
+	//	);
+	//	_ASSERTKNOWNFALSEPRINT("Wrote asserts to ", tmpfile.flush_and_close());
+	Accepts(AS_ARRAY("[123.456e-789]")); // i_number_double_huge_neg_exp
+	Accepts(AS_ARRAY("[0.4e00669999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969999999006]")); // i_number_huge_exp
+	Accepts(AS_ARRAY("[-1e+9999]")); // i_number_neg_int_huge_exp
+	Accepts(AS_ARRAY("[1.5e+9999]")); // i_number_pos_double_huge_exp
+	Accepts(AS_ARRAY("[-123123e100000]")); // i_number_real_neg_overflow
+	Accepts(AS_ARRAY("[123123e100000]")); // i_number_real_pos_overflow
+	Accepts(AS_ARRAY("[123e-10000000]")); // i_number_real_underflow
+	Accepts(AS_ARRAY("[-123123123123123123123123123123]")); // i_number_too_big_neg_int
+	Accepts(AS_ARRAY("[100000000000000000000]")); // i_number_too_big_pos_int
+	Accepts(AS_ARRAY("[-237462374673276894279832749832423479823246327846]")); // i_number_very_big_negative_int
+	Accepts(AS_ARRAY("{\"\\uDFAA\":0}")); // i_object_key_lone_2nd_surrogate
+	Accepts(AS_ARRAY("[\"\\uDADA\"]")); // i_string_1st_surrogate_but_2nd_missing
+	Accepts(AS_ARRAY("[\"\\uD888\\u1234\"]")); // i_string_1st_valid_surrogate_2nd_invalid
+	Accepts(AS_ARRAY("[\"\\uD800\\uD800\\n\"]")); // i_string_incomplete_surrogates_escape_valid
+	Accepts(AS_ARRAY("[\"\\uD800\\n\"]")); // i_string_incomplete_surrogate_and_escape_valid
+	Accepts(AS_ARRAY("[\"\\uDd1ea\"]")); // i_string_incomplete_surrogate_pair
+	Accepts(AS_ARRAY("[\"\\ud800\"]")); // i_string_invalid_lonely_surrogate
+	Accepts(AS_ARRAY("[\"\\ud800abc\"]")); // i_string_invalid_surrogate
+	Accepts(AS_ARRAY("\x5B\x22\xFF\x22\x5D")); // i_string_invalid_utf-8
+	Accepts(AS_ARRAY("[\"\\uDd1e\\uD834\"]")); // i_string_inverted_surrogates_U+1D11E
+	Accepts(AS_ARRAY("\x5B\x22\xE9\x22\x5D")); // i_string_iso_latin_1
+	Accepts(AS_ARRAY("[\"\\uDFAA\"]")); // i_string_lone_second_surrogate
+	Accepts(AS_ARRAY("\x5B\x22\x81\x22\x5D")); // i_string_lone_utf8_continuation_byte
+	Accepts(AS_ARRAY("\x5B\x22\xF4\xBF\xBF\xBF\x22\x5D")); // i_string_not_in_unicode_range
+	Accepts(AS_ARRAY("\x5B\x22\xC0\xAF\x22\x5D")); // i_string_overlong_sequence_2_bytes
+	Accepts(AS_ARRAY("\x5B\x22\xFC\x83\xBF\xBF\xBF\xBF\x22\x5D")); // i_string_overlong_sequence_6_bytes
+	Accepts(AS_ARRAY("\x5B\x22\xFC\x80\x80\x80\x80\x80\x22\x5D")); // i_string_overlong_sequence_6_bytes_null
+	Accepts(AS_ARRAY("\x5B\x22\xE0\xFF\x22\x5D")); // i_string_truncated-utf-8
+	Accepts(AS_ARRAY("\xFF\xFE\x5B\x00\x22\x00\xE9\x00\x22\x00\x5D\x00")); // i_string_UTF-16LE_with_BOM
+	Accepts(AS_ARRAY("\x5B\x22\xE6\x97\xA5\xD1\x88\xFA\x22\x5D")); // i_string_UTF-8_invalid_sequence
+	Accepts(AS_ARRAY("\x00\x5B\x00\x22\x00\xE9\x00\x22\x00\x5D")); // i_string_utf16BE_no_BOM
+	Accepts(AS_ARRAY("\x5B\x00\x22\x00\xE9\x00\x22\x00\x5D\x00")); // i_string_utf16LE_no_BOM
+	Accepts(AS_ARRAY("\x5B\x22\xED\xA0\x80\x22\x5D")); // i_string_UTF8_surrogate_U+D800
+	Accepts(AS_ARRAY("\uFEFF{}")); // i_structure_UTF-8_BOM_empty_object
+	_ASSERT(!Accepts(AS_ARRAY("[1 true]"))); // n_array_1_true_without_comma
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\x61\xE5\x5D"))); // n_array_a_invalid_utf8
+	_ASSERT(!Accepts(AS_ARRAY("[\"\": 1]"))); // n_array_colon_instead_of_comma
+	_ASSERT(!Accepts(AS_ARRAY("[\"\"],"))); // n_array_comma_after_close
+	_ASSERT(!Accepts(AS_ARRAY("[,1]"))); // n_array_comma_and_number
+	_ASSERT(!Accepts(AS_ARRAY("[1,,2]"))); // n_array_double_comma
+	_ASSERT(!Accepts(AS_ARRAY("[\"x\",,]"))); // n_array_double_extra_comma
+	_ASSERT(!Accepts(AS_ARRAY("[\"x\"]]"))); // n_array_extra_close
+	_ASSERT(!Accepts(AS_ARRAY("[\"\",]"))); // n_array_extra_comma
+	_ASSERT(!Accepts(AS_ARRAY("[\"x\""))); // n_array_incomplete
+	_ASSERT(!Accepts(AS_ARRAY("[x"))); // n_array_incomplete_invalid_value
+	_ASSERT(!Accepts(AS_ARRAY("[3[4]]"))); // n_array_inner_array_no_comma
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\xFF\x5D"))); // n_array_invalid_utf8
+	_ASSERT(!Accepts(AS_ARRAY("[1:2]"))); // n_array_items_separated_by_semicolon
+	_ASSERT(!Accepts(AS_ARRAY("[,]"))); // n_array_just_comma
+	_ASSERT(!Accepts(AS_ARRAY("[-]"))); // n_array_just_minus
+	_ASSERT(!Accepts(AS_ARRAY("[   , \"\"]"))); // n_array_missing_value
+	_ASSERT(!Accepts(AS_ARRAY("[\"a\",\n4\n,1,"))); // n_array_newlines_unclosed
+	_ASSERT(!Accepts(AS_ARRAY("[1,]"))); // n_array_number_and_comma
+	_ASSERT(!Accepts(AS_ARRAY("[1,,]"))); // n_array_number_and_several_commas
+	_ASSERT(!Accepts(AS_ARRAY("[\"\u000Ba\"\\f]"))); // n_array_spaces_vertical_tab_formfeed
+	_ASSERT(!Accepts(AS_ARRAY("[*]"))); // n_array_star_inside
+	_ASSERT(!Accepts(AS_ARRAY("[\"\""))); // n_array_unclosed
+	_ASSERT(!Accepts(AS_ARRAY("[1,"))); // n_array_unclosed_trailing_comma
+	_ASSERT(!Accepts(AS_ARRAY("[1,\n1\n,1"))); // n_array_unclosed_with_new_lines
+	_ASSERT(!Accepts(AS_ARRAY("[{}"))); // n_array_unclosed_with_object_inside
+	_ASSERT(!Accepts(AS_ARRAY("[fals]"))); // n_incomplete_false
+	_ASSERT(!Accepts(AS_ARRAY("[nul]"))); // n_incomplete_null
+	_ASSERT(!Accepts(AS_ARRAY("[tru]"))); // n_incomplete_true
+	_ASSERT(!Accepts(AS_ARRAY("123\u0000"))); // n_multidigit_number_then_00
+	_ASSERT(!Accepts(AS_ARRAY("[++1234]"))); // n_number_++
+	_ASSERT(!Accepts(AS_ARRAY("[+1]"))); // n_number_+1
+	_ASSERT(!Accepts(AS_ARRAY("[+Inf]"))); // n_number_+Inf
+	_ASSERT(!Accepts(AS_ARRAY("[-01]"))); // n_number_-01
+	_ASSERT(!Accepts(AS_ARRAY("[-1.0.]"))); // n_number_-1.0.
+	_ASSERT(!Accepts(AS_ARRAY("[-2.]"))); // n_number_-2.
+	_ASSERT(!Accepts(AS_ARRAY("[-NaN]"))); // n_number_-NaN
+	_ASSERT(!Accepts(AS_ARRAY("[.-1]"))); // n_number_.-1
+	_ASSERT(!Accepts(AS_ARRAY("[.2e-3]"))); // n_number_.2e-3
+	_ASSERT(!Accepts(AS_ARRAY("[0.1.2]"))); // n_number_0.1.2
+	_ASSERT(!Accepts(AS_ARRAY("[0.3e+]"))); // n_number_0.3e+
+	_ASSERT(!Accepts(AS_ARRAY("[0.3e]"))); // n_number_0.3e
+	_ASSERT(!Accepts(AS_ARRAY("[0.e1]"))); // n_number_0.e1
+	_ASSERT(!Accepts(AS_ARRAY("[0e+]"))); // n_number_0e+
+	_ASSERT(!Accepts(AS_ARRAY("[0e]"))); // n_number_0e
+	_ASSERT(!Accepts(AS_ARRAY("[0E+]"))); // n_number_0_capital_E+
+	_ASSERT(!Accepts(AS_ARRAY("[0E]"))); // n_number_0_capital_E
+	_ASSERT(!Accepts(AS_ARRAY("[1.0e+]"))); // n_number_1.0e+
+	_ASSERT(!Accepts(AS_ARRAY("[1.0e-]"))); // n_number_1.0e-
+	_ASSERT(!Accepts(AS_ARRAY("[1.0e]"))); // n_number_1.0e
+	_ASSERT(!Accepts(AS_ARRAY("[1eE2]"))); // n_number_1eE2
+	_ASSERT(!Accepts(AS_ARRAY("[1 000.0]"))); // n_number_1_000
+	_ASSERT(!Accepts(AS_ARRAY("[2.e+3]"))); // n_number_2.e+3
+	_ASSERT(!Accepts(AS_ARRAY("[2.e-3]"))); // n_number_2.e-3
+	_ASSERT(!Accepts(AS_ARRAY("[2.e3]"))); // n_number_2.e3
+	_ASSERT(!Accepts(AS_ARRAY("[9.e+]"))); // n_number_9.e+
+	_ASSERT(!Accepts(AS_ARRAY("[1+2]"))); // n_number_expression
+	_ASSERT(!Accepts(AS_ARRAY("[0x1]"))); // n_number_hex_1_digit
+	_ASSERT(!Accepts(AS_ARRAY("[0x42]"))); // n_number_hex_2_digits
+	_ASSERT(!Accepts(AS_ARRAY("[Inf]"))); // n_number_Inf
+	_ASSERT(!Accepts(AS_ARRAY("[Infinity]"))); // n_number_infinity
+	_ASSERT(!Accepts(AS_ARRAY("[0e+-1]"))); // n_number_invalid+-
+	_ASSERT(!Accepts(AS_ARRAY("[-123.123foo]"))); // n_number_invalid-negative-real
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\x31\x32\x33\xE5\x5D"))); // n_number_invalid-utf-8-in-bigger-int
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\x31\x65\x31\xE5\x5D"))); // n_number_invalid-utf-8-in-exponent
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\x30\xE5\x5D\x0A"))); // n_number_invalid-utf-8-in-int
+	_ASSERT(!Accepts(AS_ARRAY("[-Infinity]"))); // n_number_minus_infinity
+	_ASSERT(!Accepts(AS_ARRAY("[-foo]"))); // n_number_minus_sign_with_trailing_garbage
+	_ASSERT(!Accepts(AS_ARRAY("[- 1]"))); // n_number_minus_space_1
+	_ASSERT(!Accepts(AS_ARRAY("[NaN]"))); // n_number_NaN
+	_ASSERT(!Accepts(AS_ARRAY("[-012]"))); // n_number_neg_int_starting_with_zero
+	_ASSERT(!Accepts(AS_ARRAY("[-.123]"))); // n_number_neg_real_without_int_part
+	_ASSERT(!Accepts(AS_ARRAY("[-1x]"))); // n_number_neg_with_garbage_at_end
+	_ASSERT(!Accepts(AS_ARRAY("[1ea]"))); // n_number_real_garbage_after_e
+	_ASSERT(!Accepts(AS_ARRAY("[1.]"))); // n_number_real_without_fractional_part
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\x31\x65\xE5\x5D"))); // n_number_real_with_invalid_utf8_after_e
+	_ASSERT(!Accepts(AS_ARRAY("[.123]"))); // n_number_starting_with_dot
+	_ASSERT(!Accepts(AS_ARRAY("[\uFF11]"))); // n_number_U+FF11_fullwidth_digit_one
+	_ASSERT(!Accepts(AS_ARRAY("[1.2a-3]"))); // n_number_with_alpha
+	_ASSERT(!Accepts(AS_ARRAY("[1.8011670033376514H-308]"))); // n_number_with_alpha_char
+	_ASSERT(!Accepts(AS_ARRAY("[012]"))); // n_number_with_leading_zero
+	_ASSERT(!Accepts(AS_ARRAY("[\"x\", truth]"))); // n_object_bad_value
+	_ASSERT(!Accepts(AS_ARRAY("{[: \"x\"}\n"))); // n_object_bracket_key
+	_ASSERT(!Accepts(AS_ARRAY("{\"x\", null}"))); // n_object_comma_instead_of_colon
+	_ASSERT(!Accepts(AS_ARRAY("{\"x\"::\"b\"}"))); // n_object_double_colon
+	_ASSERT(!Accepts(AS_ARRAY("{\U0001F1E8\U0001F1ED}"))); // n_object_emoji
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"a\" 123}"))); // n_object_garbage_at_end
+	_ASSERT(!Accepts(AS_ARRAY("{key: 'value'}"))); // n_object_key_with_single_quotes
+	_ASSERT(!Accepts(AS_ARRAY("\x7B\x22\xB9\x22\x3A\x22\x30\x22\x2C\x7D"))); // n_object_lone_continuation_byte_in_key_and_trailing_comma
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\" b}"))); // n_object_missing_colon
+	_ASSERT(!Accepts(AS_ARRAY("{:\"b\"}"))); // n_object_missing_key
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\" \"b\"}"))); // n_object_missing_semicolon
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":"))); // n_object_missing_value
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\""))); // n_object_no-colon
+	_ASSERT(!Accepts(AS_ARRAY("{1:1}"))); // n_object_non_string_key
+	_ASSERT(!Accepts(AS_ARRAY("{9999E9999:1}"))); // n_object_non_string_key_but_huge_number_instead
+	_ASSERT(!Accepts(AS_ARRAY("{null:null,null:null}"))); // n_object_repeated_null_null
+	_ASSERT(!Accepts(AS_ARRAY("{\"id\":0,,,,,}"))); // n_object_several_trailing_commas
+	_ASSERT(!Accepts(AS_ARRAY("{'a':0}"))); // n_object_single_quote
+	_ASSERT(!Accepts(AS_ARRAY("{\"id\":0,}"))); // n_object_trailing_comma
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"b\"}/**/"))); // n_object_trailing_comment
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"b\"}/**//"))); // n_object_trailing_comment_open
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"b\"}//"))); // n_object_trailing_comment_slash_open
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"b\"}/"))); // n_object_trailing_comment_slash_open_incomplete
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"b\",,\"c\":\"d\"}"))); // n_object_two_commas_in_a_row
+	_ASSERT(!Accepts(AS_ARRAY("{a: \"b\"}"))); // n_object_unquoted_key
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"a"))); // n_object_unterminated-value
+	_ASSERT(!Accepts(AS_ARRAY("{ \"foo\" : \"bar\", \"a\" }"))); // n_object_with_single_string
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"b\"}#"))); // n_object_with_trailing_garbage
+	_ASSERT(!Accepts(AS_ARRAY(" "))); // n_single_space
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\uD800\\\"]"))); // n_string_1_surrogate_then_escape
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\uD800\\u\"]"))); // n_string_1_surrogate_then_escape_u
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\uD800\\u1\"]"))); // n_string_1_surrogate_then_escape_u1
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\uD800\\u1x\"]"))); // n_string_1_surrogate_then_escape_u1x
+	_ASSERT(!Accepts(AS_ARRAY("[\u00E9]"))); // n_string_accentuated_char_no_quotes
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\\u0000\"]"))); // n_string_backslash_00
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\\\\\\"]"))); // n_string_escaped_backslash_bad
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\\t\"]"))); // n_string_escaped_ctrl_char_tab
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\\U0001F300\"]"))); // n_string_escaped_emoji
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\x00\"]"))); // n_string_escape_x
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\\"]"))); // n_string_incomplete_escape
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\u00A\"]"))); // n_string_incomplete_escaped_character
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\uD834\\uDd\"]"))); // n_string_incomplete_surrogate
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\uD800\\uD800\\x\"]"))); // n_string_incomplete_surrogate_escape_invalid
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\x22\x5C\x75\xE5\x22\x5D"))); // n_string_invalid-utf-8-in-escape
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\a\"]"))); // n_string_invalid_backslash_esc
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\uqqqq\"]"))); // n_string_invalid_unicode_escape
+	_ASSERT(!Accepts(AS_ARRAY("\x5B\x22\x5C\xE5\x22\x5D"))); // n_string_invalid_utf8_after_escape
+	_ASSERT(!Accepts(AS_ARRAY("[\\u0020\"asd\"]"))); // n_string_leading_uescaped_thinspace
+	_ASSERT(!Accepts(AS_ARRAY("[\\n]"))); // n_string_no_quotes_with_bad_escape
+	_ASSERT(!Accepts(AS_ARRAY("\""))); // n_string_single_doublequote
+	_ASSERT(!Accepts(AS_ARRAY("['single quote']"))); // n_string_single_quote
+	_ASSERT(!Accepts(AS_ARRAY("abc"))); // n_string_single_string_no_double_quotes
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\"))); // n_string_start_escape_unclosed
+	_ASSERT(!Accepts(AS_ARRAY("[\"a\u0000a\"]"))); // n_string_unescaped_ctrl_char
+	_ASSERT(!Accepts(AS_ARRAY("[\"new\nline\"]"))); // n_string_unescaped_newline
+	_ASSERT(!Accepts(AS_ARRAY("[\"\t\"]"))); // n_string_unescaped_tab
+	_ASSERT(!Accepts(AS_ARRAY("\"\\UA66D\""))); // n_string_unicode_CapitalU
+	_ASSERT(!Accepts(AS_ARRAY("\"\"x"))); // n_string_with_trailing_garbage
+	_ASSERT(!Accepts(AS_ARRAY("<.>"))); // n_structure_angle_bracket_.
+	_ASSERT(!Accepts(AS_ARRAY("[<null>]"))); // n_structure_angle_bracket_null
+	_ASSERT(!Accepts(AS_ARRAY("[1]x"))); // n_structure_array_trailing_garbage
+	_ASSERT(!Accepts(AS_ARRAY("[1]]"))); // n_structure_array_with_extra_array_close
+	_ASSERT(!Accepts(AS_ARRAY("[\"asd]"))); // n_structure_array_with_unclosed_string
+	_ASSERT(!Accepts(AS_ARRAY("a\u00E5"))); // n_structure_ascii-unicode-identifier
+	_ASSERT(!Accepts(AS_ARRAY("[True]"))); // n_structure_capitalized_True
+	_ASSERT(!Accepts(AS_ARRAY("1]"))); // n_structure_close_unopened_array
+	_ASSERT(!Accepts(AS_ARRAY("{\"x\": true,"))); // n_structure_comma_instead_of_closing_brace
+	_ASSERT(!Accepts(AS_ARRAY("[][]"))); // n_structure_double_array
+	_ASSERT(!Accepts(AS_ARRAY("]"))); // n_structure_end_array
+	_ASSERT(!Accepts(AS_ARRAY("\xEF\xBB\x7B\x7D"))); // n_structure_incomplete_UTF8_BOM
+	_ASSERT(!Accepts(AS_ARRAY("\xE5"))); // n_structure_lone-invalid-utf-8
+	_ASSERT(!Accepts(AS_ARRAY("["))); // n_structure_lone-open-bracket
+	_ASSERT(!Accepts(AS_ARRAY(""))); // n_structure_no_data
+	_ASSERT(!Accepts(AS_ARRAY("[\u0000]"))); // n_structure_null-byte-outside-string
+	_ASSERT(!Accepts(AS_ARRAY("2@"))); // n_structure_number_with_trailing_garbage
+	_ASSERT(!Accepts(AS_ARRAY("{}}"))); // n_structure_object_followed_by_closing_object
+	_ASSERT(!Accepts(AS_ARRAY("{\"\":"))); // n_structure_object_unclosed_no_value
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":/*comment*/\"b\"}"))); // n_structure_object_with_comment
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\": true} \"x\""))); // n_structure_object_with_trailing_garbage
+	_ASSERT(!Accepts(AS_ARRAY("['"))); // n_structure_open_array_apostrophe
+	_ASSERT(!Accepts(AS_ARRAY("[,"))); // n_structure_open_array_comma
+	_ASSERT(!Accepts(AS_ARRAY("[{"))); // n_structure_open_array_open_object
+	_ASSERT(!Accepts(AS_ARRAY("[\"a"))); // n_structure_open_array_open_string
+	_ASSERT(!Accepts(AS_ARRAY("[\"a\""))); // n_structure_open_array_string
+	_ASSERT(!Accepts(AS_ARRAY("{"))); // n_structure_open_object
+	_ASSERT(!Accepts(AS_ARRAY("{]"))); // n_structure_open_object_close_array
+	_ASSERT(!Accepts(AS_ARRAY("{,"))); // n_structure_open_object_comma
+	_ASSERT(!Accepts(AS_ARRAY("{["))); // n_structure_open_object_open_array
+	_ASSERT(!Accepts(AS_ARRAY("{\"a"))); // n_structure_open_object_open_string
+	_ASSERT(!Accepts(AS_ARRAY("{'a'"))); // n_structure_open_object_string_with_apostrophes
+	_ASSERT(!Accepts(AS_ARRAY("[\"\\{[\"\\{[\"\\{[\"\\{"))); // n_structure_open_open
+	_ASSERT(!Accepts(AS_ARRAY("\xE9"))); // n_structure_single_eacute
+	_ASSERT(!Accepts(AS_ARRAY("*"))); // n_structure_single_star
+	_ASSERT(!Accepts(AS_ARRAY("{\"a\":\"b\"}#{}"))); // n_structure_trailing_#
+	_ASSERT(!Accepts(AS_ARRAY("[\u2060]"))); // n_structure_U+2060_word_joined
+	_ASSERT(!Accepts(AS_ARRAY("[\\u000A\"\"]"))); // n_structure_uescaped_LF_before_string
+	_ASSERT(!Accepts(AS_ARRAY("[1"))); // n_structure_unclosed_array
+	_ASSERT(!Accepts(AS_ARRAY("[ false, nul"))); // n_structure_unclosed_array_partial_null
+	_ASSERT(!Accepts(AS_ARRAY("[ true, fals"))); // n_structure_unclosed_array_unfinished_false
+	_ASSERT(!Accepts(AS_ARRAY("[ false, tru"))); // n_structure_unclosed_array_unfinished_true
+	_ASSERT(!Accepts(AS_ARRAY("{\"asd\":\"asd\""))); // n_structure_unclosed_object
+	_ASSERT(!Accepts(AS_ARRAY("\u00E5"))); // n_structure_unicode-identifier
+	_ASSERT(!Accepts(AS_ARRAY("\uFEFF"))); // n_structure_UTF8_BOM_no_data
+	_ASSERT(!Accepts(AS_ARRAY("[\u000C]"))); // n_structure_whitespace_formfeed
+	_ASSERT(!Accepts(AS_ARRAY("[\u2060]"))); // n_structure_whitespace_U+2060_word_joiner
+	_ASSERT(Accepts(AS_ARRAY("[[]   ]"))); // y_array_arraysWithSpaces
+	_ASSERT(Accepts(AS_ARRAY("[\"\"]"))); // y_array_empty-string
+	_ASSERT(Accepts(AS_ARRAY("[]"))); // y_array_empty
+	_ASSERT(Accepts(AS_ARRAY("[\"a\"]"))); // y_array_ending_with_newline
+	_ASSERT(Accepts(AS_ARRAY("[false]"))); // y_array_false
+	_ASSERT(Accepts(AS_ARRAY("[null, 1, \"1\", {}]"))); // y_array_heterogeneous
+	_ASSERT(Accepts(AS_ARRAY("[null]"))); // y_array_null
+	_ASSERT(Accepts(AS_ARRAY("[1\n]"))); // y_array_with_1_and_newline
+	_ASSERT(Accepts(AS_ARRAY(" [1]"))); // y_array_with_leading_space
+	_ASSERT(Accepts(AS_ARRAY("[1,null,null,null,2]"))); // y_array_with_several_null
+	_ASSERT(Accepts(AS_ARRAY("[2] "))); // y_array_with_trailing_space
+	_ASSERT(Accepts(AS_ARRAY("[123e65]"))); // y_number
+	_ASSERT(Accepts(AS_ARRAY("[0e+1]"))); // y_number_0e+1
+	_ASSERT(Accepts(AS_ARRAY("[0e1]"))); // y_number_0e1
+	_ASSERT(Accepts(AS_ARRAY("[ 4]"))); // y_number_after_space
+	_ASSERT(Accepts(AS_ARRAY("[-0.000000000000000000000000000000000000000000000000000000000000000000000000000001]\n"))); // y_number_double_close_to_zero
+	_ASSERT(Accepts(AS_ARRAY("[20e1]"))); // y_number_int_with_exp
+	_ASSERT(Accepts(AS_ARRAY("[-0]"))); // y_number_minus_zero
+	_ASSERT(Accepts(AS_ARRAY("[-123]"))); // y_number_negative_int
+	_ASSERT(Accepts(AS_ARRAY("[-1]"))); // y_number_negative_one
+	_ASSERT(Accepts(AS_ARRAY("[-0]"))); // y_number_negative_zero
+	_ASSERT(Accepts(AS_ARRAY("[1E22]"))); // y_number_real_capital_e
+	_ASSERT(Accepts(AS_ARRAY("[1E-2]"))); // y_number_real_capital_e_neg_exp
+	_ASSERT(Accepts(AS_ARRAY("[1E+2]"))); // y_number_real_capital_e_pos_exp
+	_ASSERT(Accepts(AS_ARRAY("[123e45]"))); // y_number_real_exponent
+	_ASSERT(Accepts(AS_ARRAY("[123.456e78]"))); // y_number_real_fraction_exponent
+	_ASSERT(Accepts(AS_ARRAY("[1e-2]"))); // y_number_real_neg_exp
+	_ASSERT(Accepts(AS_ARRAY("[1e+2]"))); // y_number_real_pos_exponent
+	_ASSERT(Accepts(AS_ARRAY("[123]"))); // y_number_simple_int
+	_ASSERT(Accepts(AS_ARRAY("[123.456789]"))); // y_number_simple_real
+	_ASSERT(Accepts(AS_ARRAY("{\"asd\":\"sdf\", \"dfg\":\"fgh\"}"))); // y_object
+	_ASSERT(Accepts(AS_ARRAY("{\"asd\":\"sdf\"}"))); // y_object_basic
+	_ASSERT(Accepts(AS_ARRAY("{\"a\":\"b\",\"a\":\"c\"}"))); // y_object_duplicated_key
+	_ASSERT(Accepts(AS_ARRAY("{\"a\":\"b\",\"a\":\"b\"}"))); // y_object_duplicated_key_and_value
+	_ASSERT(Accepts(AS_ARRAY("{}"))); // y_object_empty
+	_ASSERT(Accepts(AS_ARRAY("{\"\":0}"))); // y_object_empty_key
+	_ASSERT(Accepts(AS_ARRAY("{\"foo\\u0000bar\": 42}"))); // y_object_escaped_null_in_key
+	_ASSERT(Accepts(AS_ARRAY("{ \"min\": -1.0e+28, \"max\": 1.0e+28 }"))); // y_object_extreme_numbers
+	_ASSERT(Accepts(AS_ARRAY("{\"x\":[{\"id\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}], \"id\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"}"))); // y_object_long_strings
+	_ASSERT(Accepts(AS_ARRAY("{\"a\":[]}"))); // y_object_simple
+	_ASSERT(Accepts(AS_ARRAY("{\"title\":\"\\u041f\\u043e\\u043b\\u0442\\u043e\\u0440\\u0430 \\u0417\\u0435\\u043c\\u043b\\u0435\\u043a\\u043e\\u043f\\u0430\" }"))); // y_object_string_unicode
+	_ASSERT(Accepts(AS_ARRAY("{\n\"a\": \"b\"\n}"))); // y_object_with_newlines
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u0060\\u012a\\u12AB\"]"))); // y_string_1_2_3_bytes_UTF-8_sequences
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uD801\\udc37\"]"))); // y_string_accepted_surrogate_pair
+	_ASSERT(Accepts(AS_ARRAY("[\"\\ud83d\\ude39\\ud83d\\udc8d\"]"))); // y_string_accepted_surrogate_pairs
+	_ASSERT(Accepts(AS_ARRAY("[\"\\\"\\\\\\/\\b\\f\\n\\r\\t\"]"))); // y_string_allowed_escapes
+	_ASSERT(Accepts(AS_ARRAY("[\"\\\\u0000\"]"))); // y_string_backslash_and_u_escaped_zero
+	_ASSERT(Accepts(AS_ARRAY("[\"\\\"\"]"))); // y_string_backslash_doublequotes
+	_ASSERT(Accepts(AS_ARRAY("[\"a/*b*/c/*d//e\"]"))); // y_string_comments
+	_ASSERT(Accepts(AS_ARRAY("[\"\\\\a\"]"))); // y_string_double_escape_a
+	_ASSERT(Accepts(AS_ARRAY("[\"\\\\n\"]"))); // y_string_double_escape_n
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u0012\"]"))); // y_string_escaped_control_character
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uFFFF\"]"))); // y_string_escaped_noncharacter
+	_ASSERT(Accepts(AS_ARRAY("[\"asd\"]"))); // y_string_in_array
+	_ASSERT(Accepts(AS_ARRAY("[ \"asd\"]"))); // y_string_in_array_with_leading_space
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uDBFF\\uDFFF\"]"))); // y_string_last_surrogates_1_and_2
+	_ASSERT(Accepts(AS_ARRAY("[\"new\\u00A0line\"]"))); // y_string_nbsp_uescaped
+	_ASSERT(Accepts(AS_ARRAY("[\"\U0010FFFF\"]"))); // y_string_nonCharacterInUTF-8_U+10FFFF
+	_ASSERT(Accepts(AS_ARRAY("[\"\uFFFF\"]"))); // y_string_nonCharacterInUTF-8_U+FFFF
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u0000\"]"))); // y_string_null_escape
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u002c\"]"))); // y_string_one-byte-utf-8
+	_ASSERT(Accepts(AS_ARRAY("[\"\u03C0\"]"))); // y_string_pi
+	_ASSERT(Accepts(AS_ARRAY("[\"\U0001BFFF\"]"))); // y_string_reservedCharacterInUTF-8_U+1BFFF
+	_ASSERT(Accepts(AS_ARRAY("[\"asd \"]"))); // y_string_simple_ascii
+	_ASSERT(Accepts(AS_ARRAY("\" \""))); // y_string_space
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uD834\\uDd1e\"]"))); // y_string_surrogates_U+1D11E_MUSICAL_SYMBOL_G_CLEF
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u0821\"]"))); // y_string_three-byte-utf-8
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u0123\"]"))); // y_string_two-byte-utf-8
+	_ASSERT(Accepts(AS_ARRAY("[\"\u2028\"]"))); // y_string_u+2028_line_sep
+	_ASSERT(Accepts(AS_ARRAY("[\"\u2029\"]"))); // y_string_u+2029_par_sep
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u0061\\u30af\\u30EA\\u30b9\"]"))); // y_string_uEscape
+	_ASSERT(Accepts(AS_ARRAY("[\"new\\u000Aline\"]"))); // y_string_uescaped_newline
+	_ASSERT(Accepts(AS_ARRAY("[\"\u007F\"]"))); // y_string_unescaped_char_delete
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uA66D\"]"))); // y_string_unicode
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u005C\"]"))); // y_string_unicodeEscapedBackslash
+	_ASSERT(Accepts(AS_ARRAY("[\"\u2342\u3234\u2342\"]"))); // y_string_unicode_2
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u0022\"]"))); // y_string_unicode_escaped_double_quote
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uDBFF\\uDFFE\"]"))); // y_string_unicode_U+10FFFE_nonchar
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uD83F\\uDFFE\"]"))); // y_string_unicode_U+1FFFE_nonchar
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u200B\"]"))); // y_string_unicode_U+200B_ZERO_WIDTH_SPACE
+	_ASSERT(Accepts(AS_ARRAY("[\"\\u2064\"]"))); // y_string_unicode_U+2064_invisible_plus
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uFDD0\"]"))); // y_string_unicode_U+FDD0_nonchar
+	_ASSERT(Accepts(AS_ARRAY("[\"\\uFFFE\"]"))); // y_string_unicode_U+FFFE_nonchar
+	_ASSERT(Accepts(AS_ARRAY("[\"\u20AC\U0001D11E\"]"))); // y_string_utf8
+	_ASSERT(Accepts(AS_ARRAY("[\"a\u007Fa\"]"))); // y_string_with_del_character
+	_ASSERT(Accepts(AS_ARRAY("false"))); // y_structure_lonely_false
+	_ASSERT(Accepts(AS_ARRAY("42"))); // y_structure_lonely_int
+	_ASSERT(Accepts(AS_ARRAY("-0.1"))); // y_structure_lonely_negative_real
+	_ASSERT(Accepts(AS_ARRAY("null"))); // y_structure_lonely_null
+	_ASSERT(Accepts(AS_ARRAY("\"asd\""))); // y_structure_lonely_string
+	_ASSERT(Accepts(AS_ARRAY("true"))); // y_structure_lonely_true
+	_ASSERT(Accepts(AS_ARRAY("\"\""))); // y_structure_string_empty
+	_ASSERT(Accepts(AS_ARRAY("[\"a\"]\n"))); // y_structure_trailing_newline
+	_ASSERT(Accepts(AS_ARRAY("[true]"))); // y_structure_true_in_array
+	_ASSERT(Accepts(AS_ARRAY(" [] "))); // y_structure_whitespace_array
+}
+
+UNITTESTDEF(JSONTestSuiteStress) {
+	Accepts(tc::concat(tc::join(tc::repeat_n(500, "[")), tc::join(tc::repeat_n(500, "]")))); // i_structure_500_nested_arrays
+	_ASSERT(!Accepts(tc::join(tc::repeat_n(100000, "[")))); // n_structure_100000_opening_arrays
+	_ASSERT(!Accepts(tc::join(tc::repeat_n(50000, "[{\"\":")))); // n_structure_open_array_object
+}
+
+UNITTESTDEF(JSONDecode) {
+	static auto constexpr Test = [](tc::span<char const> strJson, tc::span<char const> strExpected) noexcept {
+		auto const MakeParser = [&]() noexcept {
+			return tc::json::parser(tc::concat("\"", strJson, "\""), tc::json::simple_error_handler(tc::never_called()));
+		};
+		_ASSERT(tc::equal(tc::as_lvalue(MakeParser()).expect_string(), tc::make_generator_range(strExpected)));
+		_ASSERT(tc::equal(tc::make_generator_range(tc::as_lvalue(MakeParser()).expect_string()), strExpected));
+	};
+	Test(
+		/*   */R"(abc 1\n\u0000\u20AC\uD834\uDD1E\t23 \u0022\" \\\b\f\r\/)",
+		AS_ARRAY("abc 1\n\0"  "\u20AC\U0001D11E""\t23 \""  "\" \\\b\f\r/")
+	);
+	Test("\u20AC", "\u20AC");
+	Test("\U0001D11E", "\U0001D11E");
+	Test(R"(\uD800\uDBFF_\uDC00\uDFFF)", "\uFFFD\uFFFD_\uFFFD\uFFFD");
+	Test(R"(\uD800\uD834\uDD1E\uD800\u20AC)", "\uFFFD\U0001D11E\uFFFD\u20AC");
+}
+
+#pragma pop_macro("AS_ARRAY")
+
+UNITTESTDEF(JSONArray_Manual) {
+	auto parser = tc::json::parser("[1, 2, 3]", tc::json::simple_error_handler(tc::never_called()));
+
+	parser.expect_array();
+
+	parser.expect_element();
+	_ASSERTEQUAL(parser.expect_number<int>(), 1);
+
+	parser.expect_element();
+	_ASSERTEQUAL(parser.expect_number<int>(), 2);
+
+	parser.expect_element();
+	_ASSERTEQUAL(parser.expect_number<int>(), 3);
+
+	parser.expect_array_end();
+}
+UNITTESTDEF(JSONArray_ManualLoop) {
+	auto parser = tc::json::parser("[1, 2, 3]", tc::json::simple_error_handler(tc::never_called()));
+
+	parser.expect_array();
+	for (auto i = 1; parser.element(); ++i) {
+		_ASSERTEQUAL(parser.expect_number<int>(), i);
+	}
+}
+UNITTESTDEF(JSONArray_FuncIdx) {
+	auto parser = tc::json::parser("[1, 2, 3]", tc::json::simple_error_handler(tc::never_called()));
+
+	auto rng = parser.expect_array([&](std::size_t const idx) noexcept {
+		return std::pair(tc::explicit_cast<int>(idx), parser.expect_number<int>());
+	});
+	TEST_RANGE_EQUAL(rng, TC_FWD(tc::literal_range_of<std::pair(0, 1), std::pair(1, 2), std::pair(2, 3)>));
+}
+UNITTESTDEF(JSONArray_Func) {
+	auto parser = tc::json::parser("[1, 2, 3]", tc::json::simple_error_handler(tc::never_called()));
+
+	auto rng = parser.expect_array([&] {
+		return parser.expect_number<int>();
+	});
+	TEST_RANGE_EQUAL(rng, TC_FWD(tc::literal_range_of<1, 2, 3>));
+}
+
+UNITTESTDEF(JSONObject_ManualLoop) {
+	auto parser = tc::json::parser(R"({"a": 1, "b": 2, "c": 3})", tc::json::simple_error_handler(tc::never_called()));
+
+	parser.expect_object();
+	while (auto const key = parser.key()) {
+		auto const expected_number = [&]{
+			if (tc::equal(*key, "a")) return 1;
+			if (tc::equal(*key, "b")) return 2;
+			if (tc::equal(*key, "c")) return 3;
+			_ASSERTFALSE;
+			return -1;
+		}();
+		VERIFYEQUAL(parser.expect_number<int>(), expected_number);
+	}
+}
+UNITTESTDEF(JSONObject_Members) {
+	auto parser = tc::json::parser(R"({"a": 1, "b": 2, "c": 3})", tc::json::simple_error_handler(tc::never_called()));
+
+	int a, b, c, d;
+	d = -1;
+
+	auto const assign = [&](int& var) noexcept {
+		return [&] {
+			var = parser.expect_number<int>();
+		};
+	};
+	parser.expect_object(
+		tc::json::required(tc::named<"b">(assign(b))),
+		tc::json::required(tc::named<"a">(assign(a)), tc::named<"A">(assign(a))),
+		tc::json::optional(tc::named<"c">(assign(c))),
+		tc::json::optional(tc::named<"d">(assign(d)))
+	);
+
+	_ASSERTEQUAL(a, 1);
+	_ASSERTEQUAL(b, 2);
+	_ASSERTEQUAL(c, 3);
+	_ASSERTEQUAL(d, -1);
+}
diff --git a/tc/string/make_c_str.h b/tc/string/make_c_str.h
index 2b54341..2f5f1fd 100644
--- a/tc/string/make_c_str.h
+++ b/tc/string/make_c_str.h
@@ -10,39 +10,36 @@
 
 #include "../base/assert_defs.h"
 #include "../base/generic_macros.h"
+#include "../base/reference_or_value.h"
+#include "../base/casts.h"
 #include "../algorithm/append.h"
 
 namespace tc {
-	namespace no_adl {
-		template< typename Char, typename Rng, typename Enable = void >
-		struct has_convertible_as_c_str final
-		: tc::constant<false> {};
+	template<typename Rng, typename Char>
+	concept has_c_str = requires(Rng&& rng) {
+		{ tc::as_c_str(rng) } -> tc::safely_convertible_to<Char*>;
+	};
 
+	namespace no_adl {
 		template< typename Char, typename Rng >
-		struct has_convertible_as_c_str< Char, Rng, std::enable_if_t<tc::safely_convertible_to<decltype(tc::as_c_str(std::declval<Rng>())), Char*>> > final
-		: tc::constant<true> {};
-
-		template< typename Char, typename Str >
-		struct [[nodiscard]] make_c_str_impl final {
-			explicit make_c_str_impl(Str&& str) noexcept: m_str(std::forward<Str>(str)) {}
+		struct [[nodiscard]] make_c_str_impl final : private tc::reference_or_value<Rng> {
+			explicit make_c_str_impl(Rng&& rng) noexcept: tc::reference_or_value<Rng>(tc::aggregate_tag, std::forward<Rng>(rng)) {}
 
 			// We don't want make_c_str_impl to be able to implicitly cast to bool. Deleting operator bool() won't work because
 			// a deleted function is still considered in overload resolution and will cause ambiguity between foo(bool) and foo(char const*).
 			template<typename T> requires std::is_same<T, Char const*>::value
 			operator T() const /*no &*/ noexcept {
-				return tc::as_c_str(m_str);
+				return tc::as_c_str(**this);
 			}
 
 			template<typename T> requires std::is_same<T, Char*>::value
 			operator T() /*no &*/ noexcept {
-				return tc::as_c_str(m_str);
+				return tc::as_c_str(**this);
 			}
 			
 			operator tc::span<Char const>() const /*no &*/ noexcept {
-				return m_str;
+				return **this;
 			}
-		private:
-			Str m_str;
 		};
 	}
 
@@ -54,7 +51,7 @@ namespace tc {
 	//   3. Explicitly specified <Char> could be omitted if the char pointer type deduced from the first rng is convertible to destination c string
 	//   4. make_mutable_c_str(<Char>): create a value or reference holder which is castable to mutable c string
 
-	template< typename Char, typename Rng0 > requires tc::no_adl::has_convertible_as_c_str<Char const, Rng0>::value
+	template< typename Char, tc::has_c_str<Char const> Rng0 >
 	auto make_c_str(Rng0&& rng0) noexcept {
 		static_assert(tc::decayed<Char>);
 		return tc::no_adl::make_c_str_impl<Char const, Rng0>(std::forward<Rng0>(rng0));
@@ -76,7 +73,7 @@ namespace tc {
 		return tc::make_c_str<tc::range_value_t<decltype(tc::concat(std::declval<Rng0>(), std::declval<Rng>()...))>>(std::forward<Rng0>(rng0), std::forward<Rng>(rng)...);
 	}
 
-	template< typename Char, typename Rng0 > requires tc::no_adl::has_convertible_as_c_str<Char, Rng0>::value
+	template< typename Char, tc::has_c_str<Char> Rng0 >
 	auto make_mutable_c_str(Rng0&& rng0) noexcept {
 		static_assert(tc::decayed<Char>);
 		return tc::no_adl::make_c_str_impl<Char, Rng0>(std::forward<Rng0>(rng0));
diff --git a/tc/string/make_c_str.t.cpp b/tc/string/make_c_str.t.cpp
index f19ee83..5cbe1f2 100644
--- a/tc/string/make_c_str.t.cpp
+++ b/tc/string/make_c_str.t.cpp
@@ -15,6 +15,17 @@
 #include "Library/Internationalization/i18n_fwd.h"
 #endif
 
+static_assert(tc::has_c_str<std::string const&, char const>);
+static_assert(!tc::has_c_str<std::string const&, char>);
+static_assert(tc::has_c_str<std::string&, char const>);
+static_assert(tc::has_c_str<std::string&, char>);
+static_assert(tc::has_c_str<std::string&&, char const>);
+static_assert(tc::has_c_str<std::string&&, char>);
+static_assert(tc::has_c_str<char const*, char const>);
+static_assert(!tc::has_c_str<char const*, char>);
+static_assert(tc::has_c_str<char*, char const>);
+static_assert(tc::has_c_str<char*, char>);
+
 namespace {
 	template<typename Char1, typename Char2> requires std::is_same<Char1, Char2>::value
 	bool check_make_c_str_fwd(Char1 const* str1, Char2 const* str2) noexcept {
@@ -62,8 +73,8 @@ UNITTESTDEF(make_c_str_test) {
 	auto strLocal3 = tc::make_c_str(tc::string<char>("ef"));
 	_ASSERT(check_make_c_str<char>(strLocal3, "ef"));
 #ifdef TC_PRIVATE
-	_ASSERT(check_make_c_str<tc::uichar>(tc::make_c_str<tc::uichar>("ab"_tc, "cd"_tc, "ef"_tc), tc::make_str<tc::uichar>("ab", "cd", "ef")));
-	_ASSERT(check_make_c_str<char>(tc::make_c_str<char>("abcdef"_tc), tc::explicit_cast<tc::string<char>>(UISTR("abcdef"))));
+	_ASSERT(check_make_c_str<tc::uichar>(tc::make_c_str<tc::uichar>(tc_ascii("ab"), tc_ascii("cd"), tc_ascii("ef")), tc::make_str<tc::uichar>("ab", "cd", "ef")));
+	_ASSERT(check_make_c_str<char>(tc::make_c_str<char>(tc_ascii("abcdef")), tc::explicit_cast<tc::string<char>>(UISTR("abcdef"))));
 #endif
 }
 
diff --git a/tc/string/named.h b/tc/string/named.h
new file mode 100644
index 0000000..31d676b
--- /dev/null
+++ b/tc/string/named.h
@@ -0,0 +1,36 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "../base/string_template_param.h"
+#include "char.h"
+
+namespace tc {
+	namespace no_adl {
+		template <tc::string_template_param strName, typename T>
+			requires tc::is_ascii_string_literal<strName>
+		struct named final {
+			T m_t;
+
+			static auto constexpr c_strName = tc::string_literal<strName>;
+		};
+	}
+
+	IS_INSTANCE_TRAIT(_str, ((tc::string_template_param)(str))((typename)(...)(T)), using arguments=tc::type::list<T...>; static constexpr auto first_argument=str;)
+
+	template<typename T>
+	using is_named = tc::constant<tc::instance_str<std::remove_reference_t<T>, no_adl::named>>;
+
+	static_assert(is_named< no_adl::named<"test",int> >::value);
+
+	template<tc::string_template_param strName, typename T>
+	constexpr auto named(T&& t) return_ctor_MAYTHROW(
+		TC_FWD(no_adl::named<strName, std::remove_cv_t<T>>), {tc_move_if_owned(t)}
+	)
+}
diff --git a/tc/string/parserbase.h b/tc/string/parserbase.h
new file mode 100644
index 0000000..fdd311c
--- /dev/null
+++ b/tc/string/parserbase.h
@@ -0,0 +1,275 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "../base/reference_or_value.h"
+#include "../range/meta.h"
+#include "char.h"
+#include "ascii.h"
+
+namespace tc {
+	namespace no_adl {
+		// Naming convention for parser functions:
+		// * `optional<T> foo()`: Try to consume `foo` and return its value. If `T == void`, return `bool`.
+		// * `T expect_foo()`: Consume `foo` and return its value. It is an error if `foo` isn't next.
+		// * `void skip_foo()`: Consume `foo`. It is an error if `foo` isn't next.
+
+		template<typename String, typename ErrorHandler>
+		struct parser_base {
+			using char_type=tc::range_value_t<String>;
+			using iterator = tc::iterator_t<String const>;
+
+			decltype(auto) input() const& noexcept {
+				return *m_strInput;
+			}
+
+			explicit operator bool() const& noexcept {
+				return !m_bError;
+			}
+
+			iterator position() const& noexcept {
+				_ASSERTDEBUG(*this);
+				return m_itchInput;
+			}
+
+			template<typename... Args>
+			void semantic_error(Args&&... args) & MAYTHROW {
+				this->error<tc_mem_fn(.semantic_error)>(tc_move_if_owned(args)...);
+			}
+
+		protected:
+			explicit parser_base(String&& strInput, ErrorHandler errorhandler) noexcept
+				: m_strInput(tc::aggregate_tag, tc_move_if_owned(strInput))
+				, m_itchInput(tc::begin(*m_strInput))
+				, m_end(tc::end(*m_strInput))
+				, m_errorhandler(tc_move(errorhandler))
+				, m_bError(false)
+			{}
+			parser_base(const parser_base&) = default;
+			parser_base& operator=(const parser_base&) = default;
+			~parser_base() = default;
+
+		protected:
+			template<auto memfn, typename... Args>
+			void warning_at(iterator it, Args&&... args) & MAYTHROW {
+				_ASSERTDEBUG(*this);
+				memfn(m_errorhandler, *m_strInput, it, std::forward<Args>(args)...); // MAYTHROW
+			}
+			template<auto memfn, typename... Args>
+			void warning(Args&&... args) & MAYTHROW {
+				warning_at<memfn>(this->m_itchInput, std::forward<Args>(args)...); // MAYTHROW
+			}
+
+			template<auto memfn, typename... Args>
+			[[noreturn]] void error_at(iterator it, Args&&... args) & MAYTHROW {
+				_ASSERTDEBUG(*this);
+				m_bError = true;
+				memfn(m_errorhandler, *m_strInput, it, std::forward<Args>(args)...); // MAYTHROW
+				_ASSERTNORETURNFALSE;
+			}
+			template<auto memfn, typename... Args>
+			[[noreturn]] void error(Args&&... args) & MAYTHROW {
+				error_at<memfn>(this->m_itchInput, std::forward<Args>(args)...); // MAYTHROW
+			}
+
+		protected:
+			char_type unchecked_peek() & noexcept {
+				_ASSERTDEBUG(*this);
+				_ASSERTDEBUG(!end());
+				return *m_itchInput;
+			}
+
+			void unchecked_increment() & noexcept {
+				_ASSERTDEBUG(*this);
+				_ASSERTDEBUG(!end());
+				++m_itchInput;
+			}
+
+			tc::sentinel_t<String const> end_position() const& noexcept {
+				return m_end;
+			}
+
+			void set_position(iterator pos) & noexcept {
+				_ASSERTDEBUG(*this);
+				if constexpr (std::random_access_iterator<iterator> && tc::common_range<String>) {
+					// If pos is outside the range, the comparison is UB, but so is calling set_position() in the first place.
+					// So we assert it to hope that it causes a nicer error.	
+					_ASSERT(tc::begin(input()) <= pos && pos <= m_end);
+				}
+				m_itchInput = pos;
+			}
+
+		protected:
+			bool end() const& noexcept {
+				_ASSERTDEBUG(*this);
+				return m_itchInput == m_end;
+			}
+			void expect_end() & MAYTHROW {
+				_ASSERTDEBUG(*this);
+				if (m_itchInput != m_end) {
+					error<tc_mem_fn(.end_expected)>(); // MAYTHROW
+				}
+			}
+			void expect_not_end() & MAYTHROW {
+				_ASSERTDEBUG(*this);
+				if (m_itchInput == m_end) {
+					error<tc_mem_fn(.end_unexpected)>(); // MAYTHROW
+				}
+			}
+
+			[[nodiscard]] std::optional<char_type> any_char() & noexcept {
+				_ASSERTDEBUG(*this);
+				if (m_itchInput == m_end) {
+					return std::nullopt;
+				}
+				return *m_itchInput++;
+			}
+			[[nodiscard]] char_type expect_any_char() & MAYTHROW {
+				_ASSERTDEBUG(*this);
+				expect_not_end();
+				return *m_itchInput++;
+			}
+
+			template <auto C>
+			[[nodiscard]] bool literal(tc::literal_range<tc::char_ascii, C>) & noexcept {
+				_ASSERTDEBUG(*this);
+				if (m_itchInput == m_end || C != *m_itchInput) {
+					return false;
+				}
+				++m_itchInput;
+				return true;
+			}
+			template <auto C>
+			void expect_literal(tc::literal_range<tc::char_ascii, C>) & MAYTHROW {
+				_ASSERTDEBUG(*this);
+				expect_not_end();
+				if (C != *m_itchInput) {
+					error<tc_mem_fn(.char_expected)>(tc::char_ascii(C)); // MAYTHROW
+				}
+				++m_itchInput;
+			}
+
+			template <auto ... Cs>
+			void expect_literal(tc::literal_range<tc::char_ascii, Cs...>) & MAYTHROW {
+				(expect_literal(tc::literal_range<tc::char_ascii, Cs>()), ...);
+			}
+
+			template <typename Fn>
+			[[nodiscard]] std::optional<char_type> char_class(Fn const predicate) & noexcept {
+				_ASSERTDEBUG(*this);
+				if (m_itchInput == m_end || !predicate(*m_itchInput)) {
+					return std::nullopt;
+				}
+
+				return *m_itchInput++;
+			}
+			template <auto ... Cs>
+			[[nodiscard]] std::optional<char_type> one_of(tc::literal_range<tc::char_ascii, Cs...>) & noexcept {
+				_ASSERTDEBUG(*this);
+				if (m_itchInput == m_end) return std::nullopt;
+
+				auto ch = *m_itchInput;
+				if (((Cs == ch) || ...)) {
+					++m_itchInput;
+					return ch;
+				}
+
+				return std::nullopt;
+			}
+
+		protected:
+			void skip_whitespace() & MAYTHROW {
+				_ASSERTDEBUG(*this);
+				for (;;) {
+					expect_not_end(); // MAYTHROW
+					switch(*m_itchInput) {
+					default:
+						return;
+					case '\t':
+					case '\n':
+					case '\r':
+					case ' ':
+						++m_itchInput;
+						break;
+					}
+				}
+			}
+			void skip_whitespace_maybe_end() & noexcept {
+				_ASSERTDEBUG(*this);
+				while (m_itchInput != m_end) {
+					switch(*m_itchInput) {
+					default:
+						return;
+					case '\t':
+					case '\n':
+					case '\r':
+					case ' ':
+						++m_itchInput;
+						break;
+					}
+				}
+			}
+
+			// Precondition: We've already consumed one character and want to skip the rest of the code point.
+			void skip_utf8_code_point(char_type const ch0) & MAYTHROW requires (sizeof(char_type) == 1) {
+				_ASSERTDEBUG(*this);
+				auto const n0 = tc::to_underlying(ch0); // MAYTHROW
+				if(0 == (n0 & 0x80)) { // ASCII
+					return;
+				}
+
+				auto const n1 = tc::to_underlying(expect_any_char()); // MAYTHROW
+				switch( (n0 >> 4) & 0x7 ) {
+					case 0b100:
+					case 0b101:
+						{	// ([\xC2-\xDF][\x80-\xBF])
+							if( (n0 < 0xC2) | (0x80 != (0xC0 & n1)) ) goto InvalidEncoding; // No short-circuit-evaluation
+							break;
+						}
+
+					case 0b110:
+						{	// ((([\xE0][\xA0-\xBF])|([\xE1-\xEC\xEE-\xEF][\x80-\xBF])|([\xED][\x80-\x9F]))[\x80-\xBF])
+							auto const n2 = tc::to_underlying(expect_any_char()); // MAYTHROW
+							if( (0x80 != (0xC0 & (n1 | n2))) | // not continuation bytes
+								(0xE0 == n0) & (n1 < 0xA0) | // non-shortest form
+								(0xED == n0) & (0xA0 <= n1) // range 0xd800-0xdfff
+							) goto InvalidEncoding; // No short-circuit-evaluation
+							break;
+						}
+
+					case 0b111:
+						{	// ((([\xF0][\x90-\xBF])|([\xF1-\xF3][\x80-\xBF])|([\xF4][\x80-\x8F]))[\x80-\xBF][\x80-\xBF])
+							auto const n2 = tc::to_underlying(expect_any_char()); // MAYTHROW
+							auto const n3 = tc::to_underlying(expect_any_char()); // MAYTHROW
+							if( (n0 < 0xF5) & // value less than U+10FFFF
+								((0xF0 != n0) | (0x90 <= n1)) & // non-shortest form
+								((0xF4 != n0) | (n1 < 0x90)) & // value less than U+10FFFF
+								(0x80 == (0xC0 & (n1 | n2 | n3))) // continuation bytes
+							) {  // No short-circuit-evaluation
+								break;
+							}
+						}
+						[[fallthrough]];
+
+					default:
+					InvalidEncoding:
+						this->template error<tc_mem_fn(.invalid_encoding)>(); // MAYTHROW
+				}
+			}
+
+		protected: // TODO: refactor XML parser
+			tc::reference_or_value<String> m_strInput;
+			iterator m_itchInput;
+			tc::sentinel_t<String const> m_end; // cached for performance
+			ErrorHandler m_errorhandler;
+			bool m_bError;
+		};
+	}
+	using no_adl::parser_base;
+}
diff --git a/tc/string/spirit.h b/tc/string/spirit.h
index eb98d94..fb15378 100644
--- a/tc/string/spirit.h
+++ b/tc/string/spirit.h
@@ -19,7 +19,7 @@
 #include "../static_vector.h"
 
 #include "ascii.h"
-#include "value_restrictive.h"
+#include "char.h"
 
 #include <boost/version.hpp>
 
@@ -110,6 +110,25 @@ namespace tc {
 		}
 	}
 
+	namespace no_adl {
+		template <typename Expr>
+		struct x3parser : Expr {
+			constexpr x3parser(Expr expr) : Expr(tc_move(expr)) {}
+
+			template <typename Rng>
+			[[nodiscard]] constexpr auto operator()(Rng const& rng) const MAYTHROW {
+				typename Expr::attribute_type result;
+				if (tc::parse(rng, *this > x3::eoi, result)) {
+					return std::optional(result);
+				} else {
+					return std::optional<typename Expr::attribute_type>();
+				}
+			}
+		};
+	}
+	template <typename Expr>
+	constexpr auto x3parser(Expr&& expr) return_ctor_MAYTHROW(no_adl::x3parser<std::remove_cvref_t<Expr>>, (tc_move_if_owned(expr)))
+
 	namespace no_adl {
 		template<typename Char>
 		struct char_encoding;
@@ -121,20 +140,20 @@ namespace tc {
 			static constexpr bool ischar(int) noexcept {
 				return true;
 			}
-			static ::boost::uint32_t toucs4(int ch) noexcept { // for debug only
+			static ::boost::uint32_t toucs4(int const ch) noexcept { // for debug only
 				return ch;
 			}
 		};
 
 		template<tc::char_type T, T tFirst, T tLast>
-		struct char_encoding<tc::value_restrictive<T, tFirst, tLast>> final {
-			using char_type = tc::value_restrictive<T, tFirst, tLast>;
+		struct char_encoding<tc::restricted_enum<T, tFirst, tLast>> final {
+			using char_type = tc::restricted_enum<T, tFirst, tLast>;
 
 			template<tc::char_like Char>
 			static constexpr bool ischar(Char ch) noexcept {
-				return char_type(tFirst) <= ch && ch <= char_type(tLast); // We reuse the SFINAE from the comparison operators of value_restrictive.
+				return char_type(tFirst) <= ch && ch <= char_type(tLast); // We reuse the SFINAE from the comparison operators of restricted_enum.
 			}
-			static ::boost::uint32_t toucs4(int ch) noexcept { // for debug only
+			static ::boost::uint32_t toucs4(int const ch) noexcept { // for debug only
 				return ch;
 			}
 		};
@@ -250,7 +269,7 @@ namespace tc {
 
 	namespace no_adl {
 		template<typename T>
-		struct value_restrictive_parser final : x3::char_parser<value_restrictive_parser<T>> {
+		struct restricted_enum_parser final : x3::char_parser<restricted_enum_parser<T>> {
 			using attribute_type = T;
 			static bool const has_attribute = true;
 
@@ -261,12 +280,12 @@ namespace tc {
 
 			template<typename U>
 			bool parse_match(U const u) const& noexcept {
-				return T(T::c_tFirst) <= u && u <= T(T::c_tLast); // We reuse the SFINAE from the comparison operators of value_restrictive.
+				return T(T::c_tFirst) <= u && u <= T(T::c_tLast); // We reuse the SFINAE from the comparison operators of restricted_enum.
 			}
 		};
 	}
 	template<typename T, T tFirst, T tLast>
-	inline constexpr auto one<value_restrictive<T, tFirst, tLast>> = no_adl::value_restrictive_parser<value_restrictive<T, tFirst, tLast>>();
+	inline constexpr auto one<restricted_enum<T, tFirst, tLast>> = no_adl::restricted_enum_parser<restricted_enum<T, tFirst, tLast>>();
 
 	inline constexpr auto asciidigit = tc::one<tc::char_asciidigit>;
 	inline constexpr auto asciilower = tc::one<tc::char_asciilower>;
@@ -306,13 +325,10 @@ namespace tc {
 			using attribute_type = x3::unused_type;
 			static bool const has_attribute = false;
 
-			template <typename CharType, typename Context>
-			bool test(CharType const& ch, Context&) const& noexcept {
-				// in C locale, it is:
-				// ' '	(0x20) space (SPC)
-				// '\t'	(0x09) horizontal tab (TAB)
+			template <typename CharType>
+			static bool test(CharType const& ch, tc::unused /*context*/) noexcept {
 				// TODO: support unicode?
-				return tc::char_ascii(' ')==ch || tc::char_ascii('\t')==ch;
+				return tc::isasciiblank(ch);
 			}
 		};
 
@@ -320,17 +336,10 @@ namespace tc {
 			using attribute_type = x3::unused_type;
 			static bool const has_attribute = false;
 
-			template <typename CharType, typename Context>
-			bool test(CharType const& ch, Context&) const& noexcept {
-				// in C locale, it is:
-				// ' '	(0x20) space (SPC)
-				// '\t'	(0x09) horizontal tab (TAB)
-				// '\n'	(0x0a) newline (LF)
-				// '\v'	(0x0b) vertical tab (VT)
-				// '\f'	(0x0c) feed (FF)
-				// '\r'	(0x0d) carriage return (CR)
+			template <typename CharType>
+			static bool test(CharType const& ch, tc::unused /*context*/) noexcept {
 				// TODO: support unicode?
-				return tc::char_ascii(' ')==ch || (tc::char_ascii('\t')<=ch && ch<=tc::char_ascii('\r'));
+				return tc::isasciispace(ch);
 			}
 		};
 	}
@@ -353,7 +362,7 @@ namespace tc {
 }
 
 namespace tc {
-	inline constexpr auto asciixdigit = asciidigit | tc::one<tc::value_restrictive<char, 'A', 'F'>> | tc::one<tc::value_restrictive<char, 'a', 'f'>>;
+	inline constexpr auto asciixdigit = asciidigit | tc::one<tc::restricted_enum<char, 'A', 'F'>> | tc::one<tc::restricted_enum<char, 'a', 'f'>>;
 
 	template<typename Char, typename T>
 	using symbols = x3::symbols_parser<tc::char_encoding<Char>, T>;
@@ -494,4 +503,12 @@ namespace boost::spirit::x3::traits
 			return true;
 		}
 	};
+	template <typename T, tc::static_vector_size_t N>
+	struct is_empty_container<tc::static_vector<T, N>, void>
+	{
+		static bool call(tc::static_vector<T, N> const& c) noexcept
+		{
+			return tc::empty(c);
+		}
+	};
 }
diff --git a/tc/string/value_restrictive.h b/tc/string/value_restrictive.h
deleted file mode 100644
index a0a79b3..0000000
--- a/tc/string/value_restrictive.h
+++ /dev/null
@@ -1,274 +0,0 @@
-
-// think-cell public library
-//
-// Copyright (C) 2016-2023 think-cell Software GmbH
-//
-// Distributed under the Boost Software License, Version 1.0.
-// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
-
-#pragma once
-
-#include "../base/type_traits.h"
-#include "../base/utility.h"
-#include "../base/casts.h"
-#include "../base/explicit_cast.h"
-#include "../base/string_template_param.h"
-#include "../algorithm/binary_operators.h"
-#include "../range/meta.h"
-#include "../array.h"
-
-namespace tc {
-	// Code unit predicates
-	//
-	// These names are based on the terminology used in the Unicode Standard: https://www.unicode.org/versions/Unicode13.0.0/UnicodeStandard-13.0.pdf
-	// "(...) reserved for the first, or leading, element of a UTF-8 code unit sequences, (...) reserved for the subsequent, or trailing, elements of such sequences;"
-	// "(...) for the lead, trail, or single code units in any of those encoding forms overlap."
-	[[nodiscard]] constexpr bool is_leading_codeunit(char const ch) noexcept {
-		return 0xc0 == (ch & 0xc0); // matches 11xxxxxx
-	}
-
-	[[nodiscard]] constexpr bool is_leading_codeunit(tc::char16 const ch) noexcept {
-		return 0xd800u == (ch & 0xfc00u); // high surrogate
-	}
-
-	[[nodiscard]] constexpr bool is_trailing_codeunit(char const ch) noexcept {
-		return 0x80 == (ch & 0xc0); // matches 10xxxxxx
-	}
-
-	[[nodiscard]] constexpr bool is_trailing_codeunit(tc::char16 const ch) noexcept {
-		return 0xdc00u == (ch & 0xfc00u); // low surrogate
-	}
-
-	namespace value_restrictive_adl {
-		template<typename TTarget, typename TSource, TSource tFirst, TSource tLast>
-		concept char_and_interval_is_in_range =
-			tc::char_type<TTarget> &&
-			tFirst<=tLast &&
-			// Code units can be directly compared when ALL allowed code points can be represented by one of the smallest code unit type.
-			tc::char_limits<TTarget>::interval_in_range(tFirst, tLast); // interval_in_range guarantees that t is a code point for all t in [tFirst, tLast]
-
-		template<typename T, T tFirst, T tLast>
-		struct value_restrictive final : tc::additive<> {
-		// private: TODO: inhibits usage as template parameter
-			static_assert(tc::decayed<T>);
-			static_assert(std::is_enum<T>::value || char_and_interval_is_in_range<T, T, tFirst, tLast>);
-			static_assert(tFirst <= tLast);
-
-			template<typename U, U uFirst, U uLast>
-			friend struct value_restrictive;
-
-			T m_t;
-
-		public:
-			static constexpr T c_tFirst = tFirst;
-			static constexpr T c_tLast = tLast;
-
-			constexpr value_restrictive() noexcept = default;
-
-			template<typename U, U uFirst, U uLast> requires (c_tFirst <= uFirst) && (uLast <= c_tLast)
-			constexpr value_restrictive(value_restrictive<U, uFirst, uLast> const ch) noexcept : m_t(ch.m_t) {} // Implicit ctor from a more restrictive type
-
-			template<typename U, U uFirst, U uLast>
-			explicit constexpr value_restrictive(value_restrictive<U, uFirst, uLast> const ch) noexcept : value_restrictive(ch.m_t) {} // Delegate to explicit ctor from data type
-
-			template<typename U> requires tc::explicit_castable_from<T, U const&>
-			explicit constexpr value_restrictive(U const u) noexcept : tc_member_init_cast(m_t, u) {
-				_ASSERTE(tc::to_underlying(c_tFirst) <= tc::to_underlying(u) && tc::to_underlying(u) <= tc::to_underlying(c_tLast));
-			}
-
-			template<typename Rhs>
-			constexpr value_restrictive& operator=(Rhs const& rhs) & noexcept { // Needed for spirit: it needs to assign to a value_restrictive attribute
-				tc::renew(*this, rhs); // Go through the ctors
-				return *this;
-			}
-
-			template<typename U> requires std::is_same<T, U>::value || char_and_interval_is_in_range<std::remove_cv_t<U>, T, c_tFirst, c_tLast>
-			constexpr operator U() const& noexcept {
-				return m_t;
-			}
-
-			template<tc::actual_integer Integral>
-			constexpr value_restrictive& operator+=(Integral const n) noexcept {
-				_ASSERTE(tc::cmp_less_equal(c_tFirst - m_t, n) && tc::cmp_less_equal(n, c_tLast - m_t));
-				m_t = static_cast<T>(m_t + n);
-				return *this;
-			}
-
-			template<tc::actual_integer Integral>
-			constexpr value_restrictive& operator-=(Integral const n) noexcept {
-				_ASSERTE(tc::cmp_less_equal(m_t - c_tLast, n) && tc::cmp_less_equal(n, m_t - c_tFirst));
-				m_t = static_cast<T>(m_t - n);
-				return *this;
-			}
-		};
-
-		template<typename T, T tFirst, T tLast>
-		constexpr auto to_underlying_impl(value_restrictive<T, tFirst, tLast> const& t) return_decltype_noexcept(
-			tc::to_underlying(tc::implicit_cast<T>(t))
-		)
-
-		template<typename T, T tFirst, T tLast>
-		constexpr auto from_underlying_impl(tc::type::identity<value_restrictive<T, tFirst, tLast>>, tc::underlying_type_t<value_restrictive<T, tFirst, tLast>> const& t) return_decltype_noexcept(
-			// Range check for T done in its from_underlying implementation.
-			// Range check for [tFirst, tLast] done in constructor.
-			value_restrictive<T, tFirst, tLast>(tc::from_underlying<T>(t))
-		)
-		
-
-#pragma push_macro("DEFINE_COMPARISON_OP")
-#define DEFINE_COMPARISON_OP(op) \
-		template<typename T, T tFirst, T tLast, typename U, std::enable_if_t<std::is_same<T, U>::value || char_and_interval_is_in_range<U, T, tFirst, tLast>>* = nullptr> \
-		constexpr auto operator op(value_restrictive<T, tFirst, tLast> const& lhs, U const& rhs) return_decltype_noexcept( \
-			static_cast<U>(tc::implicit_cast<T>(lhs)) op rhs \
-		) \
-		template<typename T, T tFirst, T tLast, typename U, U uFirst, U uLast, std::enable_if_t<std::is_same<T, U>::value>* = nullptr> \
-		constexpr auto operator op(value_restrictive<T, tFirst, tLast> const& lhs, value_restrictive<U, uFirst, uLast> const& rhs) return_decltype_noexcept( \
-			tc::implicit_cast<T>(lhs) op tc::implicit_cast<T>(rhs) \
-		) \
-		template<tc::char_type T, T tFirst, T tLast, tc::char_type U, U uFirst, U uLast, std::enable_if_t<!std::is_same<T, U>::value>* = nullptr> \
-		constexpr auto operator op(value_restrictive<T, tFirst, tLast> const& lhs, value_restrictive<U, uFirst, uLast> const& rhs) return_decltype_noexcept( \
-			static_cast<char32_t>(tc::implicit_cast<T>(lhs)) op static_cast<char32_t>(tc::implicit_cast<T>(rhs)) \
-		) \
-
-		DEFINE_COMPARISON_OP(==)
-		DEFINE_COMPARISON_OP(<=>)
-#pragma pop_macro("DEFINE_COMPARISON_OP")
-
-		// operator- between tc::char_like types is used in 2 senarios:
-		//   1. ch - '0'/'a'/'A'
-		//   2. spirit uses chLhs-chRhs as 3-way comparison
-		template<tc::char_type T, T tFirst, T tLast, tc::char_type Char>
-		constexpr auto operator-(value_restrictive<T, tFirst, tLast> const& lhs, Char const& rhs) noexcept {
-			return tc::implicit_cast<T>(lhs) - rhs;
-		}
-
-		template<tc::char_like Char, tc::char_type T, T tFirst, T tLast>
-		constexpr auto operator-(Char const& lhs, value_restrictive<T, tFirst, tLast> const& rhs) noexcept {
-			return lhs - tc::implicit_cast<T>(rhs);
-		}
-	}
-	using value_restrictive_adl::value_restrictive;
-
-	template <typename Char, Char chFirst, Char chLast>
-	[[nodiscard]] constexpr bool is_trailing_codeunit(tc::value_restrictive<Char, chFirst, chLast> const ch) noexcept {
-		return false;
-	}
-
-	namespace char_like_detail {
-		template<typename T, T tFirst, T tLast>
-		inline constexpr bool char_like_impl<tc::value_restrictive<T, tFirst, tLast>> = tc::char_like<T>;
-	}
-
-	using char_ascii = tc::value_restrictive<char, '\0', '\x7f'>;
-	using char_asciidigit = tc::value_restrictive<char, '0', '9'>;
-	using char_asciilower = tc::value_restrictive<char, 'a', 'z'>;
-	using char_asciiupper = tc::value_restrictive<char, 'A', 'Z'>;
-
-	namespace no_adl {
-		template<typename Char, Char chFirst, Char chLast>
-		struct char_limits<tc::value_restrictive<Char, chFirst, chLast>> {
-			static constexpr std::size_t c_nMaxCodeUnitsPerCodePoint = 1; // because we static_assert(is_single_codeunit())
-
-			[[nodiscard]] static constexpr bool interval_in_range(unsigned int nFirst, unsigned int nLast) noexcept {
-				return chFirst <= nFirst && nLast <= chLast;
-			}
-		};
-	}
-
-	namespace no_adl {
-#pragma push_macro("CUSTOMIZE_COMMON_TYPE_CHAR_ASCII")
-#define CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char_type) \
-		template<> \
-		struct common_type_decayed<tc::char_ascii, char_type> { \
-			using type = char_type; \
-		}; \
-		template<> \
-		struct common_type_decayed<char_type, tc::char_ascii> { \
-			using type = char_type; \
-		};
-
-		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char)
-		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(wchar_t)
-		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char16_t)
-		CUSTOMIZE_COMMON_TYPE_CHAR_ASCII(char32_t)
-#pragma pop_macro("CUSTOMIZE_COMMON_TYPE_CHAR_ASCII")
-	}
-
-	namespace no_adl {
-		template<typename Char, Char chFirst, Char chLast>
-		struct char_traits_selector<tc::value_restrictive<Char, chFirst, chLast>, void> final {
-			struct type final {
-				using char_type = tc::value_restrictive<Char, chFirst, chLast>;
-				using int_type = typename tc::char_traits<Char>::int_type;
-				using off_type = typename tc::char_traits<Char>::off_type;
-				using pos_type = typename tc::char_traits<Char>::pos_type;
-				using state_type = typename tc::char_traits<Char>::state_type;
-
-				static constexpr void assign(char_type& r, const char_type& a) noexcept {
-					r = a;
-				}
-
-				static char_type* assign(char_type* p, std::size_t count, char_type a) {
-					std::fill(p, p+count, a);
-					return p;
-				}
-
-				static constexpr bool eq(char_type a, char_type b) noexcept {
-					return a == b;
-				}
-
-				static constexpr bool lt(char_type a, char_type b) noexcept {
-					return a < b;
-				}
-
-				static constexpr std::size_t length(const char_type* s) {
-					std::size_t n = 0;
-					if(s) {
-						while(char_type() != *s++)
-							++n;
-					}
-					return n;
-				}
-
-				static constexpr const char_type* find(const char_type* p, std::size_t count, const char_type& ch) {
-					while(0<count) {
-						if(*p == ch) {
-							return p;
-						} else {
-							++p;
-							--count;
-						}
-					}
-					return nullptr;
-				}
-
-				static constexpr int compare(const char_type* s1, const char_type* s2, std::size_t count) {
-					for(std::size_t i=0; i<count; ++i) {
-						if (*s1<*s2) return -1;
-						else if (*s2<*s1) return 1;
-					}
-					return 0;
-				}
-
-				static char_type* move(char_type* dest, const char_type* src, std::size_t count) {
-					if (src <= dest && dest < src+count) {
-						std::copy_backward(src, src+count, dest+count);
-					} else {
-						std::copy(src, src+count, dest);
-					}
-					return dest;
-				}
-
-				static char_type* copy(char_type* dest, const char_type* src, std::size_t count) {
-					return move(dest, src, count); // copy works correctly just like move in clang and gcc's implementation
-				}
-			};
-		};
-	}
-}
-
-template <tc::string_template_param String>
-[[nodiscard]] constexpr auto const& operator""_tc() {
-	static_assert(std::same_as<typename decltype(String)::value_type, char>, "only ASCII is implemented at the moment");
-	return as_constexpr(tc::make_array<tc::char_ascii>(String));
-}
diff --git a/tc/string/xmlparser.h b/tc/string/xmlparser.h
new file mode 100644
index 0000000..5704ce5
--- /dev/null
+++ b/tc/string/xmlparser.h
@@ -0,0 +1,1031 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "parserbase.h"
+#include "spirit.h"
+#include "../container/container.h"
+#include "../container/cont_assign.h"
+#include "../range/join_framed_adaptor.h"
+#include "../range/join_framed_adaptor.h"
+
+namespace tc::xml {
+	namespace no_adl {
+		struct parse_error final {};
+	}
+	using no_adl::parse_error;
+	
+	namespace no_adl {
+		template<tc::decayed Func>
+		struct [[nodiscard]] simple_error_handler {
+			simple_error_handler()=default;
+			constexpr explicit simple_error_handler(Func func) noexcept
+				: m_func(tc_move(func))
+			{}
+			void semantic_error(auto const& strInput, tc::unused /*itch*/, auto&&...) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void parse_warning(auto const& strInput, tc::unused /*itch*/, tc::unused /*strTag*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void parse_warning(auto const& strInput, tc::unused /*itch*/, tc::unused /*strTag*/, tc::unused /*strAttributeName*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void parse_error(auto const& strInput, tc::unused /*itch*/, tc::unused /*strTag*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void parse_error(auto const& strInput, tc::unused /*itch*/, tc::unused /*strTag*/, tc::unused /*strAttributeName*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void end_unexpected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void end_expected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void root_expected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void name_expected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void invalid_namespace_prefix(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void attribute_name_expected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void child_expected(auto const& strInput, tc::unused /*itch*/, tc::unused /*strName*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void char_expected(auto const& strInput, tc::unused /*itch*/, tc::unused /*ch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void characters_expected(auto const& strInput, tc::unused /*itch*/, tc::unused /*strTag*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void characters_unexpected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void attribute_expected(auto const& strInput, tc::unused /*itch*/, tc::unused /*strTag*/, tc::unused /*strAttributeName*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void element_end_expected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void quotation_marks_expected(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+			void unsupported_declaration_found(auto const& strInput, tc::unused /*itch*/) const& MAYTHROW {
+				m_func(strInput);
+			}
+
+		private:
+			Func m_func;
+		};
+
+		template< typename Rng >
+		struct [[nodiscard]] decode_adaptor
+			: tc::index_range_adaptor<
+				decode_adaptor<Rng>,
+				Rng, tc::index_range_adaptor_flags::inherit_begin_end
+			>
+		{
+		private:
+			using this_type = decode_adaptor;
+			using base_ = typename decode_adaptor::index_range_adaptor;
+			using char_type=tc::range_value_t<Rng>;
+
+		public:
+			using typename base_::tc_index;
+
+			void SkipOverSemicolon(tc_index& idx) const& MAYTHROW {
+				auto& base=this->base_range();
+				for(;;) {
+					tc::increment_index(base, idx);
+					if(tc::at_end_index(base, idx)) break;
+					if(tc::char_ascii(';')==tc::dereference_index(base, idx)) {
+						tc::increment_index(base, idx);
+						break;
+					}
+				}
+			}
+
+			STATIC_FINAL(increment_index)(tc_index& idx) const& MAYTHROW -> void {
+				auto& base=this->base_range();
+				auto t=tc::dereference_index(base, idx); // we return characters, which we can always return by value
+				if(tc::char_ascii('&')==t) {
+					SkipOverSemicolon(idx);
+				} else {
+					tc::increment_index(base, idx);
+				}
+			}
+
+			template<bool bIncrement>
+			char_type ProcessEscaped(tc_index& idx) const& MAYTHROW {
+				auto& base=this->base_range();
+				tc::increment_index(base, idx);
+				if(!tc::at_end_index(base, idx)) {
+					switch(tc::dereference_index(base, idx)) {
+					case tc::explicit_cast<char_type>('a'):
+						tc::increment_index(base, idx);
+						if(!tc::at_end_index(base, idx)) {
+							switch(tc::dereference_index(base, idx)) {
+							case tc::explicit_cast<char_type>('m'): // amp
+								if constexpr(bIncrement) SkipOverSemicolon(idx);
+								return tc::char_ascii('&');
+							case tc::explicit_cast<char_type>('p'): // apos
+								if constexpr(bIncrement) SkipOverSemicolon(idx);
+								return tc::char_ascii('\'');
+							case tc::explicit_cast<char_type>(';'):
+								if constexpr(bIncrement) tc::increment_index(base, idx);
+								break;
+							default:
+								if constexpr(bIncrement) SkipOverSemicolon(idx);
+								break;
+							}
+						}
+						break;
+					case tc::explicit_cast<char_type>('l'): // lt
+						if constexpr(bIncrement) SkipOverSemicolon(idx);
+						return tc::char_ascii('<');
+					case tc::explicit_cast<char_type>('g'): // gt
+						if constexpr(bIncrement) SkipOverSemicolon(idx);
+						return tc::char_ascii('>');
+					case tc::explicit_cast<char_type>('q'): // quot
+						if constexpr(bIncrement) SkipOverSemicolon(idx);
+						return tc::char_ascii('"');
+					case tc::explicit_cast<char_type>('#'): // numeric character reference
+						tc::increment_index(base, idx);
+						if(!tc::at_end_index(base, idx)) {
+							auto const NumericCharacterReference=[&](auto N) MAYTHROW -> char_type {
+								int n;
+								auto str=tc::drop(base, idx);
+								if(tc::parse_consume( str, x3::uint_parser<decltype(n), decltype(N)::value>(), n )) { // MAYTHROW
+									idx=tc::begin_index(str);
+									if(!tc::at_end_index(base, idx)) {
+										if(tc::char_ascii(';')==tc::dereference_index(base, idx)) {
+											if constexpr(bIncrement) tc::increment_index(base, idx);
+											return static_cast<char_type>(VERIFYPRED(n, tc::char_in_range<char_type>(_)));
+										} else {
+											if constexpr(bIncrement) SkipOverSemicolon(idx);
+										}
+									}
+								} else if constexpr(bIncrement) {
+									if(tc::char_ascii(';')==tc::dereference_index(base, idx)) {
+										tc::increment_index(base, idx);
+									} else {
+										SkipOverSemicolon(idx);
+									}
+								}
+								return tc::char_ascii('&'); // replacement character would be nicer, but has multiple code units, which we do not yet support
+							};
+							if(tc::char_ascii('x')==tc::dereference_index(base, idx)) {
+								tc::increment_index(base, idx);
+								if(!tc::at_end_index(base, idx)) {
+									return NumericCharacterReference(tc::constant<16>());
+								}
+							} else {
+								return NumericCharacterReference(tc::constant<10>());
+							}
+						}
+						break;
+					case tc::explicit_cast<char_type>(';'):
+						if constexpr(bIncrement) tc::increment_index(base, idx);
+						break;
+					default:
+						if constexpr(bIncrement) SkipOverSemicolon(idx);
+						break;
+					}
+				}
+				return tc::char_ascii('&'); // replacement character would be nicer, but has multiple code units, which we do not yet support
+			};
+
+			STATIC_FINAL(dereference_index)(tc_index const& idx) const& MAYTHROW {
+				auto& base=this->base_range();
+				auto t=tc::dereference_index(base, idx); // we return characters, which we can always return by value
+				if(tc::char_ascii('&')==t) {
+					return ProcessEscaped<false>(tc::as_lvalue(tc::decay_copy(idx)));
+				} else {
+					return t;
+				}
+			}
+
+		public:
+			using base_::base_;
+
+			constexpr decode_adaptor() = default;
+
+			static decltype(auto) element_base_index(tc_index const& idx) noexcept {
+				return idx;
+			}
+			static decltype(auto) element_base_index(tc_index&& idx) noexcept {
+				return tc_move(idx);
+			}
+
+			template<typename Sink>
+			auto operator()(Sink sink) const& MAYTHROW -> tc::common_type_t<
+				decltype(tc::continue_if_not_break(sink, tc::dereference_index(this->base_range(), std::declval<tc_index const&>()))),
+				tc::constant<tc::continue_>
+			> {
+				auto& base=this->base_range();
+				auto idx=tc::begin_index(base);
+				for(;;) {
+					if(tc::at_end_index(base, idx)) return tc::constant<tc::continue_>();
+					if(tc::char_ascii('&')!=tc::dereference_index(base, idx)) {
+						auto idxBegin=idx;
+						do {
+							tc::increment_index(base, idx);
+							if(tc::at_end_index(base, idx)) {
+								tc_return_if_break( tc::for_each(tc::slice(base, idxBegin, idx), sink) );
+								return tc::constant<tc::continue_>();
+							}
+						} while(tc::char_ascii('&')!=tc::dereference_index(base, idx));
+						tc_return_if_break( tc::for_each(tc::slice(base, idxBegin, idx), sink) );
+					}
+					tc_yield(sink, ProcessEscaped<true>(idx));
+				}
+			}
+		};
+
+		template<typename WithString>
+		struct with_iterator_range /* not final */ {
+			WithString m_withstring;
+
+			template<tc::range_with_iterators String>
+			auto chunk(String&& str) const& MAYTHROW {
+				m_withstring(tc_move_if_owned(str)); // MAYTHROW
+				return tc::constant<tc::continue_>();
+			}
+		};
+		template<typename WithString>
+		with_iterator_range(WithString) -> with_iterator_range<WithString>; // CTAD not working for aggregates (clang)
+	}
+
+	template<typename Rng>
+	constexpr auto decode(Rng&& rng)
+		return_ctor_noexcept( no_adl::decode_adaptor<Rng>, (aggregate_tag, std::forward<Rng>(rng)) )
+
+	template<typename String>
+	auto split_qualified_name(String const& str) noexcept {
+		tc_auto_cref(itch, tc::find_unique<tc::return_border_after_or_begin>(str, tc::explicit_cast<tc::range_value_t<String>>(':')));
+		return std::make_pair(
+			tc::begin(str)==itch ? tc::take(str, itch) : tc::take(str, tc_modified(itch, --_)),
+			tc::drop(str, itch)
+		);
+	}
+
+	namespace no_adl {
+		template< typename T, typename = void >
+		struct has_discard_until : std::false_type { };
+
+		// specialization recognizes types that do have a nested ::type member:
+		template< typename T >
+		struct has_discard_until<T, std::void_t<decltype(&std::declval<T>().discard_until)> > : std::true_type {};
+
+#pragma push_macro("case_whitespace")
+#define case_whitespace case tc::explicit_cast<char_type>('\t'): case tc::explicit_cast<char_type>('\n'): case tc::explicit_cast<char_type>('\r'): case tc::explicit_cast<char_type>(' ')
+
+		TC_DEFINE_ENUM(EXmlEntity, exmlentity, (START)(EMPTYELEMENT)(EMPTYELEMENTCLOSING)(OPENINGTAG)(CLOSINGTAG)(CHARACTERS)(CDATA));
+
+		template<typename Char>
+		struct namespace_info : tc::noncopyable {
+		protected:
+			using SetNamespace = tc::unordered_set<tc::string<Char>>;
+			SetNamespace m_setstrns;
+			
+		public:
+			// Namespace is a nullable type
+			// Passing a nullptr as a namespace to any parser method implies
+			// that the matched element has no namespace, i.e., it belongs to the default namespace
+			// and the default namespace has no value because either
+			// - there is no xmlns="..." declaration in scope
+			// - or there is a xmlns="" declaration in scope
+			//
+			// Using a namespace prefix t in the scope of a declaration xmlns:t="" is explicitly forbidden
+			// and causes an invalid_namespace_prefix parser error.
+			// https://www.w3.org/TR/2006/REC-xml-names11-20060816/#nsc-NSDeclared
+			using Namespace = tc::string<Char> const*; // pointer is stable, iterator is not
+			
+			template<typename Rng>
+			Namespace register_namespace(Rng const& strURI) & noexcept {
+				// An empty string is a valid URI but has special semantics in the XML namespace 1.1 spec.
+				// It undefines a previously defined namespace prefix for its scope.
+				// https://www.w3.org/TR/2006/REC-xml-names11-20060816/#scoping
+				_ASSERT(!tc::empty(strURI));
+				return std::addressof(*tc::cont_try_emplace(m_setstrns, tc::make_str(decode(strURI))).first);
+			}
+		};
+
+		template<typename String, typename ErrorHandler>
+		struct [[nodiscard]] parser : parser_base<String, ErrorHandler>, namespace_info<tc::range_value_t<String>> {
+		private:
+			using base_ = parser_base<String, ErrorHandler>;
+		public:
+			using typename base_::char_type;
+
+			using SetNamespace=typename namespace_info<char_type>::SetNamespace;
+			using Namespace=typename namespace_info<char_type>::Namespace;
+			
+			explicit parser(String&& strInput, ErrorHandler errorhandler) MAYTHROW
+				: base_(tc_move_if_owned(strInput), tc_move(errorhandler))
+				, m_strMain(tc::slice(this->input(), this->m_itchInput, this->m_itchInput))
+				, m_bConsumed(false)
+			{
+				Next(); // MAYTHROW
+				SkipWhitespaceCharacters(); // MAYTHROW
+				switch_no_default(m_exmlentity) {
+				case exmlentityCLOSINGTAG:
+					this->template error_at<tc_mem_fn(.root_expected)>(m_itchEntityBegin); // MAYTHROW
+				case exmlentityEMPTYELEMENT:
+				case exmlentityOPENINGTAG:
+					; // root element
+				}
+			}
+
+			using base_::expect_end;
+
+			[[nodiscard]] auto characters() & MAYTHROW {
+				EnsureFresh(); // MAYTHROW
+				switch(m_exmlentity) {
+				case exmlentityCDATA:
+				case exmlentityCHARACTERS:
+					m_bConsumed=true;
+					break;
+				default:
+					m_bConsumed=false;
+					break;
+				}
+				return tc::generator_range_output<char_type>([this](auto sink) MAYTHROW -> tc::common_type_t<
+					decltype(tc::for_each(m_strMain, tc_move(sink))),
+					decltype(tc::for_each(xml::decode(m_strMain), tc_move(sink))),
+					tc::constant<tc::continue_>
+				> {
+					switch(m_exmlentity) {
+					case exmlentityCDATA:
+						return tc::for_each(m_strMain, tc_move(sink)); // MAYTHROW
+					case exmlentityCHARACTERS:
+						return tc::for_each(xml::decode(m_strMain), tc_move(sink)); // MAYTHROW
+					default:
+						return tc::constant<tc::continue_>();
+					}
+				});
+			}
+
+			[[nodiscard]] auto parse_characters(auto const& parser) & MAYTHROW {
+				decltype(parser(tc::make_empty_range<char_type>())) ot;
+				WithCharacters([&](auto const& strCharacters) MAYTHROW {
+					if (!tc::empty(strCharacters)) {
+						if (ot = parser(strCharacters); !ot) {
+							this->template warning_at<tc_mem_fn(.parse_warning)>(m_itchEntityBegin, m_strMain); // MAYTHROW
+						}
+					}
+				}); // MAYTHROW
+				return ot;
+			}
+
+			[[nodiscard]] auto expect_parse_characters(auto const& parser) & MAYTHROW {
+				tc::decay_t<decltype(*parser(tc::make_empty_range<char_type>()))> t;
+				WithCharacters([&](auto const& strCharacters) MAYTHROW {
+					if (tc::empty(strCharacters)) {
+						this->template error_at<tc_mem_fn(.characters_expected)>(m_itchEntityBegin, m_strMain); // MAYTHROW
+					}
+					if (auto ot = parser(strCharacters); !ot) {
+						this->template error_at<tc_mem_fn(.parse_error)>(m_itchEntityBegin, m_strMain); // MAYTHROW
+					} else {
+						t = *ot;
+					}
+				}); // MAYTHROW
+				return t;
+			}
+
+			template<typename T>
+			void assign_expect_parse_characters(T& t, auto const& parser) & MAYTHROW {
+				t = expect_parse_characters(parser); // MAYTHROW
+			}
+
+			template<typename T, template<typename> typename Parser>
+			void assign_expect_parse_characters(T& t, Parser<tc::deduce_tag> const&) & MAYTHROW {
+				t = expect_parse_characters(Parser<T>()); // MAYTHROW
+			}
+
+			bool child(Namespace ons, auto const& strName) & MAYTHROW {
+				EnsureFreshSkipWhitespaceCharacters(); // MAYTHROW
+				switch_no_default(m_exmlentity) {
+				case exmlentityEMPTYELEMENT:
+				case exmlentityOPENINGTAG:
+					{
+						auto const paironsstr = expanded_name(); // MAYTHROW
+						if(ons==paironsstr.first && tc::equal(strName, paironsstr.second)) {
+							m_bConsumed=true;
+							return true;
+						}
+					}
+					[[fallthrough]];
+				case exmlentityEMPTYELEMENTCLOSING:
+				case exmlentityCLOSINGTAG:
+					m_bConsumed=false;
+					return false;
+				}
+			}
+
+			bool child(auto const& strName) & MAYTHROW {
+				return child(/*ons*/ nullptr, strName); // MAYTHROW
+			}
+
+			// For <mso:control id="..."> return the range 'mso:control'
+			auto qualified_tag_name() const& noexcept {
+				_ASSERTANYOF(m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityEMPTYELEMENTCLOSING)(exmlentityOPENINGTAG)(exmlentityCLOSINGTAG));
+				return m_strMain;
+			}
+
+			// For <mso:control id="..."> return the pair ['mso', 'control']
+			// as a std::pair of subranges.
+			// The namespace prefix may be an empty range.
+			auto prefix_and_tag_name() const& noexcept {
+				return split_qualified_name(qualified_tag_name());
+			}
+
+			// For <mso:control id="..."> return a std::pair<Namespace, String>
+			// with the namespace for prefix 'mso' and local name 'control'.
+			// Namespace may be nullptr if the current tag has no namespace.
+			// https://www.w3.org/TR/2006/REC-xml-names11-20060816/#concepts
+			auto expanded_name() & MAYTHROW {
+				auto const pairstrstr = prefix_and_tag_name();
+				auto const ons = namespace_for_prefix(pairstrstr.first);
+				
+				// Namespace prefixes must be declared
+				// https://www.w3.org/TR/2006/REC-xml-names11-20060816/#nsc-NSDeclared
+				if(!ons && !tc::empty(pairstrstr.first)) {
+					this->template error_at<tc_mem_fn(.invalid_namespace_prefix)>(m_itchEntityBegin); // MAYTHROW
+				}
+				
+				return std::make_pair(ons, pairstrstr.second);
+			}
+
+			bool child() & MAYTHROW {
+				EnsureFreshSkipWhitespaceCharacters(); // MAYTHROW
+				switch_no_default(m_exmlentity) {
+				case exmlentityEMPTYELEMENT:
+				case exmlentityOPENINGTAG:
+					m_bConsumed=true;
+					return true;
+				case exmlentityEMPTYELEMENTCLOSING:
+				case exmlentityCLOSINGTAG:
+					m_bConsumed=false;
+					return false;
+				}
+			}
+
+			void expect_child(Namespace ons, auto const& strName) & MAYTHROW {
+				if (!child(ons, strName)) {
+					this->template error_at<tc_mem_fn(.child_expected)>(m_itchEntityBegin, strName); // MAYTHROW
+				}
+			}
+
+			void expect_child(auto const& strName) & MAYTHROW {
+				expect_child(/*ons*/ nullptr, strName); // MAYTHROW
+			}
+
+			bool skip_child(Namespace ons, auto const& strName) & MAYTHROW {
+				if (child(ons, strName)) { // MAYTHROW
+					skip_rest_of_element(); // MAYTHROW
+					return true;
+				}
+				return false;
+			}
+
+			bool skip_child(auto const& strName) & MAYTHROW {
+				return skip_child(/*ons*/ nullptr, strName); // MAYTHROW
+			}
+
+			void expect_skip_child(Namespace ons, auto const& strName) & MAYTHROW {
+				if (!skip_child(ons, strName)) {
+					this->template error_at<tc_mem_fn(.child_expected)>(m_itchEntityBegin, strName); // MAYTHROW
+				}
+			}
+
+			void expect_skip_child(auto const& strName) & MAYTHROW {
+				expect_skip_child(/*ons*/ nullptr, strName); // MAYTHROW
+			}
+
+			void skip_rest_of_element() & MAYTHROW {
+				EnsureFresh(); // MAYTHROW
+				m_bConsumed=true;
+				if(exmlentityEMPTYELEMENTCLOSING!=m_exmlentity) {
+					int nOpenElements=1;
+					for(;;) {
+						switch(m_exmlentity) {
+						case exmlentityOPENINGTAG:
+							++nOpenElements;
+							break;
+						case exmlentityCLOSINGTAG:
+							--nOpenElements;
+							if(0==nOpenElements) return;
+							break;
+						default: ;
+						}
+						Next(); // MAYTHROW
+					}
+				}
+			}
+			
+			void skip_child_or_characters() & MAYTHROW {
+				EnsureFresh(); // MAYTHROW
+				m_bConsumed=false;
+				switch_no_default(m_exmlentity) {
+				case exmlentityEMPTYELEMENT:
+				case exmlentityCDATA:
+				case exmlentityCHARACTERS:
+					Next(); // MAYTHROW
+					break;
+				case exmlentityOPENINGTAG:
+					Next(); // MAYTHROW
+					skip_rest_of_element(); // MAYTHROW
+					break;
+				case exmlentityEMPTYELEMENTCLOSING:
+				case exmlentityCLOSINGTAG:
+					;
+				}
+			}
+
+			bool element_end() & MAYTHROW {
+				EnsureFreshSkipWhitespaceCharacters(); // MAYTHROW
+				switch_no_default(m_exmlentity) {
+				case exmlentityEMPTYELEMENTCLOSING:
+				case exmlentityCLOSINGTAG:
+					m_bConsumed=true;
+					return true;
+				case exmlentityEMPTYELEMENT:
+				case exmlentityOPENINGTAG:
+					m_bConsumed=false;
+					return false;
+				}
+			}
+
+			void expect_element_end() & MAYTHROW {
+				if (!element_end()) {
+					this->template error_at<tc_mem_fn(.element_end_expected)>(m_itchEntityBegin); // MAYTHROW
+				}
+			}
+
+			[[nodiscard]] auto attribute(auto const& strName) & noexcept {
+				// TODO: Attributes can have qualified names **but** the default namespace never applies to unqualified attributes:
+				// An attribute with unqualified name always has no namespace value, not the default namespace.
+				// See https://www.w3.org/TR/2006/REC-xml-names11-20060816/#scoping-defaulting
+				_ASSERTANYOF(m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityOPENINGTAG));
+				return tc::and_then(
+					tc::find_first_if<tc::return_element_or_null>(m_vecpairstrAttributes, [&](auto const& pairstrstr) noexcept {
+						return tc::equal(pairstrstr.first, strName);
+					}),
+					[&](auto const& pairstrstr) noexcept {
+						return std::optional(xml::decode(pairstrstr.second));
+					}
+				);
+			}
+
+			[[nodiscard]] auto attributes() const& noexcept {
+				return tc::transform(
+					m_vecpairstrAttributes,
+					[&](auto const& pairstrstr) noexcept {
+						// FIXME: Support attribute without value
+						return std::make_pair(pairstrstr.first, xml::decode(pairstrstr.second));
+					}
+				);
+			}
+
+			[[nodiscard]] auto expect_attribute(auto& strName) & MAYTHROW {
+				auto ostr = attribute(strName);
+				if (!ostr) {
+					this->template error_at<tc_mem_fn(.attribute_expected)>(m_itchEntityBegin, m_strMain, strName); // MAYTHROW
+				}
+				return *tc_move(ostr);
+			}
+
+			[[nodiscard]] auto parse_attribute(auto const& parser, auto const& strName) & MAYTHROW {
+				return tc::and_then(attribute(strName), [&](auto const& strAttribute) MAYTHROW {
+					auto ot = parser(strAttribute);
+					if (!ot) {
+						this->template warning_at<tc_mem_fn(.parse_warning)>(m_itchEntityBegin, m_strMain, strName); // MAYTHROW
+					}
+					return ot;
+				});
+			}
+
+			[[nodiscard]] auto expect_parse_attribute(auto const& parser, auto const& strName) & MAYTHROW {
+				auto ot = parser(expect_attribute(strName)); // MAYTHROW
+				if (!ot) {
+					this->template error_at<tc_mem_fn(.parse_error)>(m_itchEntityBegin, m_strMain, strName); // MAYTHROW
+				}
+				return *tc_move(ot);
+			}
+
+			template<typename T, template<typename> typename Parser>
+			void assign_expect_parse_attribute(T& t, Parser<tc::deduce_tag> const&, auto const& strName) & MAYTHROW {
+				t = expect_parse_attribute(Parser<T>(), strName); // MAYTHROW
+			}
+
+			template<typename Str>
+			Namespace /* may be nullptr */ namespace_for_prefix(Str const& strNsPrefix) const& noexcept {
+				if(auto const opairstrns = tc::find_last_if<tc::return_element_or_null>(
+					m_stkpairstrns,
+					[&](auto const& pairstrns) noexcept {
+						return c_nsStackSeparator!=pairstrns.second
+							&& tc::equal(pairstrns.first, strNsPrefix);
+					}
+				)) {
+					return opairstrns->second;
+				} else {
+					return nullptr;
+				}
+			}
+			
+		protected:
+			tc::make_subrange_result_t< String const& > m_strMain;
+			EXmlEntity m_exmlentity=exmlentitySTART;
+			bool m_bConsumed;
+				
+#ifdef _MSC_VER
+			static constexpr Namespace c_nsStackSeparator = std::addressof(tc_as_constexpr(tc::string<char_type>{}));
+#else
+# if defined(__clang__)
+			static_assert(__clang_major__ == 14, "Is this workaround needed in Xcode 15?");
+# endif
+			static tc::string<char_type> const c_strDummy;
+			static Namespace const c_nsStackSeparator;
+#endif
+			tc::vector<std::pair<tc::string< char_type >, Namespace>> m_stkpairstrns; // must not store sub_range in case input string is discarded
+
+		private:
+			tc::iterator_t<String const> m_itchEntityBegin;
+			tc::vector<std::pair<tc::make_subrange_result_t< String const& >, tc::make_subrange_result_t< String const& >>> m_vecpairstrAttributes;
+			
+			void WithCharacters(auto func) & MAYTHROW {
+				IF_TC_CHECKS(bool bOnce = false;)
+				tc::for_each(
+					characters(), // MAYTHROW
+					no_adl::with_iterator_range{
+						[&](auto const& strCharacters) MAYTHROW {
+							_ASSERT(tc::change(bOnce, true));
+							func(strCharacters);
+						}
+					}
+				);
+			}
+
+			void SkipUntil(char_type const ch) & MAYTHROW {
+				for(;;) {
+					this->expect_not_end(); // MAYTHROW
+					if(ch==*this->m_itchInput) break;
+					++this->m_itchInput;
+				}
+			}
+
+			void SkipOverGreaterThan() & MAYTHROW {
+				SkipUntil(tc::char_ascii('>')); // MAYTHROW
+				++this->m_itchInput;
+			}
+
+			void SkipOver(char_type const ch1, char_type const ch2) & MAYTHROW {
+				bool bHave1=false;
+				this->expect_not_end(); // MAYTHROW
+				for(;;) {
+					bHave1 = ch1==*this->m_itchInput;
+					++this->m_itchInput;
+					this->expect_not_end(); // MAYTHROW
+					if(ch2==*this->m_itchInput && bHave1) break;
+				}
+				++this->m_itchInput;
+			}
+
+			void Next() & MAYTHROW {
+			restart:
+				if constexpr (has_discard_until<decltype((*this->m_strInput))>::value) {
+					this->m_strInput->discard_until(tc::iterator2index<String>(this->m_itchInput));
+				}
+
+				this->expect_not_end(); // MAYTHROW
+				m_itchEntityBegin=this->m_itchInput;
+				switch(m_exmlentity) {
+				case exmlentityCLOSINGTAG:
+				case exmlentityEMPTYELEMENTCLOSING:
+					tc::take_inplace(
+						m_stkpairstrns,
+						tc::find_last_if<tc::return_element>(m_stkpairstrns, [&](auto const& pairstrns) noexcept {
+							return c_nsStackSeparator==pairstrns.second;
+						})
+					);
+					break;
+				default: ;
+				};
+
+				if(tc::char_ascii('<')==*this->m_itchInput) {
+					++this->m_itchInput;
+					this->expect_not_end(); // MAYTHROW
+					switch(*this->m_itchInput) {
+					case tc::explicit_cast<char_type>('>'):
+						this->template error<tc_mem_fn(.name_expected)>(); // MAYTHROW
+					case tc::explicit_cast<char_type>('?'): // processing instruction or prolog
+						++this->m_itchInput;
+						SkipOver(tc::char_ascii('?'), tc::char_ascii('>'));
+						goto restart;
+					case tc::explicit_cast<char_type>('/'): // closing tag
+					{
+						++this->m_itchInput;
+						auto const itchBegin=this->m_itchInput;
+						SkipOverGreaterThan();
+						m_exmlentity=exmlentityCLOSINGTAG;
+						m_strMain=tc::slice(this->input(), itchBegin, tc_modified(this->m_itchInput, --_));
+						return;
+					}
+					case tc::explicit_cast<char_type>('!'):
+						++this->m_itchInput;
+						this->expect_not_end(); // MAYTHROW
+						switch(*this->m_itchInput) {
+						case tc::explicit_cast<char_type>('-'): // comment
+							++this->m_itchInput;
+							this->expect_literal("-"_tc);
+							SkipOver(tc::char_ascii('-'), tc::char_ascii('-'));
+							this->expect_literal(">"_tc);
+							goto restart;
+						case tc::explicit_cast<char_type>('['): // CDATA
+							++this->m_itchInput;
+							this->expect_literal("CDATA["_tc);
+
+							{
+								auto const itchBegin=this->m_itchInput;
+								int nClosing;
+								decltype(this->m_itchInput) aitchEnd[2];
+								goto start;
+
+								for(;;) {
+									do {
+										++this->m_itchInput;
+									start:
+										this->expect_not_end(); // MAYTHROW
+									} while(tc::char_ascii(']')!=*this->m_itchInput);
+
+									nClosing=0;
+									do {
+										aitchEnd[nClosing&1]=this->m_itchInput;
+										++this->m_itchInput;
+										this->expect_not_end(); // MAYTHROW
+										++nClosing;
+									} while(tc::char_ascii(']')==*this->m_itchInput);
+
+									if(2<=nClosing && tc::char_ascii('>')==*this->m_itchInput) break;
+								}
+								m_strMain=tc::slice(this->input(), itchBegin, aitchEnd[nClosing&1]);
+							}
+							++this->m_itchInput;
+							m_exmlentity=exmlentityCDATA;
+							return;
+						default: // DOCTYPE, ENTITY, etc.
+							this->template error_at<tc_mem_fn(.unsupported_declaration_found)>(m_itchEntityBegin); // MAYTHROW
+						}
+					default: // opening tag or empty element
+						tc::cont_assign(m_vecpairstrAttributes);
+						tc::cont_emplace_back(m_stkpairstrns, tc::take(this->input(), tc::begin(this->input())), c_nsStackSeparator);
+
+						auto itchBegin=this->m_itchInput;
+						++this->m_itchInput;
+						for(;;) {
+							this->expect_not_end(); // MAYTHROW
+							switch(*this->m_itchInput) {
+							default:
+								++this->m_itchInput;
+								break;
+							case tc::explicit_cast<char_type>('>'):
+								m_strMain=tc::slice(this->input(), itchBegin, this->m_itchInput);
+								++this->m_itchInput;
+								m_exmlentity=exmlentityOPENINGTAG;
+								return;
+							case tc::explicit_cast<char_type>('/'):
+								m_strMain=tc::slice(this->input(), itchBegin, this->m_itchInput);
+								++this->m_itchInput;
+								this->expect_literal(">"_tc);
+								m_exmlentity=exmlentityEMPTYELEMENT;
+								return;
+							case_whitespace:
+								m_strMain=tc::slice(this->input(), itchBegin, this->m_itchInput);
+								++this->m_itchInput;
+								for(;;) {
+									this->skip_whitespace();
+									switch(*this->m_itchInput) {
+									case tc::explicit_cast<char_type>('>'):
+										++this->m_itchInput;
+										m_exmlentity=exmlentityOPENINGTAG;
+										return;
+									case tc::explicit_cast<char_type>('/'):
+										++this->m_itchInput;
+										this->expect_literal(">"_tc);
+										m_exmlentity=exmlentityEMPTYELEMENT;
+										return;
+									default: ;
+									}
+
+									auto strAttribute=[&]() MAYTHROW {
+										auto itchBegin = this->m_itchInput;
+										for(;;) {
+											switch(auto const ch = *this->m_itchInput) {
+											case tc::explicit_cast<char_type>('='):
+												{
+													auto strAttribute=tc::slice(this->input(), itchBegin, this->m_itchInput);
+													if (tc::empty(strAttribute)) {
+														this->template error<tc_mem_fn(.attribute_name_expected)>(); // MAYTHROW
+													}
+													++this->m_itchInput;
+													return strAttribute;
+												}
+											case_whitespace:
+												{
+													auto strAttribute=tc::slice(this->input(), itchBegin, this->m_itchInput);
+													++this->m_itchInput;
+													this->skip_whitespace();
+													this->expect_literal("="_tc);
+													return strAttribute;
+												}
+											default:
+												++this->m_itchInput;
+												this->expect_not_end(); // MAYTHROW
+											}
+										}
+									}();
+									this->skip_whitespace();
+
+									switch(auto const ch=*this->m_itchInput) {
+									default:
+										this->template error<tc_mem_fn(.quotation_marks_expected)>(); // MAYTHROW
+									case tc::explicit_cast<char_type>('"'): case tc::explicit_cast<char_type>('\''):
+										++this->m_itchInput;
+										itchBegin=this->m_itchInput;
+										SkipUntil(ch);
+
+										auto strValue = tc::slice(this->input(), itchBegin, this->m_itchInput);
+										if(auto ostrPrefix = [&]() MAYTHROW -> std::optional<tc::make_subrange_result_t<String const&>> {
+											if(auto ostr = tc::starts_with<tc::return_drop_or_none>(strAttribute, tc_ascii("xmlns"))) {
+												if(tc::starts_with<tc::return_bool>(*ostr, tc_ascii(":"))) {
+													tc::drop_first_inplace(*ostr);
+													if(tc::empty(*ostr)) {
+														this->template error_at<tc_mem_fn(.parse_error)>(m_itchEntityBegin, m_strMain, strAttribute); // MAYTHROW
+													}
+													return ostr;
+												} else if(tc::empty(*ostr)) {
+													return ostr;
+												}
+											}
+											return std::nullopt;
+										}()) {
+											tc::cont_emplace_back(
+												m_stkpairstrns,
+												tc_move_always(*ostrPrefix),
+												tc::empty(strValue) ? nullptr : this->register_namespace(strValue)
+											);
+										} else {
+											tc::cont_emplace_back(m_vecpairstrAttributes, tc_move(strAttribute), strValue);
+										}
+										++this->m_itchInput;
+									}
+								}
+							}
+						}
+					}
+				} else {
+					++this->m_itchInput;
+					SkipUntil(tc::char_ascii('<'));
+					m_strMain=tc::slice(this->input(), m_itchEntityBegin, this->m_itchInput);
+					m_exmlentity=exmlentityCHARACTERS;
+				}
+			}
+
+			void SkipWhitespaceCharacters() & MAYTHROW {
+				for(;;) {
+					switch(m_exmlentity) {
+					default:
+						return;
+					case exmlentityCDATA:
+						this->template error_at<tc_mem_fn(.unsupported_declaration_found)>(m_itchEntityBegin); // MAYTHROW
+					case exmlentityCHARACTERS:
+						tc_auto_cref(itEnd, tc::end(m_strMain));
+						for (auto it = tc::begin(m_strMain); itEnd != it; ++it) {
+							switch(*it) {
+							default:
+								this->template error_at<tc_mem_fn(.characters_unexpected)>(it); // MAYTHROW
+							case_whitespace:
+								;
+							}
+						};
+						Next(); // MAYTHROW
+					}
+				}
+			}
+
+			void EnsureFresh() & MAYTHROW {
+				if(m_bConsumed) {
+					if(exmlentityEMPTYELEMENT==m_exmlentity) {
+						m_exmlentity=exmlentityEMPTYELEMENTCLOSING;
+					} else {
+						Next();
+					}
+				}
+
+			}
+
+			void EnsureFreshSkipWhitespaceCharacters() & MAYTHROW {
+				EnsureFresh(); // MAYTHROW
+				SkipWhitespaceCharacters(); // MAYTHROW
+			}
+		};
+#pragma pop_macro("case_whitespace")
+
+#ifndef _MSC_VER
+		template<typename String, typename ErrorHandler> tc::string<typename parser<String, ErrorHandler>::char_type> const parser<String, ErrorHandler>::c_strDummy{};
+		template<typename String, typename ErrorHandler> typename parser<String, ErrorHandler>::Namespace const parser<String, ErrorHandler>::c_nsStackSeparator = std::addressof(c_strDummy);
+#endif
+	}
+	using no_adl::simple_error_handler;
+	using no_adl::namespace_info;
+	using no_adl::parser;
+
+	inline auto constexpr throw_parse_error = simple_error_handler([](tc::unused /*strInput*/) THROW(tc::xml::parse_error) {
+		throw tc::xml::parse_error();
+	});
+
+	template<typename String, typename ErrorHandler, typename... Args>
+	[[nodiscard]] auto make_parser(String&& str, ErrorHandler&& errorhandler, Args&&... args) MAYTHROW {
+		return no_adl::parser<String, tc::decay_t<ErrorHandler>>(tc_move_if_owned(str), tc_move_if_owned(errorhandler), tc_move_if_owned(args)...); // MAYTHROW
+	}
+	
+	void for_each_descendant( auto& parser, auto funcOpen, auto funcClose) MAYTHROW {
+		int nOpenElements = 1;
+		for(;;) {
+			if(parser.child()) { // MAYTHROW
+				++nOpenElements;
+				funcOpen();
+			} else {
+				--nOpenElements;
+				if(0==nOpenElements) break;
+
+				parser.expect_element_end(); // MAYTHROW
+				funcClose();
+			}
+		}
+	}
+
+	namespace no_adl {
+		inline struct {
+			[[nodiscard]] std::optional<bool> operator()(auto const& str) const& noexcept {
+				if (tc::equal(str, tc_ascii("0")) || tc::equal(str, tc_ascii("false"))) {
+					return false;
+				} else if (tc::equal(str, tc_ascii("1")) || tc::equal(str, tc_ascii("true"))) {
+					return true;
+				} else {
+					return std::nullopt;
+				}
+			}
+		} constexpr boolean;
+
+		template<typename T>
+		struct IntegerParser final {
+			[[nodiscard]] std::optional<T> operator()(auto const& str) const& noexcept requires tc::actual_integer<T> && std::is_signed<T>::value {
+				return tc::x3parser(x3::int_parser<T>())(str);
+			}
+		};
+		template<typename T=tc::deduce_tag>
+		constexpr IntegerParser<T> integer = IntegerParser<T>();
+
+		template<typename T>
+		struct NonNegativeIntegerParser final {
+			[[nodiscard]] std::optional<T> operator()(auto const& str) const& noexcept requires tc::actual_integer<T> {
+				return tc::x3parser(x3::uint_parser<T>())(str);
+			}
+		};
+		template<typename T=tc::deduce_tag>
+		constexpr NonNegativeIntegerParser<T> nonNegativeInteger = NonNegativeIntegerParser<T>();
+
+		template<typename T>
+		struct RealParser final {
+			[[nodiscard]] std::optional<T> operator()(auto const& str) const& noexcept requires std::floating_point<T> {
+				return tc::x3parser(x3::real_parser<T>())(str);
+			}
+		};
+		template<typename T=tc::deduce_tag>
+		constexpr RealParser<T> real = RealParser<T>();
+	}
+	using no_adl::boolean;
+	using no_adl::integer;
+	using no_adl::nonNegativeInteger;
+	using no_adl::real;
+}
+
+namespace tc {
+	template<typename Rng>
+	constexpr auto enable_stable_index_on_move<xml::no_adl::decode_adaptor<Rng>> = tc::stable_index_on_move<Rng>;
+}
+
diff --git a/tc/string/xmlparser.t.cpp b/tc/string/xmlparser.t.cpp
new file mode 100644
index 0000000..26a61aa
--- /dev/null
+++ b/tc/string/xmlparser.t.cpp
@@ -0,0 +1,625 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#include "../base/assert_defs.h"
+#include "../base/ref.h"
+#include "../unittest.h"
+
+#include "xmlparser.h"
+#include "xmltransform.h"
+
+using SAssertingErrorHandler = tc::xml::simple_error_handler<decltype([](tc::unused) noexcept { _ASSERTFALSE; })>;
+struct ExErrorHandled final {};
+
+UNITTESTDEF(xmlparser_error_handling) {
+	{
+		struct SErrorHandler final : SAssertingErrorHandler {
+			void child_expected(tc::span<char const> strInput, char const* itch, tc::span<char const> strName) const& THROW(ExErrorHandled) {
+				_ASSERT(tc::equal(strInput, "<a></a>"));
+				_ASSERT(tc::equal(tc::drop(strInput, itch), "</a>"));
+				_ASSERT(tc::equal(strName, "b"));
+				throw ExErrorHandled();
+			}
+		};
+		auto parser = tc::xml::make_parser("<a></a>", SErrorHandler());
+		parser.expect_child("a");
+		try {
+			parser.expect_child("b");
+			_ASSERTFALSE;
+		} catch (ExErrorHandled const&) {
+		}
+	}
+	{
+		struct SErrorHandler final : SAssertingErrorHandler {
+			void attribute_expected(tc::span<char const> strInput, char const* itch, tc::span<char const> strTag, tc::span<char const> strName) const& THROW(ExErrorHandled) {
+				_ASSERT(tc::equal(tc::drop(strInput, itch), strInput));
+				_ASSERT(tc::equal(strTag, "tag"));
+				_ASSERT(tc::equal(strName, "missing"));
+				throw ExErrorHandled();
+			}
+		};
+		auto parser = tc::xml::make_parser("<tag name=\"value\"></tag>", SErrorHandler());
+		parser.expect_child("tag");
+		try {
+			tc::discard(parser.expect_attribute("missing"));
+			_ASSERTFALSE;
+		} catch (ExErrorHandled const&) {
+		}
+	}
+	{
+		struct SErrorHandler final : SAssertingErrorHandler {
+			void parse_error(tc::unused, tc::unused, tc::unused) const& THROW(ExErrorHandled) {
+				throw ExErrorHandled();
+			}
+			void parse_error(tc::unused, tc::unused, tc::unused, tc::unused) const& THROW(ExErrorHandled) {
+				throw ExErrorHandled();
+			}
+		};
+		auto parser = tc::xml::make_parser("<a>one</a>", SErrorHandler());
+		_ASSERT(parser.child("a"));
+		try {
+			tc::discard(parser.expect_parse_characters(tc::xml::integer<int>));
+			_ASSERTFALSE;
+		} catch (ExErrorHandled const&) {
+		}
+	}
+	{
+		struct SErrorHandler final : SAssertingErrorHandler {
+			void parse_error(tc::unused, tc::unused, tc::unused, tc::unused) const& THROW(ExErrorHandled) {
+				throw ExErrorHandled();
+			}
+		};
+		auto parser = tc::xml::make_parser("<a number=\"one\"></a>", SErrorHandler());
+		_ASSERT(parser.child("a"));
+		try {
+			tc::discard(parser.expect_parse_attribute(tc::xml::integer<int>, "number"));
+			_ASSERTFALSE;
+		} catch (ExErrorHandled const&) {
+		}
+	}
+}
+
+namespace {
+	constexpr char c_strMsoNamespace[] = {"http://schemas.microsoft.com/office/2009/07/customui"};
+}
+
+UNITTESTDEF(namespace_) {
+	static constexpr char asz[] = R"(
+<mso:customUI xmlns:mso="http://schemas.microsoft.com/office/2009/07/customui">
+	<mso:ribbon>
+		<mso:qat/>
+		<mso:tabs/>
+	</mso:ribbon>
+</mso:customUI>
+)";
+	auto parser=tc::xml::make_parser(asz, SAssertingErrorHandler());
+	auto const nsMSO = parser.register_namespace(c_strMsoNamespace);
+	_ASSERT(parser.register_namespace("http://schemas.microsoft.com/office/2009/07/CustomUI") != nsMSO);
+	_ASSERT(parser.register_namespace("http://schemas.microsoft.com/office/2009/&#x30;&#x37;/customui") == nsMSO);
+	_ASSERT(parser.register_namespace("http://schemas.microsoft.com/office/2009/&#48;&#55;/customui") == nsMSO);
+	NOEXCEPT(parser.expect_child(nsMSO, "customUI"));
+		NOEXCEPT(parser.expect_child(nsMSO, "ribbon"));
+			_ASSERT(!parser.child("qat"));
+			_ASSERT(!parser.child("mso:qat"));
+			NOEXCEPT(parser.expect_child(nsMSO, "qat"));
+			NOEXCEPT(parser.skip_rest_of_element());
+			NOEXCEPT(parser.expect_child(nsMSO, "tabs"));
+}
+
+UNITTESTDEF(default_namespace) {
+	static constexpr char asz[] = R"(
+<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
+	<ribbon>
+		<qat/>
+		<tabs/>
+	</ribbon>
+</customUI>
+)";
+	
+	auto parser=tc::xml::make_parser(asz, SAssertingErrorHandler());
+	auto const nsMSO = parser.register_namespace(c_strMsoNamespace);
+	NOEXCEPT(parser.expect_child(nsMSO, "customUI"));
+		NOEXCEPT(parser.expect_child(nsMSO, "ribbon"));
+			_ASSERT(!parser.child("qat")); // default namespace has a namespace value, so it must match
+			NOEXCEPT(parser.expect_child(nsMSO, "qat"));
+			NOEXCEPT(parser.skip_rest_of_element());
+			NOEXCEPT(parser.expect_child(nsMSO, "tabs"));
+}
+
+UNITTESTDEF(namespace_prefix_undeclared) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="">
+	<ribbon>
+		<mso:qat/>
+		<mso:tabs xmlns:mso="test"/>
+		<mso:tabs/>
+	</ribbon>
+</customUI>
+)";
+	
+	struct SErrorHandler final : SAssertingErrorHandler {
+		void invalid_namespace_prefix(tc::unused, tc::unused) const& THROW(ExErrorHandled) {
+			throw ExErrorHandled();
+		}
+	};
+	
+	auto parser=tc::xml::make_parser(asz, SErrorHandler());
+	try {
+		NOEXCEPT(parser.expect_child("customUI")); // default namespace has no value
+		NOEXCEPT(parser.expect_child("ribbon"));
+		parser.expect_child("qat"); // Prefixes must be declared and not have empty value: https://www.w3.org/TR/2006/REC-xml-names11-20060816/#nsc-NSDeclared
+		_ASSERTFALSE;
+	} catch(ExErrorHandled const&) {
+	}
+}
+
+UNITTESTDEF(namespace_override) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="">
+	<ribbon>
+		<qat/>
+		<mso:tabs xmlns:mso="test"/>
+		<mso:tabs/>
+	</ribbon>
+</customUI>
+)";
+	
+	auto parser=tc::xml::make_parser(asz, SAssertingErrorHandler());
+	auto const nsTEST = parser.register_namespace("test");
+	
+	NOEXCEPT(parser.expect_child("customUI")); // default namespace has no value
+	NOEXCEPT(parser.expect_child("ribbon"));
+	NOEXCEPT(parser.expect_child("qat"));
+	NOEXCEPT(parser.skip_rest_of_element());
+	NOEXCEPT(parser.expect_child(nsTEST, "tabs"));
+}
+
+UNITTESTDEF(default_namespace_override) {
+	static constexpr char asz[] = R"(
+<customUI xmlns="test">
+	<ribbon>
+		<qat/>
+		<tabs xmlns=""/>
+		<tabs/>
+	</ribbon>
+</customUI>
+)";
+	
+	auto parser=tc::xml::make_parser(asz, SAssertingErrorHandler());
+	auto const nsTEST = parser.register_namespace("test");
+	
+	NOEXCEPT(parser.expect_child(nsTEST, "customUI")); // default namespace has a value
+	NOEXCEPT(parser.expect_child(nsTEST, "ribbon"));
+	_ASSERT(!parser.child("qat"));
+	NOEXCEPT(parser.expect_child(nsTEST, "qat"));
+	NOEXCEPT(parser.skip_rest_of_element());
+	_ASSERT(!parser.child(nsTEST, "tabs"));
+	NOEXCEPT(parser.expect_child("tabs"));
+}
+
+UNITTESTDEF(xml_transform_append) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="">
+	<ribbon>
+		<qat></qat>
+		<mso:tabs xmlns:mso="test"/>
+		<tabs/>
+	</ribbon>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		auto const nsTEST = transform.register_namespace("test");
+			
+		NOEXCEPT(transform.expect_child("customUI"));
+		NOEXCEPT(transform.expect_child("ribbon"));
+		NOEXCEPT(transform.expect_child("qat"));
+
+		NOEXCEPT(tc::append(
+			transform,
+			tc::xml::opening_element("test"),
+			tc::xml::closing_element("test")
+		));
+		
+		NOEXCEPT(transform.skip_rest_of_element());
+		NOEXCEPT(transform.expect_child(nsTEST, "tabs"));
+
+		auto const strPrefix = transform.prefix_for_namespace(nsTEST);
+		NOEXCEPT(tc::append(
+			transform,
+			tc::xml::opening_element(strPrefix, "test"),
+			tc::xml::closing_element(strPrefix, "test"),
+			tc::xml::opening_element(strPrefix, "test2"),
+			tc::xml::closing_element(strPrefix, "test2")
+		));
+		NOEXCEPT(transform.expect_element_end());
+		NOEXCEPT(transform.expect_child("tabs"));
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+		auto const nsTEST = parser.register_namespace("test");
+			
+		NOEXCEPT(parser.expect_child("customUI"));
+			NOEXCEPT(parser.expect_child("ribbon"));
+			NOEXCEPT(parser.expect_child("qat"));
+			NOEXCEPT(parser.expect_child("test"));
+				NOEXCEPT(parser.expect_element_end());
+			NOEXCEPT(parser.expect_element_end());
+			  
+		NOEXCEPT(parser.expect_child(nsTEST, "tabs"));
+			NOEXCEPT(parser.expect_child(nsTEST, "test"));
+			NOEXCEPT(parser.expect_element_end());
+			NOEXCEPT(parser.expect_child(nsTEST, "test2"));
+			NOEXCEPT(parser.expect_element_end());
+		NOEXCEPT(parser.expect_element_end());
+	}
+}
+
+
+UNITTESTDEF(xml_transform_insert_and_parse) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="">
+	<ribbon>
+		<qat></qat>
+		<mso:tabs xmlns:mso="test"/>
+		<tabs/>
+	</ribbon>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		auto const nsTEST = transform.register_namespace("test");
+			
+		NOEXCEPT(transform.expect_child("customUI"));
+		NOEXCEPT(transform.expect_child("ribbon"));
+		{
+			auto const e = NOEXCEPT(transform.insert_elements_after(
+				tc::concat( 
+					tc::xml::opening_element("test"),
+					tc::xml::opening_element("test2")
+				),
+				tc::concat( 
+					tc::xml::closing_element("test2"),
+					tc::xml::closing_element("test")
+				)
+			));
+
+			NOEXCEPT(transform.expect_child("qat"));
+			NOEXCEPT(transform.skip_rest_of_element());
+		}
+
+		NOEXCEPT(transform.expect_child(nsTEST, "tabs"));
+
+		{
+			auto const e = NOEXCEPT(transform.insert_elements_before(
+				tc::concat( 
+					tc::xml::opening_element("test"),
+					tc::xml::opening_element("test2")
+				),
+				tc::concat( 
+					tc::xml::closing_element("test2"),
+					tc::xml::closing_element("test")
+				)
+			));
+			NOEXCEPT(transform.expect_element_end());
+			NOEXCEPT(transform.expect_child("tabs"));
+			NOEXCEPT(transform.drop_element());
+		}
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+		auto const nsTEST = parser.register_namespace("test");
+			
+		NOEXCEPT(parser.expect_child("customUI"));
+			NOEXCEPT(parser.expect_child("ribbon"));
+				NOEXCEPT(parser.expect_child("test"));
+					NOEXCEPT(parser.expect_child("test2"));
+						NOEXCEPT(parser.expect_child("qat"));
+						NOEXCEPT(parser.expect_element_end());
+					NOEXCEPT(parser.expect_element_end());
+				NOEXCEPT(parser.expect_element_end());
+
+				
+				NOEXCEPT(parser.expect_child("test"));
+					NOEXCEPT(parser.expect_child("test2"));
+						NOEXCEPT(parser.expect_child(nsTEST, "tabs"));
+						NOEXCEPT(parser.expect_element_end());
+					NOEXCEPT(parser.expect_element_end());
+				NOEXCEPT(parser.expect_element_end());
+			NOEXCEPT(parser.expect_element_end());
+		NOEXCEPT(parser.expect_element_end());
+	}
+}
+
+UNITTESTDEF(xml_transform_modify_attributes) {
+	static constexpr char asz[] = R"(
+<customUI>
+	<ribbon foo="1" bar="something"/>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		NOEXCEPT(transform.expect_child("customUI"));
+		NOEXCEPT(transform.expect_child("ribbon"));
+		NOEXCEPT(transform.modify_element_attributes(
+			tc::xml::format_attributes(
+				tc::filter(
+					transform.attributes(),
+					[](auto const& strKey, auto const& strValue) noexcept {
+						return !tc::equal(strKey, "foo");
+					}
+				)
+			),
+			" foo=\"2\""
+		));
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+			
+		NOEXCEPT(parser.expect_child("customUI"));
+		NOEXCEPT(parser.expect_child("ribbon"));
+		_ASSERT(tc::equal(*parser.attribute("bar"), "something"));
+		_ASSERT(tc::equal(*parser.attribute("foo"), "2"));
+	}
+}
+
+UNITTESTDEF(xml_transform_insert_empty_child_before) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="test">
+	<ribbon/>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		auto const nsTEST = transform.register_namespace("test");
+
+		NOEXCEPT(transform.expect_child("customUI"));
+		// lookup strPrefix here because we are doing insert_before()!
+		// <ribbon> may change the prefix of namespace test
+		auto const strPrefix = transform.prefix_for_namespace(nsTEST);
+
+		NOEXCEPT(transform.expect_child("ribbon"));
+		NOEXCEPT(tc::append(
+			transform.insert_before(),
+			tc::xml::empty_element(
+				strPrefix,
+				"element",
+				" foo=\"bar\""
+			)
+		));
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+		auto const nsTEST = parser.register_namespace("test");
+		NOEXCEPT(parser.expect_child("customUI"));
+			NOEXCEPT(parser.expect_child(nsTEST, "element"));
+			_ASSERT(tc::equal(*parser.attribute("foo"), "bar"));
+			NOEXCEPT(parser.expect_element_end());
+
+			NOEXCEPT(parser.expect_child("ribbon"));
+			NOEXCEPT(parser.expect_element_end());
+		NOEXCEPT(parser.expect_element_end());
+	}
+}
+
+
+UNITTESTDEF(xml_transform_insert_before2) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="test">
+	<ribbon/>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		auto ons = transform.register_namespace("test");
+		NOEXCEPT(transform.expect_child("customUI"));
+		NOEXCEPT(transform.expect_child("ribbon"));
+		NOEXCEPT(transform.expect_element_end());
+
+		auto const strPrefix = transform.prefix_for_namespace(ons);
+		NOEXCEPT(tc::append(
+			transform.insert_before(),
+			tc::xml::opening_element(strPrefix, "element", " foo=\"bar\""),
+			tc::xml::opening_element(strPrefix, "element2", " foo=\"bar\""),
+			tc::xml::closing_element(strPrefix, "element2"),
+			tc::xml::closing_element(strPrefix, "element")
+		));
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+		auto ons = parser.register_namespace("test");
+		NOEXCEPT(parser.expect_child("customUI"));
+			NOEXCEPT(parser.expect_child("ribbon"));
+				NOEXCEPT(parser.expect_child(ons, "element"));
+					NOEXCEPT(parser.expect_child(ons, "element2"));
+					NOEXCEPT(parser.expect_element_end());
+				NOEXCEPT(parser.expect_element_end());
+			NOEXCEPT(parser.expect_element_end());
+		NOEXCEPT(parser.expect_element_end());
+	}
+}
+
+UNITTESTDEF(xml_transform_insert_elements_before) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="test">
+	<ribbon/>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		auto ons = transform.register_namespace("test");
+		NOEXCEPT(transform.expect_child("customUI"));
+
+		auto const strPrefix = transform.prefix_for_namespace(ons);
+		NOEXCEPT(transform.expect_child("ribbon"));
+
+		auto b = NOEXCEPT(transform.insert_elements_before(
+			tc::concat(
+				tc::xml::opening_element(strPrefix, "element", " foo=\"bar\""),
+				tc::xml::opening_element(strPrefix, "element2", " foo=\"bar\"")
+			),
+			tc::concat(
+				tc::xml::closing_element(strPrefix, "element2"),
+				tc::xml::closing_element(strPrefix, "element")
+			)
+		));
+
+		NOEXCEPT(transform.expect_element_end());
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+		auto ons = parser.register_namespace("test");
+		NOEXCEPT(parser.expect_child("customUI"));
+			NOEXCEPT(parser.expect_child(ons, "element"));
+				NOEXCEPT(parser.expect_child(ons, "element2"));
+					NOEXCEPT(parser.expect_child("ribbon"));
+					NOEXCEPT(parser.expect_element_end());
+				NOEXCEPT(parser.expect_element_end());
+			NOEXCEPT(parser.expect_element_end());
+		NOEXCEPT(parser.expect_element_end());
+	}
+}
+
+
+UNITTESTDEF(xml_transform_insert_child_before3) {
+	static constexpr char asz[] = R"(
+<customUI xmlns:mso="test">
+	<ribbon/>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		auto ons = transform.register_namespace("test");
+		NOEXCEPT(transform.expect_child("customUI"));
+		NOEXCEPT(transform.expect_child("ribbon"));
+
+		auto const strPrefix = transform.prefix_for_namespace(ons);
+		if(!NOEXCEPT(transform.child("element"))) {
+			NOEXCEPT(tc::append(
+				transform.insert_before(),
+				tc::xml::opening_element(strPrefix, "element", " foo=\"bar\""),
+				tc::xml::opening_element(strPrefix, "element2", " foo=\"bar\""),
+				tc::xml::closing_element(strPrefix, "element2"),
+				tc::xml::closing_element(strPrefix, "element")
+			));
+		}
+
+		NOEXCEPT(transform.expect_element_end());
+		NOEXCEPT(transform.expect_element_end());
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+		auto ons = parser.register_namespace("test");
+		NOEXCEPT(parser.expect_child("customUI"));
+			NOEXCEPT(parser.expect_child("ribbon"));
+				NOEXCEPT(parser.expect_child(ons, "element"));
+					NOEXCEPT(parser.expect_child(ons, "element2"));
+					NOEXCEPT(parser.expect_element_end());
+				NOEXCEPT(parser.expect_element_end());
+			NOEXCEPT(parser.expect_element_end());
+	}
+}
+
+UNITTESTDEF(xml_transform_drop_element) {
+	static constexpr char asz[] = R"(
+<customUI>
+	<ribbon>
+		<qat></qat>
+		<mso:tabs xmlns:mso="test"/>
+		<mso:tabs/>
+	</ribbon>
+</customUI>
+)";
+	tc::string<char> strOutput;
+	{
+		auto transform=tc::xml::make_transform(asz, SAssertingErrorHandler(), strOutput);
+		NOEXCEPT(transform.expect_child("customUI"));
+		NOEXCEPT(transform.expect_child("ribbon"));
+		NOEXCEPT(transform.drop_element());
+	}
+	
+	{
+		auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+		NOEXCEPT(parser.expect_child("customUI"));
+		NOEXCEPT(parser.expect_element_end());
+	}
+}
+
+namespace
+{
+	// MSVC doesn't like it at function scope for some reason.
+	auto const MatchOrInsertTest = [](tc::span<char const> strXml) noexcept {
+		tc::string<char> strOutput;
+		{
+			auto transform=tc::xml::make_transform(strXml, SAssertingErrorHandler(), strOutput);
+			NOEXCEPT(transform.expect_child("customUI"));
+			auto on1 = NOEXCEPT(transform.match_or_insert_child("ribbon"));
+			auto on2 = NOEXCEPT(transform.match_or_insert_child("tabs"));
+		}
+	
+		{
+			auto parser=tc::xml::make_parser(strOutput, SAssertingErrorHandler());
+			NOEXCEPT(parser.expect_child("customUI"));
+				NOEXCEPT(parser.expect_child("ribbon"));
+					NOEXCEPT(parser.expect_child("tabs"));
+					NOEXCEPT(parser.expect_element_end());
+				NOEXCEPT(parser.expect_element_end());
+			NOEXCEPT(parser.expect_element_end());
+		}
+	};
+}
+
+UNITTESTDEF(xml_transform_match_or_insert_child) {
+	MatchOrInsertTest(R"(
+		<customUI>    
+		</customUI>
+	)");
+	
+	MatchOrInsertTest(R"(
+		<customUI>
+			<ribbon/>
+		</customUI>
+	)");
+	
+	MatchOrInsertTest(R"(
+		<customUI>
+			<ribbon></ribbon>
+		</customUI>
+	)");
+	
+	MatchOrInsertTest(R"(
+		<customUI>
+			<ribbon>
+				<tabs/>
+			</ribbon>
+		</customUI>
+	)");
+
+	MatchOrInsertTest(R"(
+		<customUI>
+			<ribbon>
+				<tabs>
+				</tabs>
+			</ribbon>
+		</customUI>
+	)");
+}
diff --git a/tc/string/xmltransform.h b/tc/string/xmltransform.h
new file mode 100644
index 0000000..ccff937
--- /dev/null
+++ b/tc/string/xmltransform.h
@@ -0,0 +1,357 @@
+
+// think-cell public library
+//
+// Copyright (C) 2016-2023 think-cell Software GmbH
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
+
+#pragma once
+
+#include "char.h"
+#include "xmlparser.h"
+#include "../range/conditional_range.h"
+
+namespace tc::xml {
+	[[nodiscard]] auto format_attributes(auto&& rngattr) noexcept {
+		return tc::join_with_separator(
+			tc_ascii(" "),
+			tc::transform(
+				tc_move_if_owned(rngattr),
+				[&](auto const& strKey, auto const& strValue) noexcept {
+					return tc::concat(strKey, tc_ascii("=\""), strValue, tc_ascii("\""));
+				}
+			) 
+		);
+	}
+
+	[[nodiscard]] auto opening_element(auto&& strPrefix, auto&& strElement, auto&& strAttributes) noexcept {
+		auto const bEmptyPrefix = tc::empty(strPrefix);
+		return tc::concat(
+			tc_ascii("<"),
+			tc_move_if_owned(strPrefix),
+			tc_conditional_range(!bEmptyPrefix, tc_ascii(":")),
+			tc_move_if_owned(strElement),
+			tc_move_if_owned(strAttributes),
+			tc_ascii(">")
+		);
+	}
+
+	[[nodiscard]] auto opening_element(auto&& strPrefix, auto&& strElement) noexcept {
+		return opening_element(tc_move_if_owned(strPrefix), tc_move_if_owned(strElement), tc::empty_range());
+	}
+
+	[[nodiscard]] auto opening_element(auto&& strElement) noexcept {
+		return opening_element(tc::empty_range(), tc_move_if_owned(strElement), tc::empty_range());
+	}
+
+	[[nodiscard]] auto closing_element(auto&& strPrefix, auto&& strElement) noexcept {
+		auto const bEmptyPrefix = tc::empty(strPrefix);
+		return tc::concat(
+			tc_ascii("</"),
+			tc_move_if_owned(strPrefix),
+			tc_conditional_range(!bEmptyPrefix, tc_ascii(":")),
+			tc_move_if_owned(strElement),
+			tc_ascii(">")
+		);
+	}
+
+	[[nodiscard]] auto closing_element(auto&& strElement) noexcept {
+		return closing_element(tc::empty_range(), tc_move_if_owned(strElement));
+	}
+
+	[[nodiscard]] auto empty_element(auto&& strPrefix, auto&& strElement, auto&& strAttributes) noexcept {
+		auto const bEmptyPrefix = tc::empty(strPrefix);
+		return tc::concat(
+			tc_ascii("<"),
+			tc_move_if_owned(strPrefix),
+			tc_conditional_range(!bEmptyPrefix, tc_ascii(":")),
+			tc_move_if_owned(strElement),
+			tc_move_if_owned(strAttributes),
+			tc_ascii("/>")
+		);
+	}
+
+	namespace no_adl {
+		template<typename String, typename ErrorHandler, typename Output>
+		struct [[nodiscard]] transform : private parser<String, ErrorHandler>, tc::inside_unwinding {
+		private:
+			using base_ = parser<String, ErrorHandler>;
+		public:
+			using typename base_::char_type;
+			
+			using SetNamespace=typename base_::SetNamespace;
+			using Namespace=typename base_::Namespace;
+
+			static_assert(!has_discard_until<decltype((*transform<String, ErrorHandler, Output>::m_strInput))>::value);
+
+			explicit transform(String&& strInput, ErrorHandler errorhandler, Output& output) MAYTHROW
+				: base_(std::forward<String>(strInput), tc_move(errorhandler)), m_output(output)
+				, m_itchOut(tc::begin(*(this->m_strInput)))
+			{}
+			
+			~transform() {
+				if(!inside_stack_unwinding()) {
+					if(OutputEmptyElementCloseTag()) { // MAYTHROW
+						// Skip the original empty element tag
+						_ASSERT(exmlentityEMPTYELEMENT==this->m_exmlentity || exmlentityEMPTYELEMENTCLOSING==this->m_exmlentity);
+						_ASSERT(exmlentityEMPTYELEMENTCLOSING==this->m_exmlentity || this->m_bConsumed);
+						if(exmlentityEMPTYELEMENT==this->m_exmlentity || !this->m_bConsumed) { 
+							base_::expect_element_end(); // MAYTHROW
+						}
+						_ASSERTEQUAL(this->m_exmlentity, exmlentityEMPTYELEMENTCLOSING);
+						_ASSERT(this->m_bConsumed);
+						m_itchOut = this->m_itchInput;
+					}
+					tc::append(
+						m_output,
+						tc::slice(*this->m_strInput, m_itchOut, tc::end(*this->m_strInput))
+					); // MAYTHROW
+				}
+			}
+			
+			template<typename ...Attributes>
+			void modify_element_attributes(Attributes&& ...attr) & MAYTHROW {
+				_ASSERT(this->m_bConsumed);
+				_ASSERTANYOF(this->m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityOPENINGTAG));
+				OutputBeforeElement(); // MAYTHROW
+
+				tc::append(
+					m_output,
+					tc_ascii("<"), this->qualified_tag_name(),
+					tc_ascii(" "),
+					tc_move_if_owned(attr)...,
+					tc_conditional_range(
+						exmlentityEMPTYELEMENT==this->m_exmlentity,
+						tc_ascii("/>"),
+						tc_ascii(">")
+					)
+				); // MAYTHROW
+				m_itchOut = this->m_itchInput;
+			}
+
+			[[nodiscard]] Output& insert_before() & noexcept {
+				if(exmlentityEMPTYELEMENTCLOSING==this->m_exmlentity) {
+					SplitEmptyElement(); // MAYTHROW
+				} else {
+					m_itchOut = OutputBeforeElement(); // MAYTHROW
+				}
+				return m_output;
+			}
+
+		private:
+			// just call tc::append(transform, ...) 
+			[[nodiscard]] Output& insert_after() & MAYTHROW {
+				_ASSERT(this->m_bConsumed);
+				_ASSERTANYOF(this->m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityEMPTYELEMENTCLOSING)(exmlentityOPENINGTAG)(exmlentityCLOSINGTAG));
+				if(exmlentityEMPTYELEMENT==this->m_exmlentity) {
+					SplitEmptyElement(); // MAYTHROW
+				} else {
+					tc::append(m_output, tc::slice(*this->m_strInput, m_itchOut, this->m_itchInput)); // MAYTHROW
+					m_itchOut = this->m_itchInput;
+				}
+				return m_output;
+			}
+
+		public:
+			friend auto appender_impl(transform& self) noexcept {
+				return tc::appender(
+					self.m_bConsumed
+					? self.insert_after()
+					: self.insert_before()
+				);
+			}
+
+			[[nodiscard]] auto insert_elements_before(auto&& strOpen, auto&& strClose) MAYTHROW {
+				// If inserting before a closing tag: What do you need the RAII return value for?
+				_ASSERTANYOF(this->m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityOPENINGTAG));
+				tc::append(insert_before(), tc_move_if_owned(strOpen)); // MAYTHROW
+				return tc::make_append_on_dtor(*this, tc_move_if_owned(strClose));
+			}
+
+			// insert_elements_after allows parsing and outputting further elements after
+			// appending strOpen and before appending strClose
+			[[nodiscard]] auto insert_elements_after(auto&& strOpen, auto&& strClose) MAYTHROW {
+				tc::append(insert_after(), tc_move_if_owned(strOpen)); // MAYTHROW
+				return tc::make_append_on_dtor(*this, tc_move_if_owned(strClose));
+			}
+
+		private:
+			[[nodiscard]] auto closing_element_on_dtor(auto&& strPrefix, auto&& strTag) noexcept {
+				return tc::make_append_on_dtor(
+					*this,
+					tc::xml::closing_element(tc_move_if_owned(strPrefix),tc_move_if_owned(strTag))
+				);
+			}
+
+		public:
+			template<typename Str>
+			[[nodiscard]] auto match_or_insert_child(Namespace ons, Str&& strTag) & MAYTHROW
+				-> std::optional<decltype(
+				closing_element_on_dtor(std::declval<tc::string<char_type>&&>(), std::forward<Str>(strTag))
+			)> {
+				auto strPrefix = prefix_for_namespace(ons);
+				if(this->child(ons, strTag)) { // MAYTHROW
+					return std::nullopt;
+				} else {
+					_ASSERT(!this->m_bConsumed);
+					tc::append(
+						insert_before(),
+						tc::xml::opening_element(strPrefix, strTag)
+					);
+					return closing_element_on_dtor(tc_move(strPrefix), tc_move_if_owned(strTag));
+				}
+			}
+
+			[[nodiscard]] auto match_or_insert_child(auto&& strTag) & MAYTHROW {
+				return match_or_insert_child(/*namespace*/ nullptr, tc_move_if_owned(strTag));
+			}
+
+			[[nodiscard]] auto drop_element_parse_children() & MAYTHROW {
+				_ASSERT(this->m_bConsumed);
+				_ASSERTANYOF(this->m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityOPENINGTAG));
+				OutputBeforeElement(); // MAYTHROW
+				m_itchOut = this->m_itchInput;
+
+				struct drop_closing_tag final : tc::noncopyable, tc::inside_unwinding {
+					explicit drop_closing_tag(transform& transform) noexcept : m_transform(transform) {}
+					drop_closing_tag(drop_closing_tag&&)=default;
+					~drop_closing_tag() MAYTHROW {
+						if(!inside_stack_unwinding()) {
+							m_transform.expect_element_end(); // MAYTHROW
+							if(exmlentityCLOSINGTAG==m_transform.m_exmlentity) {
+								m_transform.OutputBeforeElement(); // MAYTHROW
+								m_transform.m_itchOut = m_transform.m_itchInput;
+							} else {
+								_ASSERTEQUAL(m_transform.m_exmlentity, exmlentityEMPTYELEMENTCLOSING);
+								_ASSERTEQUAL(m_transform.m_itchOut, m_transform.m_itchInput);
+							}
+						}
+					}
+				private:
+					transform& m_transform;
+				};
+				return drop_closing_tag(*this);
+			}
+
+			void drop_element() & MAYTHROW {
+				_ASSERT(this->m_bConsumed);
+				_ASSERTANYOF(this->m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityOPENINGTAG));
+				OutputBeforeElement(); // MAYTHROW
+				this->skip_rest_of_element(); // MAYTHROW
+				m_itchOut = this->m_itchInput;
+			}
+			
+			// Methods inherited unchanged from tc::xml::parser
+			using base_::register_namespace;
+			using base_::namespace_for_prefix;
+			
+			tc::string<char_type> prefix_for_namespace(Namespace ons) const& noexcept {
+				if(ons) {
+					if(auto const opairstrns = tc::find_last_if<tc::return_element_or_null>(
+						this->m_stkpairstrns,
+						[&](auto const& pairstrns) noexcept {
+							return ons==pairstrns.second;
+						}
+					)) {
+						return opairstrns->first;
+					} else {
+						_ASSERTFALSE; // FIXME: Throw?
+						return tc::string<char_type>();
+					}
+				} else {
+					if(auto const opairstrns = tc::find_last_if<tc::return_element_or_null>(
+						this->m_stkpairstrns,
+						[&](auto const& pairstrns) noexcept {
+							return tc::empty(pairstrns.first)
+								&& pairstrns.second
+								&& this->c_nsStackSeparator!=pairstrns.second;
+						}
+					)) {
+						// Default namespace has been redefined
+						_ASSERTFALSE; // FIXME: Throw? 
+						return tc::string<char_type>();
+					} else {
+						return tc::string<char_type>();
+					}
+				}
+			}
+
+			using base_::semantic_error;
+
+			using base_::attribute;
+			using base_::attributes;
+			using base_::expect_attribute;
+
+			using base_::expanded_name;
+			using base_::qualified_tag_name;
+
+			using base_::child;
+			using base_::expect_child;
+
+			using base_::skip_child;
+			using base_::expect_skip_child;
+
+			// Output the injected close tag for an empty element when the empty element close tag is parsed
+			void skip_rest_of_element() & MAYTHROW { OutputEmptyElementCloseTag(); base_::skip_rest_of_element(); }
+			bool element_end() & MAYTHROW { OutputEmptyElementCloseTag(); return base_::element_end(); }
+			void expect_element_end() & MAYTHROW { OutputEmptyElementCloseTag(); base_::expect_element_end(); }
+
+		private:
+			Output& m_output;
+			static_assert(tc::appendable<tc::span<char_type const>, Output&>);
+			
+			decltype(tc::begin(*transform<String, ErrorHandler, Output>::m_strInput)) m_itchOut;
+			tc::string<char_type> m_strCloseTag;
+
+			auto OutputBeforeElement() & MAYTHROW {
+				auto itch = tc::begin(this->m_strMain); // MAYTHROW
+				switch_no_default(this->m_exmlentity) {
+					case exmlentityCLOSINGTAG: // </
+						--itch; // MAYTHROW
+						[[fallthrough]];
+					case exmlentityOPENINGTAG: // <
+					case exmlentityEMPTYELEMENT:
+					case exmlentityEMPTYELEMENTCLOSING:
+						--itch; // MAYTHROW
+				}
+				tc::append(m_output, tc::slice(*this->m_strInput, m_itchOut, itch)); // MAYTHROW
+				return itch;
+			}
+
+			void SplitEmptyElement() & MAYTHROW {
+				_ASSERTANYOF(this->m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityEMPTYELEMENTCLOSING));
+				if(tc::empty(m_strCloseTag)) {
+					m_itchOut = OutputBeforeElement(); // MAYTHROW
+					auto const str = tc::slice(*this->m_strInput, m_itchOut, this->m_itchInput);
+					tc::append(
+						m_output,
+						tc::ends_with<tc::return_take>(str, tc_ascii("/>")),
+						tc_ascii(">")
+					); // MAYTHROW
+					
+					tc::cont_assign(m_strCloseTag, this->qualified_tag_name());
+				} else {
+					_ASSERT(tc::equal(m_strCloseTag, this->qualified_tag_name()));
+				}
+			}
+
+			bool OutputEmptyElementCloseTag() & MAYTHROW {
+				if(!tc::empty(m_strCloseTag)) {
+					_ASSERTANYOF(this->m_exmlentity, (exmlentityEMPTYELEMENT)(exmlentityEMPTYELEMENTCLOSING));
+					tc::append(m_output, tc_ascii("</"), m_strCloseTag, tc_ascii(">")); // MAYTHROW
+					tc::cont_assign(m_strCloseTag);
+					return true;
+				} else {
+					return false;
+				}
+			}
+		};
+	}
+	using no_adl::transform;
+	
+	template<typename String, typename ErrorHandler, typename Output, typename... Args> requires tc::appendable<tc::span<tc::range_value_t<String>>, Output&>
+	[[nodiscard]] auto make_transform(String&& str, ErrorHandler&& errorhandler, Output& output, Args&&... args) MAYTHROW {
+		return no_adl::transform<String, tc::decay_t<ErrorHandler>, Output>(tc_move_if_owned(str), tc_move_if_owned(errorhandler), output, tc_move_if_owned(args)...); // MAYTHROW
+	}
+}
diff --git a/tc/tuple.h b/tc/tuple.h
index 65f1454..8c1fc21 100644
--- a/tc/tuple.h
+++ b/tc/tuple.h
@@ -10,7 +10,6 @@
 
 #include "base/invoke.h"
 #include "base/tc_move.h"
-#include "range/range_fwd.h"
 
 namespace tc {
 	// std::tuple from Microsofts STL is using a recursive implementation which is very slow.
@@ -87,7 +86,9 @@ namespace tc {
 			// We use std::remove_reference_t<Tuple>::tc_tuple_impl::size to restrict the argument Tuple&& to be tc::tuple in overloads found via adl.
 			static constexpr std::size_t size = sizeof...(T);
 
-			template<ENABLE_SFINAE, typename Src> requires (std::tuple_size<std::remove_cvref_t<Src>>::value == sizeof...(T))
+			template<ENABLE_SFINAE, typename Src> requires
+				(std::tuple_size<std::remove_cvref_t<Src>>::value == sizeof...(T)) &&
+				(!tc::derived_from<std::remove_reference_t<Src>, tc_tuple_impl>) // make sure default assignment operator wins in overload resolution. e.g. tc::tuple is a mutable member.
 			constexpr auto/*=void, returning tuple& may turn xvalue into lvalue*/ operator=(Src&& src) /*no &*/ return_decltype_MAYTHROW(
 				(void(tc::get<n>(*SFINAE_VALUE(this)) = tc::get<n>(std::forward<Src>(src))), ...) // assignment MAYTHROW
 			)
@@ -178,52 +179,6 @@ namespace tc {
 		);
 	}
 
-	namespace tuple_detail {
-		template<std::size_t I, tuple_like... Tuple>
-		constexpr auto zip_get(Tuple&&... tuple) noexcept {
-			// Tuple elements are tc::apply_cvref_t<std::tuple_element_t<I, std::remove_cvref_t<Tuple>>, Tuple>... unless tuple is tc::tuple and element types is empty.
-			return tc::tuple<std::conditional_t<
-				std::is_rvalue_reference<std::tuple_element_t<I, std::remove_cvref_t<Tuple>>>::value,
-				decltype(tc::get<I>(std::declval<Tuple>())),
-				tc::remove_rvalue_reference_t<decltype(tc::get<I>(std::declval<Tuple>()))>
-			>...>{{
-				{tc::get<I>(std::forward<Tuple>(tuple))}...
-			}};
-		}
-
-		template<std::size_t... I, tuple_like... Tuple>
-		constexpr auto zip_impl(std::index_sequence<I...>, Tuple&&... tuple) noexcept {
-			return tc::tuple<decltype(tuple_detail::zip_get<I>(std::forward<Tuple>(tuple)...))...>{{ // tc::make_tuple without extra copy
-				{tuple_detail::zip_get<I>(std::forward<Tuple>(tuple)...)}...
-			}};
-		}
-	}
-
-	template<tuple_like Tuple0, tuple_like... Tuple>
-		requires (!tc::range_with_iterators<Tuple0> || ... || !tc::range_with_iterators<Tuple>) // Prefer zip_adaptor for zip(std::array...)
-	[[nodiscard]] constexpr auto zip(Tuple0&& tuple0, Tuple&&... tuple) noexcept {
-		static_assert( ((std::tuple_size<std::remove_reference_t<Tuple0>>::value == std::tuple_size<std::remove_reference_t<Tuple>>::value) && ...) );
-		return tuple_detail::zip_impl(
-			std::make_index_sequence<std::tuple_size<std::remove_reference_t<Tuple0>>::value>(),
-			std::forward<Tuple0>(tuple0),
-			std::forward<Tuple>(tuple)...
-		);
-	}
-
-	template<typename TIndex, TIndex... Is>
-	[[nodiscard]] consteval tc::tuple<tc::constant<Is>...> index_sequence_as_tuple(std::integer_sequence<TIndex, Is...>) {
-		return {};
-	}
-
-	template<tuple_like Tuple> requires (!tc::range_with_iterators<Tuple>)
-	[[nodiscard]] constexpr auto enumerate(Tuple&& tuple) noexcept {
-		return tc::zip(
-			tc::index_sequence_as_tuple(std::make_integer_sequence<int, std::tuple_size<std::remove_reference_t<Tuple>>::value>()),
-			std::forward<Tuple>(tuple)
-		);
-	}
-
-
 	namespace tuple_detail {
 		template<std::size_t n, typename T>
 		T std_tuple_element_impl(tuple_member_adl::tuple_member<n, T> const&); // declaration only
diff --git a/tc/unittest.h b/tc/unittest.h
index af6d8b8..9fa8eb8 100644
--- a/tc/unittest.h
+++ b/tc/unittest.h
@@ -7,20 +7,10 @@
 // See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 
 #pragma once
+#include "array.h" // tc::single
 #include "container/container.h" // tc::vector
 
 namespace tc {
-
-	// this is for testing only, equivalent to slice(rng, begin(rng), end(rng)), but also works correctly on temporaries
-	template< typename Rng >
-	tc::make_subrange_result_t< Rng > slice(Rng&& rng) noexcept {
-		return tc::make_subrange_result_t< Rng >( std::forward<Rng>(rng), tc::begin(rng), tc::end(rng) );
-	}
-
-	// Do we want/need something like this as a generic tool?
-	template<typename Rng>
-	auto const_slice(Rng const& rng) return_decltype_noexcept(slice(rng)) 
-
 	// create a generator range that gives the same values as the rng it takes (for testing)
 	template<typename Rng> 
 	constexpr auto make_generator_range(Rng&& rng) noexcept {
@@ -104,7 +94,12 @@ namespace tc {
 
 			template<typename Elem>
 			break_or_continue operator()(Elem&& e) noexcept {
-				os << e << ", ";
+				if constexpr (requires (OStream& os, Elem& e) { os << e; }) {
+					os << e;
+				} else {
+					os << "???";
+				}
+				os << ", ";
 				--elems;
 				if( elems > 0 ) {
 					return continue_;
@@ -120,7 +115,7 @@ namespace tc {
 	}
 
 	template<typename Rng>
-	auto dbg_print_rng(Rng&& rng, std::size_t max_elems = 50) noexcept {
+	auto dbg_print_rng(Rng&& rng, std::size_t const max_elems = 50) noexcept {
 		std::stringstream os;
 		os << "[";
 		for_each(rng, std::ref(tc::as_lvalue(detail::print_elem<std::stringstream>(os, max_elems))) );
diff --git a/tc/variant.h b/tc/variant.h
index e0342a7..207fe0b 100644
--- a/tc/variant.h
+++ b/tc/variant.h
@@ -20,50 +20,24 @@
 /*
  Extensions to make std::variant easier to use
 
-
- std::get_if always takes a pointer to the variant.
- tc::get_if allows passing a reference or a pointer.
-```
-	std::variant<int, std::string> var = "Hello World";
-	_ASSERT(tc::get_if<0>(var)==nullptr);
-	_ASSERT(tc::get_if<0>(std::addressof(var))==nullptr);
-	_ASSERT(tc::equal(tc::get_if<1>(var), "Hello World"))
-	_ASSERT(tc::equal(tc::get_if<1>(std::addressof(var)), "Hello World"));
-```
+ std::get_if takes a pointer to the variant and returns a pointer.
+ tc::get_if takes a reference to the variant and returns tc::optional<TRef>.
 */
 
 namespace tc {
-	template<std::size_t I, typename Variant>
-	[[nodiscard]] constexpr auto get_if(Variant& v) noexcept -> tc::optional<std::variant_alternative_t<I, Variant>&> {
-		if(auto pval=std::get_if<I>(std::addressof(v))) {
-			return *pval;
-		} else {
-			return std::nullopt;
-		}
-	}
-
-	template<std::size_t I, typename Variant>
-	[[nodiscard]] constexpr auto get_if(Variant&& v) noexcept -> tc::optional<std::variant_alternative_t<I, Variant>&&> {
+	template<std::size_t I, typename Variant> requires (I < tc::type::size<typename tc::is_instance_or_derived<std::remove_reference_t<Variant>, std::variant>::arguments>::value)
+	[[nodiscard]] constexpr auto get_if(Variant&& v) noexcept -> tc::optional<tc::apply_cvref_t<std::variant_alternative_t<I, typename tc::is_instance_or_derived<std::remove_reference_t<Variant>, std::variant>::base_instance>, Variant&&>> {
 		if(auto pval=std::get_if<I>(std::addressof(v))) {
-			return std::move(*pval);
-		} else {
-			return std::nullopt;
-		}
-	}
-
-	template<typename T, typename Variant>
-	[[nodiscard]] constexpr auto get_if(Variant& v) noexcept -> tc::optional<std::conditional_t<std::is_const<Variant>::value, T const, T>&> {
-		if(auto pval=std::get_if<T>(std::addressof(v))) {
-			return *pval;
+			return tc::forward_like<Variant>(*pval);
 		} else {
 			return std::nullopt;
 		}
 	}
 
-	template<typename T, typename Variant>
-	[[nodiscard]] constexpr auto get_if(Variant&& v) noexcept -> tc::optional<std::conditional_t<std::is_const<Variant>::value, T const, T>&&> {
+	template<typename T, typename Variant> requires tc::type::find_unique<typename tc::is_instance_or_derived<std::remove_reference_t<Variant>, std::variant>::arguments, T>::found
+	[[nodiscard]] constexpr auto get_if(Variant&& v) noexcept -> tc::optional<tc::apply_cvref_t<T, Variant&&>> {
 		if(auto pval=std::get_if<T>(std::addressof(v))) {
-			return std::move(*pval);
+			return tc::forward_like<Variant>(*pval);
 		} else {
 			return std::nullopt;
 		}
@@ -83,12 +57,12 @@ namespace tc {
 ```
 */
 namespace tc_get_impl {
-	template<std::size_t I, tc::instance_or_derived<std::variant> Variant>
+	template<std::size_t I, typename Variant> requires (I < tc::type::size<typename tc::is_instance_or_derived<std::remove_reference_t<Variant>, std::variant>::arguments>::value)
 	[[nodiscard]] constexpr decltype(auto) get(Variant&& v) noexcept {
 		return tc::forward_like<Variant>(*VERIFYNORETURN(tc::get_if<I>(v)));
 	}
 
-	template<typename T, tc::instance_or_derived<std::variant> Variant>
+	template<typename T, typename Variant> requires tc::type::find_unique<typename tc::is_instance_or_derived<std::remove_reference_t<Variant>, std::variant>::arguments, T>::found
 	[[nodiscard]] constexpr decltype(auto) get(Variant&& v) noexcept {
 		return tc::forward_like<Variant>(*VERIFYNORETURN(tc::get_if<T>(v)));
 	}
@@ -113,7 +87,7 @@ namespace tc {
 			tc::type::transform_t<
 				tc::type::cartesian_product_t<
 					tc::type::transform_t<
-						typename tc::is_instance_or_derived<Variants, std::variant>::arguments,
+						typename tc::is_instance_or_derived<std::remove_reference_t<Variants>, std::variant>::arguments,
 						tc::type::rcurry<tc::same_cvref_t, Variants>::template type
 					>...
 				>,
@@ -123,7 +97,7 @@ namespace tc {
 
 
 		template<typename Result, typename Overload>
-		decltype(auto) projected_result(Overload&& overload) noexcept {
+		constexpr decltype(auto) projected_result(Overload&& overload) noexcept {
 			return [overload=std::forward<Overload>(overload)](auto&&... args) MAYTHROW -> Result {
 				return tc::invoke(overload, tc_move_if_owned(args)...);
 			};
@@ -179,8 +153,8 @@ namespace tc {
 		template<typename Overload>
 		struct [[nodiscard]] fn_visit_impl : private Overload {
 			using Overload::Overload;
-			template<typename... Variant>
-			detail::visit_result_t<Overload, Variant...> operator()(Variant&&... v) const& MAYTHROW {
+			template<typename... Variant> requires (... && tc::instance_or_derived<std::remove_reference_t<Variant>, std::variant>)
+			constexpr detail::visit_result_t<Overload, Variant...> operator()(Variant&&... v) const& MAYTHROW {
 				([&]() noexcept { _ASSERTNORETURN( !v.valueless_by_exception() ); tc::discard(v); }(), ...);
 				return
 #ifdef TC_MAC
@@ -190,9 +164,14 @@ namespace tc {
 #endif
 					(
 						detail::projected_result<detail::visit_result_t<Overload, Variant...>>(tc::base_cast<Overload>(*this)),
-						tc::base_cast<typename tc::is_instance_or_derived<Variant, std::variant>::base_instance>(std::forward<Variant>(v))...
+						std::forward<Variant>(v)...
 					);
 			}
+
+			template<typename... T> requires (... && (!tc::instance_or_derived<std::remove_reference_t<T>, std::variant>))
+			constexpr decltype(auto) operator()(T&&... t) const& MAYTHROW {
+				return tc::invoke(tc::base_cast<Overload>(*this), std::forward<T>(t)...);
+			}
 		};
 	}
 	template<typename... F>
@@ -211,6 +190,17 @@ namespace tc {
 	}
 	using no_adl::variant_type_index;
 
+	namespace explicit_convert_detail {
+		template<typename VarTarget, typename VarSourceNocvref, typename VarSource>
+		constexpr bool explicit_castable_between_variants_impl = false;
+
+		template<typename... TT, typename... TS, typename VarSource> requires (... && tc::explicit_castable_from<TT, tc::apply_cvref_t<TS, VarSource>>)
+		constexpr bool explicit_castable_between_variants_impl<std::variant<TT...>, std::variant<TS...>, VarSource> = true;
+
+		template<typename VarTarget, typename VarSource>
+		concept explicit_castable_between_variants=explicit_castable_between_variants_impl<VarTarget, typename tc::is_instance_or_derived<std::remove_reference_t<VarSource>, std::variant>::base_instance, VarSource>;
+	}
+
 	namespace explicit_convert_adl {
 		template<typename TVariant, std::size_t I, typename... Args, tc::explicit_castable_from<Args...> Alternative = std::variant_alternative_t<I, TVariant>>
 		constexpr TVariant explicit_convert_impl(adl_tag_t, tc::type::identity<TVariant>, std::in_place_index_t<I> tag, Args&&... args) noexcept(
@@ -227,25 +217,14 @@ namespace tc {
 			tc::explicit_cast<TVariant>(std::in_place_index_t<tc::variant_type_index<TVariant, T>::value>(), std::forward<Args>(args)...)
 		)
 
-		template<typename... TT, typename... TS> requires (sizeof...(TT) == sizeof...(TS))
-		std::variant<TT...> explicit_convert_impl(adl_tag_t, tc::type::identity<std::variant<TT...>>, std::variant<TS...> const& src) MAYTHROW {
-			using TTarget = std::variant<TT...>;
-			return tc::invoke_with_constant<std::make_index_sequence<sizeof...(TT)>>(
-				[&](auto nconstIndex) MAYTHROW -> TTarget {
-					tc_return_cast(std::in_place_index_t<nconstIndex()>(), tc::lazy_explicit_cast<std::variant_alternative_t<nconstIndex(), TTarget>>(tc::get<nconstIndex()>(src)));
-				},
-				src.index()
-			); // MAYTHROW
-		}
-
-		template<typename... TT, typename... TS> requires (sizeof...(TT) == sizeof...(TS))
-		std::variant<TT...> explicit_convert_impl(adl_tag_t, tc::type::identity<std::variant<TT...>>, std::variant<TS...>&& src) MAYTHROW {
+		template<typename... TT, typename Variant> requires	tc::explicit_convert_detail::explicit_castable_between_variants<std::variant<TT...>, Variant>
+		std::variant<TT...> explicit_convert_impl(adl_tag_t, tc::type::identity<std::variant<TT...>>, Variant&& var) MAYTHROW {
 			using TTarget = std::variant<TT...>;
 			return tc::invoke_with_constant<std::make_index_sequence<sizeof...(TT)>>(
-				[&](auto nconstIndex) MAYTHROW -> TTarget {
-					tc_return_cast(std::in_place_index_t<nconstIndex()>(), tc::lazy_explicit_cast<std::variant_alternative_t<nconstIndex(), TTarget>>(tc::get<nconstIndex()>(tc_move(src))));
+				[&](auto const nconstIndex) MAYTHROW -> TTarget {
+					return TTarget(std::in_place_index_t<nconstIndex()>(), tc::lazy_explicit_cast<std::variant_alternative_t<nconstIndex(), TTarget>>(tc::get<nconstIndex()>(tc_move_if_owned(var))));
 				},
-				src.index()
+				var.index()
 			); // MAYTHROW
 		}
 	}
@@ -333,5 +312,5 @@ static_assert( std::is_nothrow_move_constructible< std::variant<int, double, tc:
 	auto const f=[&](auto& _) MAYTHROW -> decltype(auto) { return (__VA_ARGS__); }; \
 	static_assert( !std::is_rvalue_reference<decltype(f(*o))>::value ); \
 	static_assert( !std::is_rvalue_reference<decltype((val))>::value ); \
-	return CONDITIONAL_PRVALUE_AS_VAL(o, f(*o), TC_FWD(val)); \
+	return tc_conditional_prvalue_as_val(o, f(*o), TC_FWD(val)); \
 }(tc::get_if<type>(var)))