add Chapter18

Chapter18/cib/libs/flow/detail/seq.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <cib/detail/runtime_conditional.hpp>
+#include <flow/detail/walk.hpp>
+#include <flow/subgraph_identity.hpp>
+
+#include <stdx/tuple_algorithms.hpp>
+
+namespace flow::dsl {
+template <subgraph Lhs, subgraph Rhs,
+          subgraph_identity Identity = subgraph_identity::REFERENCE,
+          typename Cond = cib::detail::always_condition_t>
+struct seq {
+    Lhs lhs;
+    Rhs rhs;
+
+    using is_subgraph = void;
+
+    constexpr auto operator*() const {
+        return seq<Lhs, Rhs, subgraph_identity::VALUE, Cond>{Lhs{}, Rhs{}};
+    }
+
+  private:
+    friend constexpr auto tag_invoke(get_initials_t, seq const &s) {
+        return get_initials(s.lhs);
+    }
+
+    friend constexpr auto tag_invoke(get_finals_t, seq const &s) {
+        return get_finals(s.rhs);
+    }
+
+    friend constexpr auto tag_invoke(get_nodes_t, seq const &s) {
+        if constexpr (Identity == subgraph_identity::VALUE) {
+            auto all_nodes = stdx::to_unsorted_set(
+                stdx::tuple_cat(get_all_mentioned_nodes(s.lhs),
+                                get_all_mentioned_nodes(s.rhs)));
+
+            return stdx::transform([](auto const &n) { return *n; }, all_nodes);
+
+        } else {
+            return stdx::tuple_cat(get_nodes(s.lhs), get_nodes(s.rhs));
+        }
+    }
+
+    friend constexpr auto tag_invoke(get_all_mentioned_nodes_t, seq const &s) {
+        return stdx::tuple_cat(get_all_mentioned_nodes(s.lhs),
+                               get_all_mentioned_nodes(s.rhs));
+    }
+
+    friend constexpr auto tag_invoke(get_edges_t, seq const &s) {
+        auto is = get_initials(s.rhs);
+        auto fs = get_finals(s.lhs);
+
+        return stdx::tuple_cat(
+            get_edges(s.lhs), get_edges(s.rhs),
+            transform(
+                []<typename P>(P const &) {
+                    return edge<stdx::tuple_element_t<0, P>,
+                                stdx::tuple_element_t<1, P>, Cond>{};
+                },
+                cartesian_product_copy(fs, is)));
+    }
+};
+
+template <subgraph Lhs, subgraph Rhs> seq(Lhs, Rhs) -> seq<Lhs, Rhs>;
+
+} // namespace flow::dsl
+
+template <flow::dsl::subgraph Lhs, flow::dsl::subgraph Rhs>
+[[nodiscard]] constexpr auto operator>>(Lhs const &lhs, Rhs const &rhs) {
+    return flow::dsl::seq{lhs, rhs};
+}
+
+template <typename Cond, flow::dsl::subgraph Lhs, flow::dsl::subgraph Rhs,
+          flow::subgraph_identity Identity, typename EdgeCond>
+constexpr auto
+make_runtime_conditional(Cond, flow::dsl::seq<Lhs, Rhs, Identity, EdgeCond>) {
+    auto lhs = make_runtime_conditional(Cond{}, Lhs{});
+    auto rhs = make_runtime_conditional(Cond{}, Rhs{});
+
+    using lhs_t = decltype(lhs);
+    using rhs_t = decltype(rhs);
+    using cond_t = decltype(EdgeCond{} and Cond{});
+
+    return flow::dsl::seq<lhs_t, rhs_t, Identity, cond_t>{lhs, rhs};
+}