Rework decltype(lambda) appearances (#150)

Author: DNKpp

include/mimic++/matchers/Common.hpp

@@ -102,16 +102,21 @@ namespace mimicpp::detail::describe_hook
 
     inline constexpr util::priority_tag<1> maxTag{};
 
-    template <typename Matcher>
-    [[nodiscard]]
-    constexpr auto describe(Matcher const& matcher)
-        -> decltype(describe_impl(maxTag, matcher))
-        requires requires {
-            { describe_impl(maxTag, matcher) } -> util::explicitly_convertible_to<std::optional<StringT>>;
-        }
+    struct describe_fn
     {
-        return describe_impl(maxTag, matcher);
-    }
+        template <typename Matcher>
+        [[nodiscard]]
+        constexpr auto operator()(Matcher const& matcher) const
+            -> decltype(describe_impl(maxTag, matcher))
+            requires requires {
+                { describe_impl(maxTag, matcher) } -> util::explicitly_convertible_to<std::optional<StringT>>;
+            }
+        {
+            return describe_impl(maxTag, matcher);
+        }
+    };
+
+    inline constexpr describe_fn describe{};
 }
 
 namespace mimicpp

include/mimic++/matchers/RangeMatchers.hpp

@@ -179,21 +179,23 @@ MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::matches::range
     [[nodiscard]]
     constexpr auto each_element(Matcher&& matcher)
     {
-        using MatcherT = std::remove_cvref_t<Matcher>;
+        using MatcherType = std::remove_cvref_t<Matcher>;
+        using arg_storage = mimicpp::detail::arg_storage<
+            MatcherType,
+            std::identity,
+            mimicpp::detail::describe_hook::describe_fn>;
+
         return PredicateMatcher{
-            [](std::ranges::range auto&& target, const MatcherT& m) {
+            []<std::ranges::range Range>(Range&& target, MatcherType const& m) {
                 return std::ranges::all_of(
-                    target,
-                    [&](const auto& element) { return m.matches(element); });
+                    std::forward<Range>(target),
+                    [&](auto&& element) {
+                        return mimicpp::detail::matches_hook::matches(m, element);
+                    });
             },
             "each el in range: el {}",
             "not each el in range: el {}",
-            std::make_tuple(
-                mimicpp::detail::arg_storage<
-                    MatcherT,
-                    std::identity,
-                    decltype([](const auto& m) { return mimicpp::detail::describe_hook::describe(m); })>{
-                    std::forward<MatcherT>(matcher)})};
+            std::tuple<arg_storage>{std::forward<Matcher>(matcher)}};
     }
 
     /**
@@ -204,21 +206,23 @@ MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::matches::range
     [[nodiscard]]
     constexpr auto any_element(Matcher&& matcher)
     {
-        using MatcherT = std::remove_cvref_t<Matcher>;
+        using MatcherType = std::remove_cvref_t<Matcher>;
+        using arg_storage = mimicpp::detail::arg_storage<
+            MatcherType,
+            std::identity,
+            mimicpp::detail::describe_hook::describe_fn>;
+
         return PredicateMatcher{
-            [](std::ranges::range auto&& target, const MatcherT& m) {
+            []<std::ranges::range Range>(Range&& target, MatcherType const& m) {
                 return std::ranges::any_of(
-                    target,
-                    [&](const auto& element) { return m.matches(element); });
+                    std::forward<Range>(target),
+                    [&](auto&& element) {
+                        return mimicpp::detail::matches_hook::matches(m, element);
+                    });
             },
             "any el in range: el {}",
             "none el in range: el {}",
-            std::make_tuple(
-                mimicpp::detail::arg_storage<
-                    MatcherT,
-                    std::identity,
-                    decltype([](const auto& m) { return mimicpp::detail::describe_hook::describe(m); })>{
-                    std::forward<MatcherT>(matcher)})};
+            std::tuple<arg_storage>{std::forward<Matcher>(matcher)}};
     }
 
     /**

include/mimic++/printing/type/PrintType.hpp

@@ -96,15 +96,25 @@ MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::printing::type
 
 namespace mimicpp::printing::type
 {
+    namespace detail
+    {
+        struct free_deleter
+        {
+            void operator()(char* const c) const noexcept
+            {
+                std::free(c);
+            }
+        };
+    }
+
     template <typename T>
     StringT type_name()
     {
         auto* const rawName = typeid(T).name();
 
         // see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_demangling.html
         int status{};
-        using free_deleter_t = decltype([](char* c) noexcept { std::free(c); });
-        std::unique_ptr<char, free_deleter_t> const demangledName{
+        std::unique_ptr<char, detail::free_deleter> const demangledName{
             abi::__cxa_demangle(rawName, nullptr, nullptr, &status)};
         if (0 == status)
         {

include/mimic++/printing/type/Templated.hpp

@@ -199,35 +199,35 @@ namespace mimicpp::printing::type::detail
     {
     };
 
-    // used for array, span and the like
-    // should also handle c++26s inplace_vector
-    // see: https://en.cppreference.com/w/cpp/container/inplace_vector
     template <template <typename, auto...> typename Template, typename T, auto n>
-    struct template_type_printer<Template<T, n>>
-        : public basic_template_type_printer<
-              decltype([]<print_iterator OutIter>(OutIter out) {
-                  out = pretty_template_name<Template<T, n>>(std::move(out));
-                  out = format::format_to(std::move(out), "<");
-                  out = mimicpp::print_type<T>(std::move(out));
-                  out = format::format_to(std::move(out), ", {}>", n);
-
-                  return out;
-              })>
+    struct array_like_name_generator
     {
+        template <print_iterator OutIter>
+        constexpr OutIter operator()(OutIter out) const
+        {
+            out = pretty_template_name<Template<T, n>>(std::move(out));
+            out = format::format_to(std::move(out), "<");
+            out = mimicpp::print_type<T>(std::move(out));
+
+            if constexpr (constexpr bool isDefaultSize = requires { requires std::same_as<Template<T>, Template<T, n>>; };
+                          !isDefaultSize)
+            {
+                out = format::format_to(std::move(out), ", {}", n);
+            }
+
+            out = format::format_to(std::move(out), ">");
+
+            return out;
+        }
     };
 
+    // used for array, span and the like
+    // should also handle c++26s inplace_vector
+    // see: https://en.cppreference.com/w/cpp/container/inplace_vector
     template <template <typename, auto...> typename Template, typename T, auto n>
-        requires std::same_as<Template<T>, Template<T, n>>
     struct template_type_printer<Template<T, n>>
         : public basic_template_type_printer<
-              decltype([]<print_iterator OutIter>(OutIter out) {
-                  out = pretty_template_name<Template<T, n>>(std::move(out));
-                  out = format::format_to(std::move(out), "<");
-                  out = mimicpp::print_type<T>(std::move(out));
-                  out = format::format_to(std::move(out), ">");
-
-                  return out;
-              })>
+              array_like_name_generator<Template, T, n>>
     {
     };