STL: Finish replacing tag dispatch with `if constexpr`

[StephanTLavavej]

Tag dispatch is the STL's original metaprogramming technique: overload a helper function on a tag struct (e.g. input_iterator_tag versus forward_iterator_tag, or true_type versus false_type) and then call it with a tag object to select the appropriate overload. This has several downsides, though - it is somewhat verbose, it interferes with code organization, and it results in actual function calls in debug mode. (This is slower, more work to step through when debugging, and bloats object files.) C++17 if constexpr supersedes tag dispatch in almost every situation (see note below) and we're using it in new C++17-and-later code. We can use it in C++14 mode too (compilers support it unconditionally with a warning that we've suppressed).

We should finish overhauling the STL to use if constexpr.

Note: Tag dispatch works with delegating constructors, whereas if constexpr works only in function bodies. subrange's delegating constructors are a rare example of necessary tag dispatch:

STL/stl/inc/xutility

Lines 3345 to 3356 in f099e9c

	template <class _Rng>
	constexpr subrange(true_type, _Rng&& _Val)
	: subrange(_STD forward<_Rng>(_Val), static_cast<_Size_type>(_RANGES size(_Val))) {
	// delegation target for subrange(_Rng&&) when we must store the range size
	_STL_INTERNAL_STATIC_ASSERT(_Store_size);
	}
	template <class _Rng>
	constexpr subrange(false_type, _Rng&& _Val) : subrange(_RANGES begin(_Val), _RANGES end(_Val)) {
	// delegation target for subrange(_Rng&&) when we need not store the range size
	_STL_INTERNAL_STATIC_ASSERT(!_Store_size);
	}

[StephanTLavavej]

In #491, I noticed that C++17 default_searcher is using tag dispatch when it could use if constexpr:

STL/stl/inc/functional

Lines 1662 to 1664 in ff94756

	const auto _Result =
	_Search_pair_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Get_unwrapped(_Pat.first),
	_Get_unwrapped(_Pat.second), _Eq, _Iter_cat_t<_FwdItHaystack>{}, _Iter_cat_t<_FwdItPat>{});

[CaseyCarter]

#1433 brought _Lex_compare_memcmp_classify to our attention:

STL/stl/inc/xutility

Lines 5303 to 5319 in 60d9ed7

	template <class _InIt1, class _InIt2, class _Pr>
	constexpr auto _Lex_compare_memcmp_classify(const _InIt1&, const _InIt2&, const _Pr&) {
	// return lex_compare optimization category for arbitrary iterators
	return _Lex_compare_optimize<void>{};
	}
	template <class _Obj1, class _Obj2, class _FTy>
	constexpr auto _Lex_compare_memcmp_classify(_Obj1* const&, _Obj2* const&, const less<_FTy>&) {
	// return lex_compare optimization category for pointer iterators and less<_FTy>
	return _Lex_compare_check_element_types<less<int>, _Obj1, _Obj2, _FTy>{};
	}
	template <class _Obj1, class _Obj2, class _FTy>
	constexpr auto _Lex_compare_memcmp_classify(_Obj1* const&, _Obj2* const&, const greater<_FTy>&) {
	// return lex_compare optimization category for pointer iterators and greater<_FTy>
	return _Lex_compare_check_element_types<greater<int>, _Obj1, _Obj2, _FTy>{};
	}

This overload set could be if constexpr-ed to good effect, doubly so after #1433 adds more overloads to the set.

[AlexGuteniev]

I don't think it deserves separate issue, rather an expansion of this issue scope.

Some specializations can be replaced with if constexpr.

Compare internal _Invoke_ret dispached by SFINAE-selected partial specialization:

STL/stl/inc/functional

Lines 658 to 685 in 8833270

	// helper to give INVOKE an explicit return type; avoids undesirable Expression SFINAE
	template <class _Rx, bool = is_void_v<_Rx>>
	struct _Invoker_ret { // selected for _Rx being cv void
	template <class _Fx, class... _Valtys>
	static _CONSTEXPR20 void _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(_Select_invoke_traits<_Fx,
	_Valtys...>::_Is_nothrow_invocable::value) { // INVOKE, "implicitly" converted to void
	_STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
	}
	};
	template <class _Rx>
	struct _Invoker_ret<_Rx, false> { // selected for all _Rx other than cv void and _Unforced
	template <class _Fx, class... _Valtys>
	static _CONSTEXPR20 _Rx _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(_Select_invoke_traits<_Fx,
	_Valtys...>::template _Is_nothrow_invocable_r<_Rx>::value) { // INVOKE, implicitly converted to _Rx
	return _STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
	}
	};
	template <>
	struct _Invoker_ret<_Unforced, false> { // selected for _Rx being _Unforced
	template <class _Fx, class... _Valtys>
	static _CONSTEXPR20 auto _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(
	_Select_invoke_traits<_Fx, _Valtys...>::_Is_nothrow_invocable::value)
	-> decltype(_STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...)) { // INVOKE, unchanged
	return _STD invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
	}
	};

And standard invoke_r dispatched by if constexpr:

STL/stl/inc/functional

Lines 33 to 42 in 8833270

	template <class _Result_type, class _Callable, class... _Types,
	enable_if_t<is_invocable_r_v<_Result_type, _Callable, _Types...>, int> = 0>
	_NODISCARD constexpr _Result_type invoke_r(_Callable&& _Obj, _Types&&... _Args) noexcept(
	is_nothrow_invocable_r_v<_Result_type, _Callable, _Types...>) {
	if constexpr (is_void_v<_Result_type>) {
	(void) _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
	} else {
	return _STD invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
	}
	}