functional_adapters.hpp File Reference

#include <helios/core_pch.hpp>
#include <algorithm>
#include <concepts>
#include <cstddef>
#include <iterator>
#include <optional>
#include <ranges>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes
struct	helios::utils::details::is_folder_applicable_impl< Folder, Accumulator, Tuple >
	Helper to extract tuple element types and check if a folder is invocable with accumulator + tuple elements. More...
struct	helios::utils::details::is_folder_applicable_impl< Folder, Accumulator, std::tuple< TupleArgs... > >
struct	helios::utils::details::folder_apply_result< Folder, Accumulator, std::tuple< TupleArgs... > >
class	helios::utils::FilterAdapter< Iter, Pred >
class	helios::utils::MapAdapter< Iter, Func >
class	helios::utils::TakeAdapter< Iter >
class	helios::utils::SkipAdapter< Iter >
class	helios::utils::TakeWhileAdapter< Iter, Pred >
class	helios::utils::SkipWhileAdapter< Iter, Pred >
class	helios::utils::EnumerateAdapter< Iter >
class	helios::utils::InspectAdapter< Iter, Func >
class	helios::utils::StepByAdapter< Iter >
class	helios::utils::ChainAdapter< Iter1, Iter2 >
class	helios::utils::ReverseAdapter< Iter >
class	helios::utils::SlideView< Iter >
class	helios::utils::SlideAdapter< Iter >
class	helios::utils::StrideAdapter< Iter >
class	helios::utils::ZipAdapter< Iter1, Iter2 >
class	helios::utils::ConcatAdapter< Iter >
class	helios::utils::FunctionalAdapterBase< Derived >
	CRTP base class providing common adapter operations. More...

Namespaces
namespace	helios
namespace	helios::utils
namespace	helios::utils::details

Concepts
concept	helios::utils::details::TupleLike
	Concept to check if a type is tuple-like (has tuple_size and get).
concept	helios::utils::details::CallableOrApplicable
concept	helios::utils::details::CallableOrApplicableWithReturn
concept	helios::utils::IteratorLike
	Concept for types that can be used as base iterators in adapters.
concept	helios::utils::BidirectionalIteratorLike
	Concept for bidirectional iterators that support decrement operations.
concept	helios::utils::PredicateFor
	Concept for predicate functions that can be applied to iterator values.
concept	helios::utils::TransformFor
	Concept for transformation functions that can be applied to iterator values.
concept	helios::utils::InspectorFor
	Concept for inspection functions that observe but don't modify values.
concept	helios::utils::ActionFor
	Concept for action functions that process values.
concept	helios::utils::FolderFor
	Concept for folder functions that accumulate values.
concept	helios::utils::FilterAdapterRequirements
	Concept to validate FilterAdapter requirements.
concept	helios::utils::MapAdapterRequirements
	Concept to validate MapAdapter requirements.
concept	helios::utils::TakeAdapterRequirements
	Concept to validate TakeAdapter requirements.
concept	helios::utils::SkipAdapterRequirements
	Concept to validate SkipAdapter requirements.
concept	helios::utils::TakeWhileAdapterRequirements
	Concept to validate TakeWhileAdapter requirements.
concept	helios::utils::SkipWhileAdapterRequirements
	Concept to validate SkipWhileAdapter requirements.
concept	helios::utils::EnumerateAdapterRequirements
	Concept to validate EnumerateAdapter requirements.
concept	helios::utils::InspectAdapterRequirements
	Concept to validate InspectAdapter requirements.
concept	helios::utils::StepByAdapterRequirements
	Concept to validate StepByAdapter requirements.
concept	helios::utils::ChainAdapterRequirements
	Concept to validate ChainAdapter requirements.
concept	helios::utils::ReverseAdapterRequirements
	Concept to validate ReverseAdapter requirements.
concept	helios::utils::JoinAdapterRequirements
	Concept to validate JoinAdapter requirements.
concept	helios::utils::SlideAdapterRequirements
	Concept to validate SlideAdapter requirements.
