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

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 >

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::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<typename OutIt >
constexpr void	helios::utils::Into (OutIt out) const

constexpr Derived &	helios::utils::GetDerived () noexcept
	Gets reference to derived class instance.

template<std::ranges::range R, typename Pred > requires FilterAdapterRequirements<std::ranges::iterator_t<R>, Pred>
constexpr auto	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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	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.

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

Function Documentation

◆ ChainAdapterFromRange() [1/4]

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 ChainAdapterFromRange	(	const R1 &	range1,
		const R2 &	range2
	)		-> ChainAdapter<decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ChainAdapter from two const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

Definition at line 3234 of file functional_adapters.hpp.

                                                                                          {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2),
          std::ranges::cend(range2)};
}

◆ ChainAdapterFromRange() [2/4]

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 ChainAdapterFromRange	(	const R1 &	range1,
		R2 &	range2
	)		-> ChainAdapter<decltype(std::ranges::cbegin(range1)), std::ranges::iterator_t<R2>>

constexprnoexcept

Helper function to create a ChainAdapter from const and non-const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

Definition at line 3216 of file functional_adapters.hpp.

                                                                                {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::begin(range2), std::ranges::end(range2)};
}

◆ ChainAdapterFromRange() [3/4]

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 ChainAdapterFromRange	(	R1 &	range1,
		const R2 &	range2
	)		-> ChainAdapter<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ChainAdapter from non-const and const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

Definition at line 3198 of file functional_adapters.hpp.

                                                                                {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)};
}

◆ ChainAdapterFromRange() [4/4]

template<std::ranges::range R1, std::ranges::range R2>
requires ChainAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexpr auto ChainAdapterFromRange	(	R1 &	range1,
		R2 &	range2
	)		-> ChainAdapter<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexprnoexcept

Helper function to create a ChainAdapter from two non-const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3180 of file functional_adapters.hpp.

                                                                      {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)};
}

◆ EnumerateAdapterFromRange() [1/2]

template<std::ranges::range R>
requires EnumerateAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto EnumerateAdapterFromRange ( const R & range ) -> EnumerateAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create an EnumerateAdapter from a const range.

Template Parameters

R	Range type

Parameters

range Range to enumerate

Returns: EnumerateAdapter for the range

Definition at line 3100 of file functional_adapters.hpp.

                                                          {
  return {std::ranges::cbegin(range), std::ranges::cend(range)};
}

◆ EnumerateAdapterFromRange() [2/2]

template<std::ranges::range R>
requires EnumerateAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto EnumerateAdapterFromRange ( R & range ) -> EnumerateAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create an EnumerateAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range Range to enumerate

Returns: EnumerateAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3086 of file functional_adapters.hpp.

                                                {
  return {std::ranges::begin(range), std::ranges::end(range)};
}

◆ FilterAdapterFromRange() [1/2]

template<std::ranges::range R, typename Pred >
requires FilterAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>

constexpr auto FilterAdapterFromRange	(	const R &	range,
		Pred	predicate
	)		-> FilterAdapter<decltype(std::ranges::cbegin(range)), Pred>

constexprnoexcept

Helper function to create a FilterAdapter from a const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to filter
predicate	Function to filter elements

Returns: FilterAdapter for the range

Definition at line 2909 of file functional_adapters.hpp.

                                                             {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)};
}

◆ FilterAdapterFromRange() [2/2]

template<std::ranges::range R, typename Pred >
requires FilterAdapterRequirements<std::ranges::iterator_t<R>, Pred>

constexpr auto FilterAdapterFromRange	(	R &	range,
		Pred	predicate
	)		-> FilterAdapter<std::ranges::iterator_t<R>, Pred>

constexprnoexcept

Helper function to create a FilterAdapter from a non-const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to filter
predicate	Function to filter elements

Returns: FilterAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2892 of file functional_adapters.hpp.

                                                   {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(predicate)};
}

◆ InspectAdapterFromRange() [1/2]

template<std::ranges::range R, typename Func >
requires InspectAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>

constexpr auto InspectAdapterFromRange	(	const R &	range,
		Func	inspector
	)		-> InspectAdapter<decltype(std::ranges::cbegin(range)), Func>

constexprnoexcept

Helper function to create an InspectAdapter from a const range.

Template Parameters

R	Range type
Func	Inspector function type

Parameters

range	Range to inspect
inspector	Function to call for each element

Returns: InspectAdapter for the range

Definition at line 3133 of file functional_adapters.hpp.

                                                              {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(inspector)};
}

