c0nstexpr
diff --git a/‎include/stdsharp/functional/always_return.h
Lines changed: 24 additions & 9 deletions b/‎include/stdsharp/functional/always_return.h
Lines changed: 24 additions & 9 deletions
diff --git a/‎include/stdsharp/functional/sequenced_invocables.h
Lines changed: 6 additions & 3 deletions b/‎include/stdsharp/functional/sequenced_invocables.h
Lines changed: 6 additions & 3 deletions
diff --git a/‎include/stdsharp/type_traits/indexed_traits.h
Lines changed: 2 additions & 6 deletions b/‎include/stdsharp/type_traits/indexed_traits.h
Lines changed: 2 additions & 6 deletions
diff --git a/‎include/stdsharp/type_traits/object.h
Lines changed: 2 additions & 1 deletion b/‎include/stdsharp/type_traits/object.h
Lines changed: 2 additions & 1 deletion
diff --git a/‎include/stdsharp/type_traits/regular_value_sequence.h
Lines changed: 1 addition & 1 deletion b/‎include/stdsharp/type_traits/regular_value_sequence.h
Lines changed: 1 addition & 1 deletion
@@ -8,23 +8,38 @@ namespace stdsharp
 {
     inline constexpr struct always_return_fn
     {
-        constexpr decltype(auto) operator()(auto&& v, const auto&... /*unused*/) const noexcept
+        [[nodiscard]] constexpr decltype(auto
+        ) operator()(auto&& v, const auto&... /*unused*/) const noexcept
         {
             return cpp_forward(v);
         }
     } always_return{};
 
-    inline constexpr auto always_true = std::bind_front(always_return, true);
-
-    using always_true_fn = decltype(always_true);
-
-    inline constexpr auto always_false = std::bind_front(always_return, false);
+    inline constexpr struct always_true_fn
+    {
+        [[nodiscard]] constexpr bool operator()(const auto&... /*unused*/) const noexcept
+        {
+            return true;
+        }
+    } always_true{};
 
-    using always_false_fn = decltype(always_false);
+    inline constexpr struct always_false_fn
+    {
+        [[nodiscard]] constexpr bool operator()(const auto&... /*unused*/) const noexcept
+        {
+            return false;
+        }
+    } always_false{};
 
     template<typename T>
-    inline constexpr auto always_default = std::bind_front(always_return, T{});
+    struct always_default_fn
+    {
+        [[nodiscard]] constexpr auto operator()(const auto&... /*unused*/) const noexcept
+        {
+            return T{};
+        }
+    };
 
     template<typename T>
-    using always_default_fn = decltype(always_default<T>);
+    inline constexpr always_default_fn<T> always_default{};
 }
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "../type_traits/indexed_traits.h"
+#include "invoke.h"
 
 #include <tuple>
 
@@ -22,7 +23,7 @@ namespace stdsharp::details
         {
             using fn = forward_cast_t<Self, type<J>>;
 
-            if constexpr(std::invocable<fn, Args...>) return type_constant<indexed_value<J, fn>>{};
+            if constexpr(std::invocable<fn, Args...>) return J;
             else return first_invocable<Self, J + 1, Args...>();
         }
 
@@ -55,11 +56,13 @@ namespace stdsharp::details
         template<
             typename Self,
             typename... Args,
-            std::invocable<Args...> Fn = decltype(first_invocable<0, Args...>())::type>
+            auto J = first_invocable<Self, 0, Args...>(),
+            std::invocable<Args...> Fn = forward_cast_t<Self, type<J>>>
         constexpr decltype(auto) operator()(this Self&& self, Args&&... args)
             noexcept(nothrow_invocable<Fn, Args...>)
         {
-            return invoke(forward_cast<Self, sequenced_invocables, Fn>(self), cpp_forward(args)...);
+            auto&& fn = forward_cast<Self, sequenced_invocables>(self).template get<J>();
+            return invoke(cpp_forward(fn), cpp_forward(args)...);
         }
     };
 }
 
@@ -17,23 +17,19 @@ namespace stdsharp::details
             consteval type_constant<T> get() const noexcept { return {}; }
         };
 
+        template<std::size_t>
         struct invalid
         {
         };
 