concept	helios::utils::ConcatAdapterRequirements
	Concept to validate ConcatAdapter requirements.
concept	helios::utils::StrideAdapterRequirements
	Concept to validate StrideAdapter requirements.
concept	helios::utils::ZipAdapterRequirements
	Concept to validate ZipAdapter requirements.

Typedefs
template<typename Folder , typename Accumulator , typename Tuple >
using	helios::utils::details::folder_apply_result_t = typename folder_apply_result< Folder, Accumulator, Tuple >::type
template<typename Func , typename... Args>
using	helios::utils::details::call_or_apply_result_t = typename decltype(get_call_or_apply_result_type< Func, Args... >())::type

Functions
template<typename Func , typename... Args>
consteval auto	helios::utils::details::get_call_or_apply_result_type () noexcept
	Helper to get the result type of either invoke or apply.
template<std::ranges::range R, typename Pred > requires FilterAdapterRequirements<std::ranges::iterator_t<R>, Pred>
constexpr auto	helios::utils::FilterAdapterFromRange (R &range, Pred predicate) noexcept(noexcept(FilterAdapter< std::ranges::iterator_t< R >, Pred >(std::ranges::begin(range), std::ranges::end(range), std::move(predicate)))) -> FilterAdapter< std::ranges::iterator_t< R >, Pred >
	Helper function to create a FilterAdapter from a non-const range.
template<std::ranges::range R, typename Pred > requires FilterAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>
constexpr auto	helios::utils::FilterAdapterFromRange (const R &range, Pred predicate) noexcept(noexcept(FilterAdapter< decltype(std::ranges::cbegin(range)), Pred >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)))) -> FilterAdapter< decltype(std::ranges::cbegin(range)), Pred >
	Helper function to create a FilterAdapter from a const range.
template<std::ranges::range R, typename Func > requires MapAdapterRequirements<std::ranges::iterator_t<R>, Func>
constexpr auto	helios::utils::MapAdapterFromRange (R &range, Func transform) noexcept(noexcept(MapAdapter< std::ranges::iterator_t< R >, Func >(std::ranges::begin(range), std::ranges::end(range), std::move(transform)))) -> MapAdapter< std::ranges::iterator_t< R >, Func >
	Helper function to create a MapAdapter from a range.
template<std::ranges::range R, typename Func > requires MapAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>
constexpr auto	helios::utils::MapAdapterFromRange (const R &range, Func transform) noexcept(noexcept(MapAdapter< decltype(std::ranges::cbegin(range)), Func >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(transform)))) -> MapAdapter< decltype(std::ranges::cbegin(range)), Func >
	Helper function to create a MapAdapter from a const range.
template<std::ranges::range R> requires TakeAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::TakeAdapterFromRange (R &range, size_t count) noexcept(noexcept(TakeAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), count))) -> TakeAdapter< std::ranges::iterator_t< R > >
	Helper function to create a TakeAdapter from a non-const range.
template<std::ranges::range R> requires TakeAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::TakeAdapterFromRange (const R &range, size_t count) noexcept(noexcept(TakeAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), count))) -> TakeAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a TakeAdapter from a const range.
template<std::ranges::range R> requires SkipAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::SkipAdapterFromRange (R &range, size_t count) noexcept(noexcept(SkipAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), count))) -> SkipAdapter< std::ranges::iterator_t< R > >
	Helper function to create a SkipAdapter from a non-const range.
template<std::ranges::range R> requires SkipAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::SkipAdapterFromRange (const R &range, size_t count) noexcept(noexcept(SkipAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), count))) -> SkipAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a SkipAdapter from a const range.
template<std::ranges::range R, typename Pred > requires TakeWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>
constexpr auto	helios::utils::TakeWhileAdapterFromRange (R &range, Pred predicate) noexcept(noexcept(TakeWhileAdapter< std::ranges::iterator_t< R >, Pred >(std::ranges::begin(range), std::ranges::end(range), std::move(predicate)))) -> TakeWhileAdapter< std::ranges::iterator_t< R >, Pred >
	Helper function to create a TakeWhileAdapter from a non-const range.