◆ InspectAdapterFromRange() [2/2]

template<std::ranges::range R, typename Func >
requires InspectAdapterRequirements<std::ranges::iterator_t<R>, Func>

constexpr auto InspectAdapterFromRange	(	R &	range,
		Func	inspector
	)		-> InspectAdapter<std::ranges::iterator_t<R>, Func>

constexprnoexcept

Helper function to create an InspectAdapter from a non-const range.

Template Parameters

R	Range type
Func	Inspector function type

Parameters

range	Range to inspect
inspector	Function to call on each element

Returns: InspectAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3116 of file functional_adapters.hpp.

                                                    {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(inspector)};
}

◆ JoinAdapterFromRange() [1/2]

template<std::ranges::range R>
requires JoinAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto JoinAdapterFromRange ( const R & range ) -> JoinAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a JoinAdapter from a const range.

Template Parameters

R	Range type

Parameters

range Range to join

Returns: JoinAdapter for the range

Definition at line 3293 of file functional_adapters.hpp.

                                                     {
  return {std::ranges::cbegin(range), std::ranges::cend(range)};
}

◆ JoinAdapterFromRange() [2/2]

template<std::ranges::range R>
requires JoinAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto JoinAdapterFromRange ( R & range ) -> JoinAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a JoinAdapter from a range.

Template Parameters

R	Range type

Parameters

range Range to join

Returns: JoinAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3279 of file functional_adapters.hpp.

                                           {
  return {std::ranges::begin(range), std::ranges::end(range)};
}

◆ MapAdapterFromRange() [1/2]

template<std::ranges::range R, typename Func >
requires MapAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>

constexpr auto MapAdapterFromRange	(	const R &	range,
		Func	transform
	)		-> MapAdapter<decltype(std::ranges::cbegin(range)), Func>

constexprnoexcept

Helper function to create a MapAdapter from a const range.

Template Parameters

R	Range type
Func	Transformation function type

Parameters

range	Range to map
transform	Function to apply to each element

Returns: MapAdapter for the range

Definition at line 2943 of file functional_adapters.hpp.

                                                          {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(transform)};
}

◆ MapAdapterFromRange() [2/2]

template<std::ranges::range R, typename Func >
requires MapAdapterRequirements<std::ranges::iterator_t<R>, Func>

constexpr auto MapAdapterFromRange	(	R &	range,
		Func	transform
	)		-> MapAdapter<std::ranges::iterator_t<R>, Func>

constexprnoexcept

Helper function to create a MapAdapter from a range.

Template Parameters

R	Range type
Func	Transformation function type

Parameters

range	Range to map
transform	Function to apply to each element

Returns: MapAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2926 of file functional_adapters.hpp.

                                                {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(transform)};
}

◆ ReverseAdapterFromRange() [1/2]

template<std::ranges::range R>
requires ReverseAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto ReverseAdapterFromRange ( const R & range ) -> ReverseAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a ReverseAdapter from a const range.

Template Parameters

R	Range type

Parameters

range Range to reverse

Returns: ReverseAdapter for the range

Definition at line 3265 of file functional_adapters.hpp.

                                                        {
  return {std::ranges::cbegin(range), std::ranges::cend(range)};
}

◆ ReverseAdapterFromRange() [2/2]

template<std::ranges::range R>
requires ReverseAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto ReverseAdapterFromRange ( R & range ) -> ReverseAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a ReverseAdapter from a range.

Template Parameters

R	Range type

Parameters

range Range to reverse

Returns: ReverseAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3251 of file functional_adapters.hpp.

                                              {
  return {std::ranges::begin(range), std::ranges::end(range)};
}

◆ SkipAdapterFromRange() [1/2]

template<std::ranges::range R>
requires SkipAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto SkipAdapterFromRange	(	const R &	range,
		size_t	count
	)		-> SkipAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a SkipAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to skip from
count	Number of elements to skip

Returns: SkipAdapter for the range

Definition at line 3004 of file functional_adapters.hpp.

                                                     {
  return {std::ranges::cbegin(range), std::ranges::cend(range), count};
}

◆ SkipAdapterFromRange() [2/2]

template<std::ranges::range R>
requires SkipAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto SkipAdapterFromRange	(	R &	range,
		size_t	count
	)		-> SkipAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a SkipAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range	Range to skip from
count	Number of elements to skip

Returns: SkipAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2989 of file functional_adapters.hpp.

                                           {
  return {std::ranges::begin(range), std::ranges::end(range), count};
}