-        template<>
-        struct filter<invalid>
-        {
-        };
-
     public:
         template<std::size_t I, std::size_t... J, typename... T>
         static consteval auto impl(
             const std::index_sequence<J...> /*unused*/,
             const basic_type_sequence<T...> /*unused*/
         )
         {
-            constexpr struct : filter<std::conditional_t<I == J, T, invalid>>...
+            constexpr struct STDSHARP_EBO : std::conditional_t<I == J, filter<T>, invalid<J>>...
             {
             } f{};
 
 
@@ -1,9 +1,10 @@
 
 #pragma once
 
+#include "../concepts/object.h"
 #include "expression.h"
 #include "regular_type_sequence.h"
-#include "../concepts/object.h"
+
 
 namespace stdsharp
 {
 
@@ -77,7 +77,7 @@ namespace stdsharp
     using make_index_sequence = make_integer_sequence<std::size_t, N>;
 
     template<auto From, std::size_t Size, auto PlusF = std::plus{}>
-    using make_value_sequence_t =
+    using make_value_sequence =
         decltype(details::make_value_sequence<From, PlusF>(std::make_index_sequence<Size>{}));
 
     template<typename... T>
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`#pragma once`
`2`	`2`
`3`	`3`	`#include "../type_traits/indexed_traits.h"`
	`4`	`+#include "invoke.h"`
`4`	`5`
`5`	`6`	`#include <tuple>`
`6`	`7`
`@@ -22,7 +23,7 @@ namespace stdsharp::details`
`22`	`23`	`{`
`23`	`24`	`using fn = forward_cast_t<Self, type<J>>;`
`24`	`25`
`25`		`- if constexpr(std::invocable<fn, Args...>) return type_constant<indexed_value<J, fn>>{};`
	`26`	`+ if constexpr(std::invocable<fn, Args...>) return J;`
`26`	`27`	`else return first_invocable<Self, J + 1, Args...>();`
`27`	`28`	`}`
`28`	`29`
`@@ -55,11 +56,13 @@ namespace stdsharp::details`
`55`	`56`	`template<`
`56`	`57`	`typename Self,`
`57`	`58`	`typename... Args,`
`58`		`- std::invocable<Args...> Fn = decltype(first_invocable<0, Args...>())::type>`
	`59`	`+ auto J = first_invocable<Self, 0, Args...>(),`
	`60`	`+ std::invocable<Args...> Fn = forward_cast_t<Self, type<J>>>`
`59`	`61`	`constexpr decltype(auto) operator()(this Self&& self, Args&&... args)`
`60`	`62`	`noexcept(nothrow_invocable<Fn, Args...>)`
`61`	`63`	`{`
`62`		`- return invoke(forward_cast<Self, sequenced_invocables, Fn>(self), cpp_forward(args)...);`
	`64`	`+ auto&& fn = forward_cast<Self, sequenced_invocables>(self).template get<J>();`
	`65`	`+ return invoke(cpp_forward(fn), cpp_forward(args)...);`
`63`	`66`	`}`
`64`	`67`	`};`
`65`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,23 +17,19 @@ namespace stdsharp::details`
`17`	`17`	`consteval type_constant<T> get() const noexcept { return {}; }`
`18`	`18`	`};`
`19`	`19`
	`20`	`+ template<std::size_t>`
`20`	`21`	`struct invalid`
`21`	`22`	`{`
`22`	`23`	`};`
`23`	`24`
`24`		`- template<>`
`25`		`- struct filter<invalid>`
`26`		`- {`
`27`		`- };`
`28`		`-`
`29`	`25`	`public:`
`30`	`26`	`template<std::size_t I, std::size_t... J, typename... T>`
`31`	`27`	`static consteval auto impl(`
`32`	`28`	`const std::index_sequence<J...> /unused/,`
`33`	`29`	`const basic_type_sequence<T...> /unused/`
`34`	`30`	`)`
`35`	`31`	`{`
`36`		`- constexpr struct : filter<std::conditional_t<I == J, T, invalid>>...`
	`32`	`+ constexpr struct STDSHARP_EBO : std::conditional_t<I == J, filter<T>, invalid<J>>...`
`37`	`33`	`{`
`38`	`34`	`} f{};`
`39`	`35`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`	`1`
`2`	`2`	`#pragma once`
`3`	`3`
	`4`	`+#include "../concepts/object.h"`
`4`	`5`	`#include "expression.h"`
`5`	`6`	`#include "regular_type_sequence.h"`
`6`		`-#include "../concepts/object.h"`
	`7`	`+`
`7`	`8`
`8`	`9`	`namespace stdsharp`
`9`	`10`	`{`