🎨 Use stdx name utilities instead of manual naming for flow

include/flow/debug_builder.hpp

@@ -21,7 +21,8 @@ struct debug_builder {
     [[nodiscard]] static auto build(Graph const &input) {
         auto const nodes = stdx::to_unsorted_set(flow::dsl::get_nodes(input));
         auto const edges = stdx::to_unsorted_set(flow::dsl::get_edges(input));
-        auto const named_nodes = stdx::apply_indices<name_for>(nodes);
+        auto const named_nodes =
+            stdx::apply_indices<stdx::constant_name_of_t>(nodes);
 
         using nodes_t = std::remove_cvref_t<decltype(nodes)>;
         using edges_t = std::remove_cvref_t<decltype(edges)>;

include/flow/dsl/walk.hpp

@@ -25,10 +25,9 @@ template <typename Source, typename Dest, typename Cond> struct edge {
     using cond_t = Cond;
 };
 
-template <stdx::ct_string Name> struct node_reference {
+template <stdx::ct_string Name> struct node_reference : stdx::with_name<Name> {
     using is_subgraph = void;
     constexpr static auto identity = subgraph_identity::REFERENCE;
-    using name_t = stdx::cts_t<Name>;
 };
 
 namespace literals {

include/flow/func_list.hpp

@@ -7,6 +7,7 @@
 #include <stdx/ct_string.hpp>
 #include <stdx/span.hpp>
 #include <stdx/type_traits.hpp>
+#include <stdx/utility.hpp>
 
 #include <algorithm>
 #include <array>
@@ -23,8 +24,8 @@ constexpr static auto run_func = []() -> void {
         LogPolicy::template log<
             decltype(get_log_env<CTNode, log_env_id_t<FlowName>>())>(
             __FILE__, __LINE__,
-            stdx::ct_format<"flow.{}({})">(stdx::cts_t<CTNode::ct_type>{},
-                                           stdx::cts_t<CTNode::ct_name>{}));
+            stdx::ct_format<"flow.{}({})">(stdx::ct<CTNode::ct_type>(),
+                                           stdx::constant_name_of_v<CTNode>));
         auto f = typename CTNode::func_t{};
         if constexpr (requires { std::move(f).template operator()<Nexus>(); }) {
             std::move(f).template operator()<Nexus>();
@@ -35,20 +36,19 @@ constexpr static auto run_func = []() -> void {
 };
 
 template <stdx::ct_string Name, log_policy LogPolicy, auto... FuncPtrs>
-struct inlined_func_list {
+struct inlined_func_list : stdx::with_name<Name> {
     constexpr static auto active = sizeof...(FuncPtrs) > 0;
-    constexpr static auto ct_name = Name;
 
     __attribute__((flatten, always_inline)) auto operator()() const -> void {
         LogPolicy::template log<decltype(get_log_env<inlined_func_list>())>(
             __FILE__, __LINE__,
-            stdx::ct_format<"flow.start({})">(stdx::cts_t<Name>{}));
+            stdx::ct_format<"flow.start({})">(stdx::ct<Name>()));
 
         (FuncPtrs(), ...);
 
         LogPolicy::template log<decltype(get_log_env<inlined_func_list>())>(
             __FILE__, __LINE__,
-            stdx::ct_format<"flow.end({})">(stdx::cts_t<Name>{}));
+            stdx::ct_format<"flow.end({})">(stdx::ct<Name>()));
     }
 };
 } // namespace detail
@@ -62,7 +62,7 @@ struct func_list {
     template <typename Nexus, typename CTNode>
     constexpr static auto create_node(CTNode) -> node_t {
         constexpr auto fp = detail::run_func<Name, LogPolicy, CTNode, Nexus>;
-        constexpr auto name = std::string_view{CTNode::ct_name};
+        constexpr auto name = std::string_view{stdx::name_of_v<CTNode>};
         return {fp, name};
     }
 

include/flow/graph_builder.hpp

@@ -78,12 +78,15 @@ struct graph_builder {
                      Node n) { g.put(Output::template create_node<Nexus>(n)); },
                  nodes);
 
-        auto const named_nodes = stdx::apply_indices<name_for>(nodes);
+        auto const named_nodes =
+            stdx::apply_indices<stdx::constant_name_of_t>(nodes);
         for_each(
             [&]<typename Lhs, typename Rhs, typename Cond>(
                 dsl::edge<Lhs, Rhs, Cond> const &) {
-                auto const lhs = get<name_for<Lhs>>(named_nodes);
-                auto const rhs = get<name_for<Rhs>>(named_nodes);
+                auto const lhs =
+                    get<stdx::constant_name_of_t<Lhs>>(named_nodes);
+                auto const rhs =
+                    get<stdx::constant_name_of_t<Rhs>>(named_nodes);
 
                 using lhs_t = std::remove_cvref_t<decltype(lhs)>;
                 using rhs_t = std::remove_cvref_t<decltype(rhs)>;
@@ -102,9 +105,13 @@ struct graph_builder {
                             "weaker than those on {}[{}] or {}[{}]. "
                             "Specifically, the sequence is missing the "
                             "predicate: {}",
-                            lhs_t::ct_name, rhs_t::ct_name, Cond::ct_name,
-                            lhs_t::ct_name, lhs_cond_t::ct_name, rhs_t::ct_name,
-                            rhs_cond_t::ct_name, P);
+                            stdx::constant_name_of_v<lhs_t>,
+                            stdx::constant_name_of_v<rhs_t>,
+                            stdx::constant_name_of_v<Cond>,
+                            stdx::constant_name_of_v<lhs_t>,
+                            stdx::constant_name_of_v<lhs_cond_t>,
+                            stdx::constant_name_of_v<rhs_t>,
+                            stdx::constant_name_of_v<rhs_cond_t>, P);
                     },
                     node_ps);
 
@@ -183,8 +190,10 @@ struct graph_builder {
     // NOLINTNEXTLINE (readability-function-cognitive-complexity)
     constexpr static void check_for_missing_nodes(auto nodes,
                                                   auto mentioned_nodes) {
-        constexpr auto get_name = []<typename N>(N) ->
-            typename N::name_t { return {}; };
+        constexpr auto get_name =
+            []<typename N>(N) -> stdx::constant_name_of_t<N> {
+            return stdx::constant_name_of_v<N>;
+        };
         auto node_names = stdx::transform(get_name, nodes);
         auto mentioned_node_names = stdx::transform(get_name, mentioned_nodes);
 
@@ -201,7 +210,7 @@ struct graph_builder {
             "{}.",
             Name, detail::error_join<missing_nodes_t>);
 
-        constexpr auto duplicates = stdx::transform(
+        auto duplicates = stdx::transform(
             [](auto e) { return stdx::get<0>(e); },
             stdx::filter<detail::is_duplicated>(stdx::gather(node_names)));
         using duplicate_nodes_t = decltype(duplicates);

include/flow/graph_common.hpp

@@ -9,18 +9,16 @@
 #include <type_traits>
 
 namespace flow {
-template <typename T> using name_for = typename T::name_t;
-
 [[nodiscard]] constexpr auto edge_size(auto const &nodes, auto const &edges)
     -> std::size_t {
     auto const edge_capacities = transform(
         [&]<typename N>(N const &) {
             return edges.fold_left(
                 std::size_t{}, []<typename E>(auto acc, E const &) {
-                    if constexpr (std::is_same_v<name_for<typename E::source_t>,
-                                                 name_for<N>> or
-                                  std::is_same_v<name_for<typename E::dest_t>,
-                                                 name_for<N>>) {
+                    if constexpr (stdx::name_of_v<typename E::source_t> ==
+                                      stdx::name_of_v<N> or
+                                  stdx::name_of_v<typename E::dest_t> ==
+                                      stdx::name_of_v<N>) {
                         return ++acc;
                     } else {
                         return acc;
@@ -37,16 +35,19 @@ template <typename T> using name_for = typename T::name_t;
 namespace detail {
 template <typename N> struct matching_source {
     template <typename Edge>
-    using fn = std::is_same<name_for<N>, name_for<typename Edge::source_t>>;
+    using fn = std::bool_constant<stdx::name_of_v<N> ==
+                                  stdx::name_of_v<typename Edge::source_t>>;
 };
 
 template <typename N> struct matching_dest {
     template <typename Edge>
-    using fn = std::is_same<name_for<N>, name_for<typename Edge::dest_t>>;
+    using fn = std::bool_constant<stdx::name_of_v<N> ==
+                                  stdx::name_of_v<typename Edge::dest_t>>;
 };
 
 template <typename T> struct matching_name {
-    template <typename U> using fn = std::is_same<name_for<T>, name_for<U>>;
+    template <typename U>
+    using fn = std::bool_constant<stdx::name_of_v<T> == stdx::name_of_v<U>>;
 };
 
 template <typename Nodes> struct contained_edge_q {
@@ -85,7 +86,7 @@ using any_descendants =
 template <typename Start, typename Edges> struct descendant_of_q<Start, Edges> {
     template <typename Node>
     using fn = boost::mp11::mp_eval_if_c<
-        std::is_same_v<name_for<Node>, name_for<Start>>, std::true_type,
+        stdx::name_of_v<Node> == stdx::name_of_v<Start>, std::true_type,
         any_descendants, parents_of<Node, Edges>, Start, Edges>;
 };
 
@@ -97,7 +98,7 @@ using any_ancestors = boost::mp11::mp_any_of_q<L, ancestor_of_q<Start, Edges>>;
 template <typename Start, typename Edges> struct ancestor_of_q<Start, Edges> {
     template <typename Node>
     using fn = boost::mp11::mp_eval_if_c<
-        std::is_same_v<name_for<Node>, name_for<Start>>, std::true_type,
+        stdx::name_of_v<Node> == stdx::name_of_v<Start>, std::true_type,
         any_ancestors, children_of<Node, Edges>, Start, Edges>;
 };
 } // namespace detail

include/flow/log.hpp

@@ -19,18 +19,16 @@ using default_log_env =
 template <stdx::ct_string, typename...>
 constexpr auto log_env = default_log_env{};
 
-template <stdx::ct_string Name> struct log_env_id_t {
-    constexpr static auto ct_name = Name;
-};
+template <stdx::ct_string Name> struct log_env_id_t : stdx::with_name<Name> {};
 
 template <typename T, typename Fallback = log_env_id_t<"default">,
           typename... DummyArgs>
     requires(sizeof...(DummyArgs) == 0)
 constexpr static auto get_log_env() {
-    using log_env_t = decltype(log_env<T::ct_name, DummyArgs...>);
+    using log_env_t = decltype(log_env<stdx::name_of_v<T>, DummyArgs...>);
     if constexpr (std::is_same_v<log_env_t, default_log_env const>) {
-        if constexpr (Fallback::ct_name == stdx::ct_string{"default"}) {
-            return log_env<Fallback::ct_name, DummyArgs...>;
+        if constexpr (stdx::name_of_v<Fallback> == stdx::ct_string{"default"}) {
+            return log_env<"default", DummyArgs...>;
         } else {
             return get_log_env<Fallback>();
         }

include/flow/step.hpp

@@ -13,14 +13,12 @@
 namespace flow {
 template <stdx::ct_string Type, stdx::ct_string Name,
           dsl::subgraph_identity Identity, typename Cond, typename F>
-struct ct_node {
+struct ct_node : stdx::with_name<Name> {
     using is_subgraph = void;
-    using name_t = stdx::cts_t<Name>;
     using func_t = F;
     using cond_t = Cond;
 
     constexpr static auto ct_type = Type;
-    constexpr static auto ct_name = Name;
     constexpr static auto identity = Identity;
     constexpr static auto condition = cond_t{};
 

include/flow/viz_builder.hpp

@@ -17,18 +17,19 @@
 namespace flow {
 struct graphviz {
     template <stdx::ct_string Name> consteval static auto prologue() {
-        return +stdx::ct_format<"digraph {} {">(stdx::cts_t<Name>{});
+        return +stdx::ct_format<"digraph {} {">(stdx::ct<Name>());
     }
     template <stdx::ct_string Name> consteval static auto epilogue() {
         using namespace stdx::literals;
         return "}"_cts;
     }
     template <typename Node> consteval static auto render_node(Node) {
-        return +stdx::ct_format<"  {}">(typename Node::name_t{});
+        return +stdx::ct_format<"  {}">(stdx::constant_name_of_v<Node>);
     }
     template <typename Edge> consteval static auto render_edge(Edge) {
-        return +stdx::ct_format<"  {} -> {}">(typename Edge::source_t::name_t{},
-                                              typename Edge::dest_t::name_t{});
+        return +stdx::ct_format<"  {} -> {}">(
+            stdx::constant_name_of_v<typename Edge::source_t>,
+            stdx::constant_name_of_v<typename Edge::dest_t>);
     }
 };
 
@@ -45,9 +46,9 @@ class mermaid {
     template <typename Node> consteval static auto to_box() {
         using namespace stdx::literals;
         if constexpr (detail::is_milestone<Node>) {
-            return stdx::ct_format<"[{}]">(typename Node::name_t{});
+            return stdx::ct_format<"[{}]">(stdx::constant_name_of_v<Node>);
         } else {
-            return stdx::ct_format<"({})">(typename Node::name_t{});
+            return stdx::ct_format<"({})">(stdx::constant_name_of_v<Node>);
         }
     }
 
@@ -63,30 +64,30 @@ class mermaid {
     }
 
     template <typename Node> consteval static auto render_node(Node) {
-        return +stdx::ct_format<"  {}{}">(to_id<Node::name_t::value>(),
+        return +stdx::ct_format<"  {}{}">(to_id<stdx::name_of_v<Node>>(),
                                           to_box<Node>());
     }
 
     template <typename Node>
-        requires(Node::name_t::value == stdx::ct_string{"start"} or
-                 Node::name_t::value == stdx::ct_string{"end"})
+        requires(stdx::name_of_v<Node> == stdx::ct_string{"start"} or
+                 stdx::name_of_v<Node> == stdx::ct_string{"end"})
     consteval static auto render_node(Node) {
-        return +stdx::ct_format<"  {}(({}))">(to_id<Node::name_t::value>(),
-                                              typename Node::name_t{});
+        return +stdx::ct_format<"  {}(({}))">(to_id<stdx::name_of_v<Node>>(),
+                                              stdx::constant_name_of_v<Node>);
     }
 
     template <typename Edge> consteval static auto render_edge(Edge) {
         using namespace stdx::literals;
 
-        if constexpr (Edge::cond_t::ct_name == "always"_cts) {
+        if constexpr (stdx::name_of_v<typename Edge::cond_t> == "always"_cts) {
             return +stdx::ct_format<"  {} --> {}">(
-                to_id<Edge::source_t::name_t::value>(),
-                to_id<Edge::dest_t::name_t::value>());
+                to_id<stdx::name_of_v<typename Edge::source_t>>(),
+                to_id<stdx::name_of_v<typename Edge::dest_t>>());
         } else {
             return +stdx::ct_format<"  {} --{}--> {}">(
-                to_id<Edge::source_t::name_t::value>(),
-                stdx::cts_t<Edge::cond_t::ct_name>{},
-                to_id<Edge::dest_t::name_t::value>());
+                to_id<stdx::name_of_v<typename Edge::source_t>>(),
+                stdx::constant_name_of_v<typename Edge::cond_t>,
+                to_id<stdx::name_of_v<typename Edge::dest_t>>());
         }
     }
 };

include/msg/callback.hpp

@@ -99,7 +99,7 @@ template <typename Cond, stdx::ct_string Name, typename Msg, match::matcher M,
 constexpr auto make_runtime_conditional(Cond, callback<Name, Msg, M, F> cb) {
     using ::operator and;
 
-    auto predicate = match::predicate<Cond::ct_name>(
+    auto predicate = match::predicate<stdx::name_of_v<Cond>>(
         [](auto...) -> bool { return static_cast<bool>(Cond{}); });
     using predicate_t = decltype(predicate);
 

include/nexus/detail/constexpr_conditional.hpp

@@ -5,6 +5,7 @@
 #include <nexus/detail/extend.hpp>
 
 #include <stdx/ct_format.hpp>
+#include <stdx/ct_string.hpp>
 #include <stdx/tuple.hpp>
 #include <stdx/tuple_algorithms.hpp>
 #include <stdx/type_traits.hpp>
@@ -33,11 +34,10 @@ struct constexpr_conditional : config_item {
     }
 };
 
-template <stdx::ct_string Name, typename... Ps> struct constexpr_condition {
+template <stdx::ct_string Name, typename... Ps>
+struct constexpr_condition : stdx::with_name<Name> {
     constexpr static auto predicates = stdx::make_tuple(Ps{}...);
 
-    constexpr static auto ct_name = Name;
-
     template <typename... Configs>
     [[nodiscard]] consteval auto operator()(Configs const &...configs) const {
         return detail::constexpr_conditional<constexpr_condition<Name, Ps...>,

include/nexus/detail/runtime_conditional.hpp

@@ -6,6 +6,7 @@
 
 #include <stdx/concepts.hpp>
 #include <stdx/ct_format.hpp>
+#include <stdx/ct_string.hpp>
 #include <stdx/tuple.hpp>
 #include <stdx/tuple_algorithms.hpp>
 
@@ -56,11 +57,9 @@ concept runtime_predicate =
     std::default_initializable<T> and stdx::predicate<T>;
 
 template <stdx::ct_string Name, runtime_predicate... Ps>
-struct runtime_condition {
+struct runtime_condition : stdx::with_name<Name> {
     constexpr static auto predicates = stdx::make_tuple(Ps{}...);
 
-    constexpr static auto ct_name = Name;
-
     template <typename... Configs>
     [[nodiscard]] consteval auto operator()(Configs const &...configs) const {
         return detail::runtime_conditional<runtime_condition<Name, Ps...>,

include/seq/step.hpp

@@ -28,16 +28,12 @@ struct rt_step {
 };
 
 template <stdx::ct_string Name, bool IsReference = true>
-struct ct_step : rt_step {
+struct ct_step : rt_step, stdx::with_name<Name> {
     using is_subgraph = void;
-    using name_t = stdx::cts_t<Name>;
 
     constexpr static auto identity = flow::dsl::subgraph_identity::VALUE;
-
     constexpr static auto condition = cib::detail::always_condition;
 
-    constexpr static auto ct_name = Name;
-
     constexpr auto operator*() const -> ct_step<Name, false> {
         return {forward_ptr, backward_ptr, log_name};
     }