Remove source pointer support from cache, cleaup aliases

Author: gracicot

include/kangaru/detail/cache.hpp

@@ -6,7 +6,7 @@
 #include "ctti.hpp"
 #include "concepts.hpp"
 #include "cache_types.hpp"
-#include "source_helper.hpp"
+#include "source_rebind.hpp"
 
 #include <type_traits>
 #include <concepts>
@@ -36,7 +36,7 @@ namespace kangaru {
 		using cache_type = Cache;
 
 	private:
-		using unwrapped_cache_type = maybe_wrapped_t<cache_type>;
+		using unwrapped_cache_type = std::remove_reference_t<maybe_unwrap_result_t<cache_type>>;
 
 	public:
 		explicit constexpr with_cache_asymmetric(source_type source) noexcept
@@ -134,8 +134,8 @@ namespace kangaru {
 		}
 
 		template<forwarded<with_cache_asymmetric> Original, forwarded_source NewLeaf>
-		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_cache_asymmetric<rebind_wrapped_source_result_t<Original, NewLeaf>, source_ref_t<Cache>, CacheFrom> {
-			return with_cache_asymmetric<rebind_wrapped_source_result_t<Original, NewLeaf>, source_ref_t<Cache>, CacheFrom>{
+		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_cache_asymmetric<wrapped_source_rebind_result_t<Original, NewLeaf>, ref_result_t<Cache>, CacheFrom> {
+			return with_cache_asymmetric<wrapped_source_rebind_result_t<Original, NewLeaf>, ref_result_t<Cache>, CacheFrom>{
 				kangaru::rebind(KANGARU5_FWD(original).source, KANGARU5_FWD(new_leaf)),
 				KANGARU5_NO_ADL(ref)(original.cache)
 			};
@@ -207,9 +207,9 @@ namespace kangaru {
 
 		template<forwarded<with_cache> Original, forwarded_source NewLeaf>
 		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept
-			-> with_cache<rebind_wrapped_source_result_t<detail::utility::forward_like_t<Original, parent_t>, NewLeaf>, source_ref_t<Cache>>
+			-> with_cache<wrapped_source_rebind_result_t<detail::utility::forward_like_t<Original, parent_t>, NewLeaf>, ref_result_t<Cache>>
 		{
-			return with_cache<rebind_wrapped_source_result_t<detail::utility::forward_like_t<Original, parent_t>, NewLeaf>, source_ref_t<Cache>>{
+			return with_cache<wrapped_source_rebind_result_t<detail::utility::forward_like_t<Original, parent_t>, NewLeaf>, ref_result_t<Cache>>{
 				parent_t::rebind(static_cast<detail::utility::forward_like_t<Original, parent_t>&&>(original), KANGARU5_FWD(new_leaf))
 			};
 		}
@@ -236,9 +236,11 @@ namespace kangaru {
 	static_assert(cache_map<with_cache<none_source, source_reference_wrapper<with_cache<none_source>>>>);
 
 	template<template<unqualified_object> typename SourceType>
-	struct cached_pointer_to_source {
+	struct cached_reference_to_source {
 		template<injectable T>
-		using source = SourceType<std::remove_cvref_t<T>>*;
+		struct ttype {
+			using type = SourceType<std::remove_cvref_t<T>>&;
+		};
 	};
 
 	template<source Source, template<typename> typename SourceFor>
@@ -251,12 +253,7 @@ namespace kangaru {
 			)
 		constexpr KANGARU5_PROVIDE_FUNCTION_DECL(Self&& source) -> T {
 			decltype(auto) source_for_t = kangaru::provide<SourceFor<T>>(KANGARU5_FWD(source).source);
-			// TODO: Can we avoid this pointer thing?
-			if constexpr (std::is_pointer_v<decltype(source_for_t)>) {
-				return kangaru::provide<T>(*KANGARU5_FWD(source_for_t));
-			} else {
-				return kangaru::provide<T>(KANGARU5_FWD(source_for_t));
-			}
+			return kangaru::provide<T>(KANGARU5_FWD(source_for_t));
 		}
 
 		Source source;

include/kangaru/detail/concepts.hpp

@@ -16,6 +16,9 @@ namespace kangaru {
 	template<typename T>
 	concept object = std::is_object_v<T>;
 
+	template<typename T>
+	concept forwarded_object = object<std::remove_reference_t<T>>;
+	
 	template<typename T>
 	concept unqualified_object = object<T> and not std::is_const_v<T> and not std::is_volatile_v<T>;
 

include/kangaru/detail/container.hpp

@@ -14,8 +14,8 @@
 
 namespace kangaru {
 	template<injectable T>
-	using cached_pointer_to_injectable_reference_source =
-		typename cached_pointer_to_source<injectable_reference_source>::template source<T>;
+	using cached_reference_to_injectable_reference_source =
+		detail::utility::ttype_t<cached_reference_to_source<injectable_reference_source>, T>;
 
 	template<
 		rebindable_source Source,
@@ -53,11 +53,13 @@ namespace kangaru {
 				make_source_with_exhaustive_construction(
 					with_alternative{
 						with_recursion{
-							make_source_with_cache_using_source<cached_pointer_to_injectable_reference_source>(
-								KANGARU5_NO_ADL(fwd_ref)(KANGARU5_FWD(source))
+							make_source_with_cache_using_source<cached_reference_to_injectable_reference_source>(
+								with_dereference{
+									KANGARU5_NO_ADL(fwd_ref)(KANGARU5_FWD(source))
+								}
 							)
 						},
-						external_reference_source{self}
+						KANGARU5_NO_ADL(concat)(external_reference_source{self}, KANGARU5_NO_ADL(fwd_ref)(KANGARU5_FWD(source)))
 					}
 				)
 			};

include/kangaru/detail/heap_storage.hpp

@@ -4,7 +4,7 @@
 #include "source_types.hpp"
 #include "source.hpp"
 #include "allocator.hpp"
-#include "source_helper.hpp"
+#include "source_rebind.hpp"
 
 #include <concepts>
 #include <vector>
@@ -185,8 +185,8 @@ namespace kangaru {
 		}
 
 		template<forwarded<with_heap_storage> Original, forwarded_source NewSource>
-		static constexpr auto rebind(Original&& original, NewSource&& new_leaf) noexcept -> with_heap_storage<rebind_wrapped_source_result_t<Original, NewSource>, source_ref_t<Storage>> {
-			return with_heap_storage<rebind_wrapped_source_result_t<Original, NewSource>, source_ref_t<Storage>>{
+		static constexpr auto rebind(Original&& original, NewSource&& new_leaf) noexcept -> with_heap_storage<wrapped_source_rebind_result_t<Original, NewSource>, ref_result_t<Storage>> {
+			return with_heap_storage<wrapped_source_rebind_result_t<Original, NewSource>, ref_result_t<Storage>>{
 				kangaru::rebind(KANGARU5_FWD(original).source, new_leaf),
 				KANGARU5_NO_ADL(ref)(original.storage)
 			};

include/kangaru/detail/recursive_source.hpp

@@ -8,7 +8,7 @@
 #include "source.hpp"
 #include "source_types.hpp"
 #include "source_reference_wrapper.hpp"
-#include "source_helper.hpp"
+#include "source_rebind.hpp"
 
 #include <type_traits>
 #include <cstdlib>
@@ -206,7 +206,7 @@ namespace kangaru {
 	template<source Source, construction Construction>
 	struct with_construction {
 	private:
-		using construction_type = maybe_wrapped_t<Construction>;
+		using construction_type = std::remove_reference_t<maybe_unwrap_result_t<Construction>>;
 
 	public:
 		explicit constexpr with_construction(Source source) noexcept
@@ -236,8 +236,8 @@ namespace kangaru {
 		}
 
 		template<forwarded<with_construction> Original, forwarded_source NewLeaf>
-		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_construction<rebind_wrapped_source_result_t<Original, NewLeaf>, Construction> {
-			return with_construction<rebind_wrapped_source_result_t<Original, NewLeaf>, Construction>{
+		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_construction<wrapped_source_rebind_result_t<Original, NewLeaf>, Construction> {
+			return with_construction<wrapped_source_rebind_result_t<Original, NewLeaf>, Construction>{
 				kangaru::rebind(KANGARU5_FWD(original).source, KANGARU5_FWD(new_leaf)),
 				original.construction
 			};
@@ -322,17 +322,17 @@ namespace kangaru {
 			// also yield false if it would result in infinite recursion
 			// Yes, this requires expression will yield different result depending on the metastate of the compiler!
 			detail::recursive_source::source_of_sfinae_wrapper<
-				rebind_wrapped_source_result_t<
+				wrapped_source_rebind_result_t<
 					Self&,
-					detail::recursive_source::leaf_as_alternative<with_recursion<source_ref_t<wrapped_source_t<Self>>>>
+					detail::recursive_source::leaf_as_alternative<with_recursion<ref_result_t<wrapped_source_t<Self>>>>
 				>,
 				T
 			>::value
 		) {
 			return kangaru::provide<T>(
 				kangaru::rebind(
 					source,
-					detail::recursive_source::leaf_as_alternative<with_recursion<source_ref_t<wrapped_source_t<Self>>>>{
+					detail::recursive_source::leaf_as_alternative<with_recursion<ref_result_t<wrapped_source_t<Self>>>>{
 						KANGARU5_NO_ADL(ref)(source.source)
 					}
 				)

include/kangaru/detail/source_helper.hpp include/kangaru/detail/source_rebind.hppinclude/kangaru/detail/source_helper.hpp renamed to include/kangaru/detail/source_rebind.hpp

@@ -1,5 +1,5 @@
-#ifndef KANGARU5_DETAIL_SOURCE_HELPER_HPP
-#define KANGARU5_DETAIL_SOURCE_HELPER_HPP
+#ifndef KANGARU5_DETAIL_SOURCE_REBIND_HPP
+#define KANGARU5_DETAIL_SOURCE_REBIND_HPP
 
 #include "source.hpp"
 #include "source_reference_wrapper.hpp"
@@ -11,7 +11,7 @@
 #include "define.hpp"
 
 namespace kangaru {
-	namespace detail::source_helper {
+	namespace detail::source_rebind {
 		template<wrapping_source>
 		struct rebind_wrapper {};
 
@@ -46,14 +46,15 @@ namespace kangaru {
 				using type = Branch<NewSource, Param>;
 			};
 		};
-	} // namespace detail::source_helper
+	} // namespace detail::source_rebind
 
 	template<typename Source>
 	concept transparent_rebindable_wrapping_source =
 		    wrapping_source<Source>
 		and requires(Source source) {
 			// Here we need to used ttype_t instead of directly using ::ttype<...>::type because GCC 12 has issues with it.
-			typename detail::utility::ttype_t<detail::source_helper::rebind_wrapper<std::remove_cv_t<Source>>,
+			typename detail::utility::ttype_t<
+				detail::source_rebind::rebind_wrapper<std::remove_cv_t<Source>>,
 				std::decay_t<decltype(source.source)>
 			>;
 		};
@@ -70,16 +71,17 @@ namespace kangaru {
 		   transparent_rebindable_wrapping_source<Source>
 		or stateful_rebindable_wrapping_source<Source>;
 
-	namespace detail::source_helper {
+	namespace detail::source_rebind {
 		struct rebind_function {
 			template<forwarded_source Wrapper> requires (rebindable_wrapping_source<std::remove_reference_t<Wrapper>> and not forwarded_reference_wrapper<Wrapper>)
-			constexpr auto operator()(Wrapper&& source, forwarded_source auto&& new_leaf) const noexcept {
+			constexpr auto operator()(Wrapper&& source, forwarded_object auto&& new_leaf) const noexcept {
 				if constexpr (stateful_rebindable_wrapping_source<std::remove_reference_t<Wrapper>>) {
 					return std::decay_t<Wrapper>::rebind(source, new_leaf);
 				} else if constexpr (transparent_rebindable_wrapping_source<std::remove_reference_t<Wrapper>>) {
-					using rebound = typename detail::source_helper::rebind_wrapper<std::remove_cvref_t<Wrapper>>::template ttype<
+					using rebound = typename detail::utility::ttype_t<
+						detail::source_rebind::rebind_wrapper<std::remove_cvref_t<Wrapper>>,
 						decltype(operator()(source.source, KANGARU5_FWD(new_leaf)))
-					>::type;
+					>;
 					return rebound{
 						operator()(source.source, KANGARU5_FWD(new_leaf))
 					};
@@ -89,9 +91,7 @@ namespace kangaru {
 			}
 
 			template<forwarded_reference_wrapper Wrapper>
-			constexpr auto operator()(Wrapper&& wrapper, forwarded_source auto&& new_leaf) const noexcept {
-				// TODO: Do we need to use forwarding refs for wrappers?
-				// TODO: Do we need to unwrap references at all? Does it even make sense?
+			constexpr auto operator()(Wrapper&& wrapper, forwarded_object auto&& new_leaf) const noexcept {
 				decltype(auto) unwrapped = KANGARU5_FWD(wrapper).unwrap();
 				return operator()(KANGARU5_FWD(unwrapped), KANGARU5_FWD(new_leaf));
 			}
@@ -101,7 +101,7 @@ namespace kangaru {
 				and not rebindable_wrapping_source<std::remove_reference_t<Leaf>>
 				and not forwarded_wrapping_source<Leaf>
 			)
-			constexpr auto operator()(Leaf&& leaf, forwarded_source auto&& new_leaf) const noexcept {
+			constexpr auto operator()(Leaf&& leaf, forwarded_object auto&& new_leaf) const noexcept {
 				// We do not forward new_leaf here, since it may be called multiple times
 				return new_leaf(KANGARU5_FWD(leaf));
 			}
@@ -120,24 +120,24 @@ namespace kangaru {
 		inline constexpr auto is_rebindable_v<Leaf> = true;
 
 		namespace niebloid {
-			inline constexpr auto rebind = detail::source_helper::rebind_function{};
+			inline constexpr auto rebind = detail::source_rebind::rebind_function{};
 		}
-	} // namespace detail::source_helper
+	} // namespace detail::source_rebind
 
 	inline namespace niebloid {
-		using namespace detail::source_helper::niebloid;
+		using namespace detail::source_rebind::niebloid;
 	}
 
 	template<typename Source>
-	concept rebindable_source = source<Source> and detail::source_helper::is_rebindable_v<Source>;
+	concept rebindable_source = source<Source> and detail::source_rebind::is_rebindable_v<Source>;
 
 	template<source Source, forwarded_source Leaf>
 	using rebind_result_t = decltype(kangaru::rebind(std::declval<Source>(), std::declval<Leaf>()));
 
 	template<forwarded_wrapping_source Source, forwarded_source Leaf>
-	using rebind_wrapped_source_result_t = decltype(kangaru::rebind(std::declval<forwarded_wrapped_source_t<Source>>(), std::declval<Leaf>()));
+	using wrapped_source_rebind_result_t = decltype(kangaru::rebind(std::declval<forwarded_wrapped_source_t<Source>>(), std::declval<Leaf>()));
 } // namespace kangaru
 
 #include "undef.hpp"
 
-#endif
+#endif // KANGARU5_DETAIL_SOURCE_REBIND_HPP

include/kangaru/detail/source_reference_wrapper.hpp

@@ -9,7 +9,12 @@
 #include "define.hpp"
 
 namespace kangaru {
-	template<object Source> requires source<std::remove_const_t<Source>>
+	template<typename T>
+	concept reference_wrapper = source<T> and requires(T ref) {
+		{ ref.unwrap() } -> reference;
+	};
+	
+	template<object Source> requires (source<std::remove_const_t<Source>> and not reference_wrapper<std::remove_const_t<Source>>)
 	struct source_reference_wrapper {
 		explicit constexpr source_reference_wrapper(Source& source) noexcept : source{std::addressof(source)} {}
 
@@ -28,7 +33,7 @@ namespace kangaru {
 		Source* source;
 	};
 
-	template<source_ref Source>
+	template<source_ref Source> requires (not reference_wrapper<std::remove_cvref_t<Source>>)
 	struct source_forwarding_reference_wrapper {
 		explicit constexpr source_forwarding_reference_wrapper(Source source) noexcept : source{std::addressof(source)} {}
 
@@ -61,14 +66,12 @@ namespace kangaru {
 	template<forwarded_source Source>
 	source_forwarding_reference_wrapper(Source&&) -> source_forwarding_reference_wrapper<Source&&>;
 
-	template<typename T>
-	concept reference_wrapper = source<T> and requires(T ref) {
-		{ ref.unwrap() } -> reference;
-	};
-	
 	template<typename T>
 	concept forwarded_reference_wrapper = reference_wrapper<std::remove_reference_t<T>>;
 
+	template<reference_wrapper Wrapper>
+	using source_reference_wrapped_type = std::remove_reference_t<decltype(std::declval<Wrapper>().unwrap())>;
+	
 	inline constexpr auto maybe_unwrap(forwarded_reference_wrapper auto&& ref) noexcept -> decltype(auto) {
 		return KANGARU5_FWD(ref).unwrap();
 	}
@@ -77,14 +80,8 @@ namespace kangaru {
 		return KANGARU5_FWD(any);
 	}
 
-	template<reference_wrapper Wrapper>
-	using source_reference_wrapped_type = std::remove_reference_t<decltype(std::declval<Wrapper>().unwrap())>;
-	
-	template<typename MaybeWrapper>
-	using maybe_wrapped_t = std::remove_reference_t<decltype(KANGARU5_NO_ADL(maybe_unwrap)(std::declval<MaybeWrapper>()))>;
-	
 	template<typename MaybeWrapper>
-	using forwarded_maybe_wrapped_t = decltype(KANGARU5_NO_ADL(maybe_unwrap)(std::declval<MaybeWrapper>()));
+	using maybe_unwrap_result_t = decltype(KANGARU5_NO_ADL(maybe_unwrap)(std::declval<MaybeWrapper>()));
 
 	template<source Source> requires (not reference_wrapper<std::remove_cvref_t<Source>>)
 	inline constexpr auto ref(Source& source) -> source_reference_wrapper<Source> {
@@ -96,6 +93,11 @@ namespace kangaru {
 		return source;
 	}
 
+	template<source_ref Source> requires (not reference_wrapper<std::remove_cvref_t<Source>>)
+	inline constexpr auto ref(source_forwarding_reference_wrapper<Source> source) -> source_reference_wrapper<std::remove_reference_t<Source>> {
+		return source_reference_wrapper<std::remove_reference_t<Source>>{source.unwrap()};
+	}
+	
 	template<forwarded_source Source> requires (not forwarded_reference_wrapper<Source>)
 	inline constexpr auto fwd_ref(Source&& source) -> source_forwarding_reference_wrapper<Source&&> {
 		return source_forwarding_reference_wrapper<Source&&>{KANGARU5_FWD(source)};
@@ -106,11 +108,16 @@ namespace kangaru {
 		return source;
 	}
 
+	template<forwarded_source Source> requires (not reference_wrapper<std::remove_cvref_t<Source>>)
+	inline constexpr auto fwd_ref(source_reference_wrapper<Source> source) -> source_forwarding_reference_wrapper<Source&> {
+		return source_forwarding_reference_wrapper<Source&>{source.unwrap()};
+	}
+	
 	template<source Source>
-	using source_ref_t = decltype(KANGARU5_NO_ADL(ref)(std::declval<Source&>()));
+	using ref_result_t = decltype(KANGARU5_NO_ADL(ref)(std::declval<Source&>()));
 
 	template<source_ref Source>
-	using source_fwd_ref_t = decltype(KANGARU5_NO_ADL(fwd_ref)(std::declval<Source>()));
+	using fwd_ref_result_t = decltype(KANGARU5_NO_ADL(fwd_ref)(std::declval<Source>()));
 } // namespace kangaru
 
 #include "undef.hpp"

include/kangaru/detail/source_types.hpp

@@ -8,7 +8,7 @@
 #include "constructor.hpp"
 #include "source_reference_wrapper.hpp"
 #include "tag.hpp"
-#include "source_helper.hpp"
+#include "source_rebind.hpp"
 
 #include <tuple>
 #include <concepts>
@@ -256,8 +256,8 @@ namespace kangaru {
 		}
 
 		template<forwarded<with_alternative> Original, forwarded_source NewLeaf>
-		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_alternative<rebind_wrapped_source_result_t<Original, NewLeaf>, source_fwd_ref_t<detail::utility::forward_like_t<Original, Alternative>>> {
-			return with_alternative<rebind_wrapped_source_result_t<Original, NewLeaf>, source_fwd_ref_t<detail::utility::forward_like_t<Original, Alternative>>>{
+		static constexpr auto rebind(Original&& original, NewLeaf&& new_leaf) noexcept -> with_alternative<wrapped_source_rebind_result_t<Original, NewLeaf>, fwd_ref_result_t<detail::utility::forward_like_t<Original, Alternative>>> {
+			return with_alternative<wrapped_source_rebind_result_t<Original, NewLeaf>, fwd_ref_result_t<detail::utility::forward_like_t<Original, Alternative>>>{
 				kangaru::rebind(KANGARU5_FWD(original).source, KANGARU5_FWD(new_leaf)),
 				KANGARU5_NO_ADL(fwd_ref)(maybe_unwrap(KANGARU5_FWD(original).alternative))
 			};