◆ SkipWhileAdapterFromRange() [1/2]

template<std::ranges::range R, typename Pred >
requires SkipWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>

constexpr auto SkipWhileAdapterFromRange	(	const R &	range,
		Pred	predicate
	)		-> SkipWhileAdapter<decltype(std::ranges::cbegin(range)), Pred>

constexprnoexcept

Helper function to create a SkipWhileAdapter from a const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to skip from
predicate	Predicate to test elements

Returns: SkipWhileAdapter for the range

Definition at line 3071 of file functional_adapters.hpp.

                                                                {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)};
}

◆ SkipWhileAdapterFromRange() [2/2]

template<std::ranges::range R, typename Pred >
requires SkipWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>

constexpr auto SkipWhileAdapterFromRange	(	R &	range,
		Pred	predicate
	)		-> SkipWhileAdapter<std::ranges::iterator_t<R>, Pred>

constexprnoexcept

Helper function to create a SkipWhileAdapter from a non-const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to skip from
predicate	Predicate to test elements

Returns: SkipWhileAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3054 of file functional_adapters.hpp.

                                                      {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(predicate)};
}

◆ SlideAdapterFromRange() [1/2]

template<std::ranges::range R>
requires SlideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto SlideAdapterFromRange	(	const R &	range,
		size_t	window_size
	)		-> SlideAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a SlideAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to slide over
window_size	Size of the sliding window

Returns: SlideAdapter for the range

Definition at line 3323 of file functional_adapters.hpp.

                                                      {
  return {std::ranges::cbegin(range), std::ranges::cend(range), window_size};
}

◆ SlideAdapterFromRange() [2/2]

template<std::ranges::range R>
requires SlideAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto SlideAdapterFromRange	(	R &	range,
		size_t	window_size
	)		-> SlideAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a SlideAdapter from a range.

Template Parameters

R	Range type

Parameters

range	Range to slide over
window_size	Size of the sliding window

Returns: SlideAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3308 of file functional_adapters.hpp.

                                            {
  return {std::ranges::begin(range), std::ranges::end(range), window_size};
}

◆ StepByAdapterFromRange() [1/2]

template<std::ranges::range R>
requires StepByAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto StepByAdapterFromRange	(	const R &	range,
		size_t	step
	)		-> StepByAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a StepByAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to step through
step	Number of elements to step by

Returns: StepByAdapter for the range

Definition at line 3164 of file functional_adapters.hpp.

                                                       {
  return {std::ranges::cbegin(range), std::ranges::cend(range), step};
}

◆ StepByAdapterFromRange() [2/2]

template<std::ranges::range R>
requires StepByAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto StepByAdapterFromRange	(	R &	range,
		size_t	step
	)		-> StepByAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a StepByAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range	Range to step through
step	Step size

Returns: StepByAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3149 of file functional_adapters.hpp.

                                             {
  return {std::ranges::begin(range), std::ranges::end(range), step};
}

◆ StrideAdapterFromRange() [1/2]

template<std::ranges::range R>
requires StrideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto StrideAdapterFromRange	(	const R &	range,
		size_t	stride
	)		-> StrideAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a StrideAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to stride over
stride	Stride value

Returns: StrideAdapter for the range

Definition at line 3354 of file functional_adapters.hpp.

                                                       {
  return {std::ranges::cbegin(range), std::ranges::cend(range), stride};
}

◆ StrideAdapterFromRange() [2/2]

template<std::ranges::range R>
requires StrideAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto StrideAdapterFromRange	(	R &	range,
		size_t	stride
	)		-> StrideAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a StrideAdapter from a range.

Template Parameters

R	Range type

Parameters

range	Range to stride over
stride	Stride value

Returns: StrideAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3339 of file functional_adapters.hpp.

                                             {
  return {std::ranges::begin(range), std::ranges::end(range), stride};
}

◆ TakeAdapterFromRange() [1/2]

template<std::ranges::range R>
requires TakeAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto TakeAdapterFromRange	(	const R &	range,
		size_t	count
	)		-> TakeAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a TakeAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to take from
count	Maximum number of elements to yield

Returns: TakeAdapter for the range

Definition at line 2974 of file functional_adapters.hpp.

                                                     {
  return {std::ranges::cbegin(range), std::ranges::cend(range), count};
}

◆ TakeAdapterFromRange() [2/2]

template<std::ranges::range R>
requires TakeAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto TakeAdapterFromRange	(	R &	range,
		size_t	count
	)		-> TakeAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a TakeAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range	Range to take from