template<std::ranges::range R, typename Pred > requires TakeWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>
constexpr auto	helios::utils::TakeWhileAdapterFromRange (const R &range, Pred predicate) noexcept(noexcept(TakeWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)))) -> TakeWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >
	Helper function to create a TakeWhileAdapter from a const range.
template<std::ranges::range R, typename Pred > requires SkipWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>
constexpr auto	helios::utils::SkipWhileAdapterFromRange (R &range, Pred predicate) noexcept(noexcept(SkipWhileAdapter< std::ranges::iterator_t< R >, Pred >(std::ranges::begin(range), std::ranges::end(range), std::move(predicate)))) -> SkipWhileAdapter< std::ranges::iterator_t< R >, Pred >
	Helper function to create a SkipWhileAdapter from a non-const range.
template<std::ranges::range R, typename Pred > requires SkipWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>
constexpr auto	helios::utils::SkipWhileAdapterFromRange (const R &range, Pred predicate) noexcept(noexcept(SkipWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)))) -> SkipWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >
	Helper function to create a SkipWhileAdapter from a const range.
template<std::ranges::range R> requires EnumerateAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::EnumerateAdapterFromRange (R &range) noexcept(noexcept(EnumerateAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range)))) -> EnumerateAdapter< std::ranges::iterator_t< R > >
	Helper function to create an EnumerateAdapter from a non-const range.
template<std::ranges::range R> requires EnumerateAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::EnumerateAdapterFromRange (const R &range) noexcept(noexcept(EnumerateAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range)))) -> EnumerateAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create an EnumerateAdapter from a const range.
template<std::ranges::range R, typename Func > requires InspectAdapterRequirements<std::ranges::iterator_t<R>, Func>
constexpr auto	helios::utils::InspectAdapterFromRange (R &range, Func inspector) noexcept(noexcept(InspectAdapter< std::ranges::iterator_t< R >, Func >(std::ranges::begin(range), std::ranges::end(range), std::move(inspector)))) -> InspectAdapter< std::ranges::iterator_t< R >, Func >
	Helper function to create an InspectAdapter from a non-const range.
template<std::ranges::range R, typename Func > requires InspectAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>
constexpr auto	helios::utils::InspectAdapterFromRange (const R &range, Func inspector) noexcept(noexcept(InspectAdapter< decltype(std::ranges::cbegin(range)), Func >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(inspector)))) -> InspectAdapter< decltype(std::ranges::cbegin(range)), Func >
	Helper function to create an InspectAdapter from a const range.
template<std::ranges::range R> requires StepByAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::StepByAdapterFromRange (R &range, size_t step) noexcept(noexcept(StepByAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), step))) -> StepByAdapter< std::ranges::iterator_t< R > >
	Helper function to create a StepByAdapter from a non-const range.