count	Maximum number of elements to yield

Returns: TakeAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 2959 of file functional_adapters.hpp.

                                           {
  return {std::ranges::begin(range), std::ranges::end(range), count};
}

◆ TakeWhileAdapterFromRange() [1/2]

template<std::ranges::range R, typename Pred >
requires TakeWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>

constexpr auto TakeWhileAdapterFromRange	(	const R &	range,
		Pred	predicate
	)		-> TakeWhileAdapter<decltype(std::ranges::cbegin(range)), Pred>

constexprnoexcept

Helper function to create a TakeWhileAdapter from a const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to take from
predicate	Predicate to test elements

Returns: TakeWhileAdapter for the range

Definition at line 3037 of file functional_adapters.hpp.

                                                                {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)};
}

◆ TakeWhileAdapterFromRange() [2/2]

template<std::ranges::range R, typename Pred >
requires TakeWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>

constexpr auto TakeWhileAdapterFromRange	(	R &	range,
		Pred	predicate
	)		-> TakeWhileAdapter<std::ranges::iterator_t<R>, Pred>

constexprnoexcept

Helper function to create a TakeWhileAdapter from a non-const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to take from
predicate	Predicate to test elements

Returns: TakeWhileAdapter for the range

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3020 of file functional_adapters.hpp.

                                                      {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(predicate)};
}

◆ ZipAdapterFromRange() [1/3]

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 ZipAdapterFromRange	(	const R1 &	range1,
		const R2 &	range2
	)		-> ZipAdapter<decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ZipAdapter from two const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ZipAdapter for the two ranges

Definition at line 3405 of file functional_adapters.hpp.

                                                                                        {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2),
          std::ranges::cend(range2)};
}

◆ ZipAdapterFromRange() [2/3]

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 ZipAdapterFromRange	(	R1 &	range1,
		const R2 &	range2
	)		-> ZipAdapter<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ZipAdapter from a range and a const range.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ZipAdapter for the two ranges

Definition at line 3387 of file functional_adapters.hpp.

                                                                              {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)};
}

◆ ZipAdapterFromRange() [3/3]

template<std::ranges::range R1, std::ranges::range R2>
requires ZipAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexpr auto ZipAdapterFromRange	(	R1 &	range1,
		R2 &	range2
	)		-> ZipAdapter<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexprnoexcept

Helper function to create a ZipAdapter from two ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ZipAdapter for the two ranges

Examples: /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/utils/functional_adapters.hpp.

Definition at line 3370 of file functional_adapters.hpp.

                                                                    {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)};
}

	Helios Engine 0.1.0 A modular ECS based data-oriented C++23 game engine

Classes

Namespaces

Concepts

Typedefs

Functions

Variables

Function Documentation

◆ ChainAdapterFromRange() [1/4]

◆ ChainAdapterFromRange() [2/4]

◆ ChainAdapterFromRange() [3/4]

◆ ChainAdapterFromRange() [4/4]

◆ EnumerateAdapterFromRange() [1/2]

◆ EnumerateAdapterFromRange() [2/2]

◆ FilterAdapterFromRange() [1/2]

◆ FilterAdapterFromRange() [2/2]

◆ InspectAdapterFromRange() [1/2]

◆ InspectAdapterFromRange() [2/2]

◆ JoinAdapterFromRange() [1/2]

◆ JoinAdapterFromRange() [2/2]

◆ MapAdapterFromRange() [1/2]

◆ MapAdapterFromRange() [2/2]

◆ ReverseAdapterFromRange() [1/2]

◆ ReverseAdapterFromRange() [2/2]

◆ SkipAdapterFromRange() [1/2]

◆ SkipAdapterFromRange() [2/2]

◆ SkipWhileAdapterFromRange() [1/2]

◆ SkipWhileAdapterFromRange() [2/2]

◆ SlideAdapterFromRange() [1/2]

◆ SlideAdapterFromRange() [2/2]

◆ StepByAdapterFromRange() [1/2]

◆ StepByAdapterFromRange() [2/2]

◆ StrideAdapterFromRange() [1/2]

◆ StrideAdapterFromRange() [2/2]

◆ TakeAdapterFromRange() [1/2]

◆ TakeAdapterFromRange() [2/2]

◆ TakeWhileAdapterFromRange() [1/2]

◆ TakeWhileAdapterFromRange() [2/2]

◆ ZipAdapterFromRange() [1/3]

◆ ZipAdapterFromRange() [2/3]

◆ ZipAdapterFromRange() [3/3]