template<std::ranges::range R> requires StepByAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::StepByAdapterFromRange (const R &range, size_t step) noexcept(noexcept(StepByAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), step))) -> StepByAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a StepByAdapter from a const range.
template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>
constexpr auto	helios::utils::ChainAdapterFromRange (R1 &range1, R2 &range2) noexcept(noexcept(ChainAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ChainAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >
	Helper function to create a ChainAdapter from two non-const ranges.
template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	helios::utils::ChainAdapterFromRange (R1 &range1, const R2 &range2) noexcept(noexcept(ChainAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ChainAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>
	Helper function to create a ChainAdapter from non-const and const ranges.
template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), std::ranges::iterator_t<R2>>
constexpr auto	helios::utils::ChainAdapterFromRange (const R1 &range1, R2 &range2) noexcept(noexcept(ChainAdapter< decltype(std::ranges::cbegin(range1)), std::ranges::iterator_t< R2 > >(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ChainAdapter< decltype(std::ranges::cbegin(range1)), std::ranges::iterator_t< R2 > >
	Helper function to create a ChainAdapter from const and non-const ranges.
template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	helios::utils::ChainAdapterFromRange (const R1 &range1, const R2 &range2) noexcept(noexcept(ChainAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ChainAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>
	Helper function to create a ChainAdapter from two const ranges.
template<std::ranges::range R> requires ReverseAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::ReverseAdapterFromRange (R &range) noexcept(noexcept(ReverseAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range)))) -> ReverseAdapter< std::ranges::iterator_t< R > >
	Helper function to create a ReverseAdapter from a range.
template<std::ranges::range R> requires ReverseAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::ReverseAdapterFromRange (const R &range) noexcept(noexcept(ReverseAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range)))) -> ReverseAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a ReverseAdapter from a const range.
template<std::ranges::range R> requires JoinAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::JoinAdapterFromRange (R &range) noexcept(noexcept(JoinAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range)))) -> JoinAdapter< std::ranges::iterator_t< R > >
	Helper function to create a JoinAdapter from a range.
template<std::ranges::range R> requires JoinAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::JoinAdapterFromRange (const R &range) noexcept(noexcept(JoinAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range)))) -> JoinAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a JoinAdapter from a const range.
template<std::ranges::range R> requires SlideAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::SlideAdapterFromRange (R &range, size_t window_size) noexcept(noexcept(SlideAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), window_size))) -> SlideAdapter< std::ranges::iterator_t< R > >
	Helper function to create a SlideAdapter from a range.
template<std::ranges::range R> requires SlideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::SlideAdapterFromRange (const R &range, size_t window_size) noexcept(noexcept(SlideAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), window_size))) -> SlideAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a SlideAdapter from a const range.
template<std::ranges::range R> requires StrideAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::StrideAdapterFromRange (R &range, size_t stride) noexcept(noexcept(StrideAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), stride))) -> StrideAdapter< std::ranges::iterator_t< R > >
	Helper function to create a StrideAdapter from a range.
template<std::ranges::range R> requires StrideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::StrideAdapterFromRange (const R &range, size_t stride) noexcept(noexcept(StrideAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), stride))) -> StrideAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a StrideAdapter from a const range.
template<std::ranges::range R1, std::ranges::range R2> requires ZipAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>
constexpr auto	helios::utils::ZipAdapterFromRange (R1 &range1, R2 &range2) noexcept(noexcept(ZipAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ZipAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >
	Helper function to create a ZipAdapter from two ranges.
template<std::ranges::range R1, std::ranges::range R2> requires ZipAdapterRequirements<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	helios::utils::ZipAdapterFromRange (R1 &range1, const R2 &range2) noexcept(noexcept(ZipAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ZipAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>
	Helper function to create a ZipAdapter from a range and a const range.
template<std::ranges::range R1, std::ranges::range R2> requires ZipAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	helios::utils::ZipAdapterFromRange (const R1 &range1, const R2 &range2) noexcept(noexcept(ZipAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ZipAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>
	Helper function to create a ZipAdapter from two const ranges.
template<std::ranges::range R> requires ConcatAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	helios::utils::ConcatAdapterFromRange (R &range1, R &range2) noexcept(noexcept(ConcatAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ConcatAdapter< std::ranges::iterator_t< R > >
template<std::ranges::range R> requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::ConcatAdapterFromRange (const R &range1, const R &range2) noexcept(noexcept(ConcatAdapter< decltype(std::ranges::cbegin(range1))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ConcatAdapter< decltype(std::ranges::cbegin(range1))>
template<std::ranges::range R> requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::ConcatAdapterFromRange (R &range1, const R &range2) noexcept(noexcept(ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>
	Helper function to create a ConcatAdapter from a non-const and const range of the same type.
template<std::ranges::range R> requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	helios::utils::ConcatAdapterFromRange (const R &range1, R &range2) noexcept(noexcept(ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>
	Helper function to create a ConcatAdapter from a const and non-const range of the same type.

Variables
template<typename Folder , typename Accumulator , typename Tuple >
constexpr bool	helios::utils::details::is_folder_applicable_v = is_folder_applicable_impl<Folder, Accumulator, Tuple>::value