Repository: yaito3014/yk_util
Pull request #69: comparison utilities
Author: login: yaito3014
Labels: name: enhancement
description: New feature or request
Created: 2025-05-08T07:49:34Z | Merged: 2025-05-22T14:48:25Z



Diff:
diff --git a/include/yk/boolean_testable.hpp b/include/yk/boolean_testable.hpp
new file mode 100644
index 00000000..82011ebe
--- /dev/null
+++ b/include/yk/boolean_testable.hpp
@@ -0,0 +1,22 @@
+#ifndef YK_BOOLEAN_TESTABLE_HPP
+#define YK_BOOLEAN_TESTABLE_HPP
+
+#include <concepts>
+
+namespace yk {
+
+namespace detail {
+
+template <class T>
+concept boolean_testable_impl = std::convertible_to<T, bool>;
+
+}  // namespace detail
+
+template <class T>
+concept boolean_testable = detail::boolean_testable_impl<T> && requires(T&& t) {
+  { !static_cast<T&&>(t) } -> detail::boolean_testable_impl;
+};
+
+}  // namespace yk
+
+#endif  // YK_BOOLEAN_TESTABLE_HPP
diff --git a/include/yk/compare.hpp b/include/yk/compare.hpp
new file mode 100644
index 00000000..d40fd708
--- /dev/null
+++ b/include/yk/compare.hpp
@@ -0,0 +1,8 @@
+#ifndef YK_COMPARE_HPP
+#define YK_COMPARE_HPP
+
+#include "yk/compare/adaptor.hpp"
+#include "yk/compare/comparator.hpp"
+#include "yk/compare/concepts.hpp"
+
+#endif  // YK_COMPARE_HPP
diff --git a/include/yk/compare/adaptor.hpp b/include/yk/compare/adaptor.hpp
new file mode 100644
index 00000000..15bc17a3
--- /dev/null
+++ b/include/yk/compare/adaptor.hpp
@@ -0,0 +1,88 @@
+#ifndef YK_COMPARE_ADAPTOR_HPP
+#define YK_COMPARE_ADAPTOR_HPP
+
+#include "yk/compare/concepts.hpp"
+#include "yk/no_unique_address.hpp"
+
+#include <compare>
+#include <functional>
+
+namespace yk {
+
+namespace compare {
+
+namespace detail {
+
+template <ordering T>
+struct then_closure {
+  T value;
+
+  template <ordering Lhs>
+  [[nodiscard]] friend constexpr std::common_comparison_category_t<Lhs, T> operator|(Lhs lhs, then_closure rhs) noexcept
+  {
+    if (lhs == 0) {
+      return rhs.value;
+    } else {
+      return lhs;
+    }
+  }
+};
+
+struct then_impl {
+  template <ordering T>
+  [[nodiscard]] constexpr then_closure<T> operator()(T x) const noexcept
+  {
+    return {x};
+  }
+
+  template <ordering T, ordering U>
+  [[nodiscard]] constexpr auto operator()(T x, U y) const noexcept
+  {
+    return x | then_closure<U>{y};
+  }
+};
+
+template <class F>
+  requires std::invocable<std::decay_t<F>>
+struct then_with_closure {
+  YK_NO_UNIQUE_ADDRESS F func;
+
+  template <ordering Lhs, class Self>
+    requires std::same_as<std::remove_cvref_t<Self>, then_with_closure>
+  [[nodiscard]] friend constexpr auto operator|(Lhs lhs, Self&& rhs) noexcept
+      -> std::common_comparison_category_t<Lhs, std::invoke_result_t<std::decay_t<F>>>
+  {
+    if (lhs == 0) {
+      return std::invoke(std::forward<Self>(rhs).func);
+    } else {
+      return lhs;
+    }
+  }
+};
+
+struct then_with_impl {
+  template <class F>
+    requires std::invocable<std::decay_t<F>>
+  [[nodiscard]] constexpr then_with_closure<F> operator()(F&& f) const noexcept
+  {
+    return then_with_closure<F>{f};
+  }
+
+  template <ordering T, class F>
+    requires std::invocable<std::decay_t<F>>
+  [[nodiscard]] constexpr auto operator()(T x, F&& f) const noexcept
+  {
+    return x | then_with_closure<F>{f};
+  }
+};
+
+}  // namespace detail
+
+inline constexpr detail::then_impl then{};
+inline constexpr detail::then_with_impl then_with;
+
+}  // namespace compare
+
+}  // namespace yk
+
+#endif  // YK_COMPARE_ADAPTOR_HPP
diff --git a/include/yk/compare/comparator.hpp b/include/yk/compare/comparator.hpp
new file mode 100644
index 00000000..e5e5e043
--- /dev/null
+++ b/include/yk/compare/comparator.hpp
@@ -0,0 +1,414 @@
+#ifndef YK_COMPARE_COMPARATOR
+#define YK_COMPARE_COMPARATOR
+
+#include "yk/compare/concepts.hpp"
+#include "yk/no_unique_address.hpp"
+#include "yk/util/functional.hpp"
+#include "yk/util/specialization_of.hpp"
+
+#include <compare>
+#include <concepts>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+namespace yk {
+
+namespace compare {
+
+namespace detail {
+
+struct dummy_range {
+  int* begin();
+  int* end();
+};
+
+// is there more better way to detect range adaptor closure? idk
+template <class Closure>
+concept RangeAdaptorClosure = requires(Closure closure) {
+  closure(dummy_range{});
+  dummy_range{} | closure;
+  closure | closure;
+};
+
+}  // namespace detail
+
+struct comparator_interface {};
+
+template <class Comp>
+inline constexpr bool enable_comparator = std::derived_from<Comp, comparator_interface>;
+
+template <class Comp>
+concept comparator = yk::binary_function<Comp> && enable_comparator<Comp>;
+
+struct comparator_adaptor_closure {};
+
+template <class Comp, class Closure>
+  requires binary_function<std::decay_t<Comp>>
+           && std::derived_from<std::remove_cvref_t<Closure>, comparator_adaptor_closure>
+[[nodiscard]] constexpr auto operator|(Comp&& comp, Closure&& closure) noexcept
+{
+  return std::invoke(std::forward<Closure>(closure), std::forward<Comp>(comp));
+}
+
+namespace detail {
+
+template <class Lhs, class Rhs>
+struct [[nodiscard]] pipe_closure : comparator_adaptor_closure {
+  static constexpr std::size_t arity = 1;
+
+  YK_NO_UNIQUE_ADDRESS Lhs lhs;
+  YK_NO_UNIQUE_ADDRESS Rhs rhs;
+
+  constexpr pipe_closure(Lhs&& l, Rhs&& r) noexcept : lhs(std::forward<Lhs>(l)), rhs(std::forward<Rhs>(r)) {}
+
+  template <class Comp>
+    requires binary_function<std::decay_t<Comp>>
+  [[nodiscard]] constexpr auto operator()(Comp&& comp) const noexcept(
+      noexcept(std::invoke(rhs, std::invoke(lhs, std::forward<Comp>(comp))))
+  )
+  {
+    return std::invoke(rhs, std::invoke(lhs, std::forward<Comp>(comp)));
+  }
+};
+
+}  // namespace detail
+
+template <class Lhs, class Rhs>
+  requires std::derived_from<std::remove_cvref_t<Lhs>, comparator_adaptor_closure>
+           && std::derived_from<std::remove_cvref_t<Rhs>, comparator_adaptor_closure>
+[[nodiscard]] constexpr auto operator|(Lhs&& lhs, Rhs&& rhs) noexcept
+{
+  return detail::pipe_closure{std::forward<Lhs>(lhs), std::forward<Rhs>(rhs)};
+}
+
+template <class Comp>
+  requires binary_function<std::decay_t<Comp>>
+struct wrapper_comparator : comparator_interface {
+  static constexpr std::size_t arity = 2;
+
+  YK_NO_UNIQUE_ADDRESS Comp comp;
+
+  constexpr wrapper_comparator(Comp&& c) noexcept : comp(std::forward<Comp>(c)) {}
+
+  template <class T, class U>
+  [[nodiscard]] constexpr auto operator()(T&& x, U&& y) const noexcept(
+      noexcept(std::is_nothrow_invocable_v<Comp, T, U>)
+  )
+  {
+    return std::invoke(comp, std::forward<T>(x), std::forward<U>(y));
+  }
+};
+
+template <class Comp>
+wrapper_comparator(Comp&&) -> wrapper_comparator<Comp>;
+
+namespace detail {
+
+struct wrap_fn {
+  template <class Comp>
+    requires binary_function<std::decay_t<Comp>>
+  [[nodiscard]] constexpr auto operator()(Comp&& comp) const noexcept
+  {
+    return wrapper_comparator{std::forward<Comp>(comp)};
+  }
+
+  template <class Comp>
+    requires comparator<std::decay_t<Comp>>
+  [[nodiscard]] constexpr auto operator()(Comp&& comp) const noexcept
+  {
+    return std::forward<Comp>(comp);
+  }
+};
+
+}  // namespace detail
+
+namespace comparators {
+
+inline constexpr detail::wrap_fn wrap{};
+
+}  // namespace comparators
+
+template <class Comp>
+using wrap_t = decltype(comparators::wrap(std::declval<Comp>()));
+
+template <comparator Comp1, comparator Comp2>
+struct then_comparator : comparator_interface {
+  static constexpr std::size_t arity = 2;
+
+  YK_NO_UNIQUE_ADDRESS Comp1 comp1;
+  YK_NO_UNIQUE_ADDRESS Comp2 comp2;
+
+  template <class T, class U>
+  constexpr then_comparator(T&& c1, U&& c2) noexcept : comp1(std::forward<T>(c1)), comp2(std::forward<U>(c2))
+  {
+  }
+
+  template <class T, class U>
+  [[nodiscard]] constexpr auto operator()(
+      T&& x, U&& y
+  ) const noexcept(std::is_nothrow_invocable_v<Comp1, T&, U&> && std::is_nothrow_invocable_v<Comp2, T&, U&>) ->
+      typename std::common_comparison_category_t<
+          std::invoke_result_t<Comp1, T&, U&>, std::invoke_result_t<Comp2, T&, U&>>
+  {
+    ordering auto res = std::invoke(comp1, x, y);
+    if (res == 0) {
+      return std::invoke(comp2, x, y);
+    } else {
+      return res;
+    }
+  }
+};
+
+template <class Comp1, class Comp2>
+then_comparator(Comp1&&, Comp2&&) -> then_comparator<wrap_t<Comp1>, wrap_t<Comp2>>;
+
+namespace detail {
+
+template <class Comp2>
+struct [[nodiscard]] comp_then_closure : comparator_adaptor_closure {
+  static constexpr std::size_t arity = 1;
+
+  YK_NO_UNIQUE_ADDRESS Comp2 comp2;
+
+  constexpr comp_then_closure(Comp2&& c2) noexcept : comp2(std::forward<Comp2>(c2)) {}
+
+  // if closure if const lvalue reference, pass reference
+  template <class Comp1>
+    requires binary_function<std::decay_t<Comp1>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1) const& noexcept
+  {
+    return then_comparator{std::forward<Comp1>(comp1), comp2};
+  }
+
+  // if closure if non-const lvalue reference, pass reference
+  template <class Comp1>
+    requires binary_function<std::decay_t<Comp1>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1) & noexcept
+  {
+    return then_comparator{std::forward<Comp1>(comp1), comp2};
+  }
+
+  // if closure if rvalue reference, move if Comp2 is not reference
+  template <class Comp1>
+    requires binary_function<std::decay_t<Comp1>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1) && noexcept
+  {
+    return then_comparator{std::forward<Comp1>(comp1), std::forward<Comp2>(comp2)};
+  }
+
+  // template <class Self, class Comp1>
+  // constexpr auto operator()(this Self&& self, Comp1&& comp1) noexcept
+  // {
+  //   return then_comparator{std::forward<Comp1>(comp1), move_if_both_rvalue<Self>(std::forward<Self>(self).comp2)};
+  // }
+};
+
+template <class Comp2>
+comp_then_closure(Comp2&&) -> comp_then_closure<Comp2>;
+
+struct comp_then_fn {
+  template <class Comp1, class Comp2>
+    requires binary_function<std::decay_t<Comp1>> && binary_function<std::decay_t<Comp2>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1, Comp2&& comp2) const noexcept
+  {
+    return then_comparator{std::forward<Comp1>(comp1), std::forward<Comp2>(comp2)};
+  }
+
+  template <class Comp2>
+    requires binary_function<std::decay_t<Comp2>>
+  [[nodiscard]] constexpr auto operator()(Comp2&& comp2) const noexcept
+  {
+    return comp_then_closure{std::forward<Comp2>(comp2)};
+  }
+};
+
+}  // namespace detail
+
+namespace comparators {
+
+inline constexpr detail::comp_then_fn then{};
+
+}  // namespace comparators
+
+template <class From, class To>
+struct is_promotable : std::false_type {};
+
+template <>
+struct is_promotable<std::partial_ordering, std::partial_ordering> : std::true_type {};
+
+template <>
+struct is_promotable<std::partial_ordering, std::weak_ordering> : std::true_type {};
+
+template <>
+struct is_promotable<std::partial_ordering, std::strong_ordering> : std::true_type {};
+
+template <>
+struct is_promotable<std::weak_ordering, std::weak_ordering> : std::true_type {};
+
+template <>
+struct is_promotable<std::weak_ordering, std::strong_ordering> : std::true_type {};
+
+template <class From, class To>
+inline constexpr bool is_promotable_v = is_promotable<From, To>::value;
+
+template <comparator Comp1, comparator Comp2>
+struct promote_comparator : comparator_interface {
+  static constexpr std::size_t arity = 2;
+
+  YK_NO_UNIQUE_ADDRESS Comp1 comp1;
+  YK_NO_UNIQUE_ADDRESS Comp2 comp2;
+
+  constexpr promote_comparator(Comp1&& comp1, Comp2&& comp2)
+      : comp1(std::forward<Comp1>(comp1)), comp2(std::forward<Comp2>(comp2))
+  {
+  }
+
+  // Invalid promotion. If you're trying to promote strong_ordering to strong_ordering, use then() instead.
+  template <class T, class U>
+  void operator()(T&&, U&&) const = delete;
+
+  template <class T, class U>
+  [[nodiscard]] constexpr auto operator()(T&& x, U&& y) const noexcept(
+      std::is_nothrow_invocable_v<Comp1, T&, U&> && std::is_nothrow_invocable_v<Comp2, T&, U&>
+  ) -> std::invoke_result_t<Comp2, T&, U&>
+    requires is_promotable_v<std::invoke_result_t<Comp1, T&, U&>, std::invoke_result_t<Comp2, T&, U&>>
+  {
+    using From = std::invoke_result_t<Comp1, T&, U&>;
+    using To = std::invoke_result_t<Comp2, T&, U&>;
+
+    const auto res = std::invoke(comp1, x, y);
+
+    if constexpr (std::same_as<From, To>) {
+      if (res == From::equivalent) return std::invoke(comp2, x, y);
+      return res;
+
+    } else {
+      if (res == From::less) return To::less;
+      if (res == From::greater) return To::greater;
+      return std::invoke(comp2, x, y);
+    }
+  }
+};
+
+template <class Comp1, class Comp2>
+promote_comparator(Comp1&&, Comp2&&) -> promote_comparator<wrap_t<Comp1>, wrap_t<Comp2>>;
+
+namespace detail {
+
+template <class Comp2>
+struct [[nodiscard]] promote_closure : comparator_adaptor_closure {
+  static constexpr std::size_t arity = 1;
+
+  YK_NO_UNIQUE_ADDRESS Comp2 comp2;
+
+  [[nodiscard]] constexpr promote_closure(Comp2&& c2) noexcept : comp2(std::forward<Comp2>(c2)) {}
+
+  template <class Comp1>
+    requires binary_function<std::decay_t<Comp1>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1) const& noexcept
+  {
+    return promote_comparator{std::forward<Comp1>(comp1), comp2};
+  }
+
+  template <class Comp1>
+    requires binary_function<std::decay_t<Comp1>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1) & noexcept
+  {
+    return promote_comparator{std::forward<Comp1>(comp1), comp2};
+  }
+
+  template <class Comp1>
+    requires binary_function<std::decay_t<Comp1>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1) && noexcept
+  {
+    return promote_comparator{std::forward<Comp1>(comp1), std::forward<Comp2>(comp2)};
+  }
+};
+
+struct promote_fn {
+  template <class Comp1, class Comp2>
+    requires binary_function<std::decay_t<Comp1>> && binary_function<std::decay_t<Comp2>>
+  [[nodiscard]] constexpr auto operator()(Comp1&& comp1, Comp2&& comp2) const noexcept
+  {
+    return promote_comparator{std::forward<Comp1>(comp1), std::forward<Comp2>(comp2)};
+  }
+
+  template <class Comp2>
+    requires binary_function<std::decay_t<Comp2>>
+  [[nodiscard]] constexpr auto operator()(Comp2&& comp2) const noexcept
+  {
+    return promote_closure<Comp2>{std::forward<Comp2>(comp2)};
+  }
+};
+
+}  // namespace detail
+
+namespace comparators {
+
+inline constexpr detail::promote_fn promote{};
+
+}  // namespace comparators
+
+template <class F>
+  requires unary_function<std::decay_t<F>>
+struct extract_comparator : comparator_interface {
+  static constexpr std::size_t arity = 2;
+
+  YK_NO_UNIQUE_ADDRESS F func;
+
+  constexpr extract_comparator(F&& f) noexcept : func(std::forward<F>(f)) {}
+
+  template <class T, class U>
+  [[nodiscard]] constexpr auto operator()(T&& x, U&& y) const noexcept(
+      noexcept(std::compare_three_way{}(std::invoke(func, std::forward<T>(x)), std::invoke(func, std::forward<U>(y))))
+  )
+  {
+    return std::compare_three_way{}(std::invoke(func, std::forward<T>(x)), std::invoke(func, std::forward<U>(y)));
+  }
+};
+
+template <class Self, class RAC>
+  requires specialization_of<std::remove_cvref_t<Self>, extract_comparator>
+           && detail::RangeAdaptorClosure<std::remove_cvref_t<RAC>>
+[[nodiscard]] constexpr auto operator|(Self&& comp, RAC&& rac) noexcept
+{
+  return extract_comparator{yk::compose(std::forward<RAC>(rac), std::forward<Self>(comp).func)};
+}
+
+namespace detail {
+
+struct extract_fn {
+  template <class F>
+    requires unary_function<std::decay_t<F>>
+  [[nodiscard]] constexpr auto operator()(F&& func) const noexcept
+  {
+    return extract_comparator{std::forward<F>(func)};
+  }
+};
+
+}  // namespace detail
+
+namespace comparators {
+
+inline constexpr detail::extract_fn extract{};
+
+}  // namespace comparators
+
+// short-hand syntax
+template <class Comp, class F>
+  requires comparator<std::decay_t<Comp>> && unary_function<std::decay_t<F>>
+           && (!std::derived_from<std::decay_t<F>, comparator_adaptor_closure>)
+           && (!detail::RangeAdaptorClosure<std::decay_t<F>>)
+[[nodiscard]] constexpr auto operator|(Comp&& comp, F&& f) noexcept
+{
+  return comparators::then(std::forward<Comp>(comp), comparators::extract(std::forward<F>(f)));
+}
+
+}  // namespace compare
+
+namespace comparators = compare::comparators;
+
+}  // namespace yk
+
+#endif  // YK_COMPARE_COMPARATOR
diff --git a/include/yk/compare/concepts.hpp b/include/yk/compare/concepts.hpp
new file mode 100644
index 00000000..f98750ab
--- /dev/null
+++ b/include/yk/compare/concepts.hpp
@@ -0,0 +1,35 @@
+#ifndef YK_COMPARE_CONCEPTS_HPP
+#define YK_COMPARE_CONCEPTS_HPP
+
+#include "yk/boolean_testable.hpp"
+#include "yk/util/functional.hpp"
+
+#include <concepts>
+
+namespace yk {
+
+namespace compare {
+
+template <class T>
+concept ordering = requires(T x) {
+  { x < 0 } -> boolean_testable;
+  { x <= 0 } -> boolean_testable;
+  { x == 0 } -> boolean_testable;
+  { x >= 0 } -> boolean_testable;
+  { x > 0 } -> boolean_testable;
+  { x != 0 } -> boolean_testable;
+  { x <=> 0 } -> std::same_as<T>;
+  { 0 < x } -> boolean_testable;
+  { 0 <= x } -> boolean_testable;
+  { 0 == x } -> boolean_testable;
+  { 0 >= x } -> boolean_testable;
+  { 0 > x } -> boolean_testable;
+  { 0 != x } -> boolean_testable;
+  { 0 <=> x } -> std::same_as<T>;
+};
+
+}  // namespace compare
+
+}  // namespace yk
+
+#endif  // YK_COMPARE_CONCEPTS_HPP
diff --git a/include/yk/util/functional.hpp b/include/yk/util/functional.hpp
index a0aa06e3..e588d768 100644
--- a/include/yk/util/functional.hpp
+++ b/include/yk/util/functional.hpp
@@ -2,8 +2,11 @@
 #define YK_UTIL_FUNCTIONAL_HPP
 
 #include "yk/util/type_list.hpp"
+#include "yk/no_unique_address.hpp"
 
+#include <functional>
 #include <type_traits>
+#include <utility>
 
 namespace yk {
 
@@ -12,16 +15,49 @@ enum class invocable_kind {
   member_function,
   data_member,
   function_object,
-  generic_function_object,
+  overloaded_function_object,
 };
 
 namespace detail {
 
-template <class F, class = void>
-struct invocable_traits {
-  static constexpr invocable_kind kind = invocable_kind::generic_function_object;
+template <class T, class = void>
+struct has_unambiguous_function_call_operator : std::false_type {};
+
+template <class T>
+struct has_unambiguous_function_call_operator<T, std::void_t<decltype(&T::operator())>> : std::true_type {};
+
+struct has_function_call_operator_mixin {
+  void operator()() {}
 };
 
+template <class T>
+struct has_function_call_operator_helper : T, has_function_call_operator_mixin {};
+
+template <class T>
+struct has_function_call_operator
+    : std::conjunction<
+          std::is_class<T>,
+          std::negation<has_unambiguous_function_call_operator<has_function_call_operator_helper<T>>>> {};
+
+}  // namespace detail
+
+template <class T>
+struct has_unambiguous_function_call_operator : detail::has_unambiguous_function_call_operator<T> {};
+
+template <class T>
+inline constexpr bool has_umambiguous_function_call_operator_v = has_unambiguous_function_call_operator<T>::value;
+
+template <class T>
+struct has_function_call_operator : detail::has_function_call_operator<T> {};
+
+template <class T>
+inline constexpr bool has_function_call_operator_v = has_function_call_operator<T>::value;
+
+namespace detail {
+
+template <class F, class = void>
+struct invocable_traits {};
+
 template <class R, class... Args>
 struct invocable_traits<R(Args...)> {
   static constexpr invocable_kind kind = invocable_kind::function;
@@ -47,88 +83,121 @@ template <class C, class R>
 struct invocable_traits<R C::*> {
   static constexpr invocable_kind kind = invocable_kind::data_member;
   using return_type = R;
-  using parameters = type_list<>;
+  using parameters = type_list<C&>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...)> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<C&, Args...>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...) noexcept> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<C&, Args...>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...) const> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<const C&, Args...>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...) const noexcept> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<const C&, Args...>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...) volatile> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<volatile C&, Args...>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...) volatile noexcept> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<volatile C&, Args...>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...) const volatile> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<const volatile C&, Args...>;
 };
 
 template <class C, class R, class... Args>
 struct invocable_traits<R (C::*)(Args...) const volatile noexcept> {
   static constexpr invocable_kind kind = invocable_kind::member_function;
   using return_type = R;
-  using parameters = type_list<Args...>;
+  using parameters = type_list<const volatile C&, Args...>;
+};
+
+template <class TypeList>
+struct drop_head {};
+
+template <class T, class... Args>
+struct drop_head<type_list<T, Args...>> {
+  using type = type_list<Args...>;
 };
 
 template <class F>
-struct invocable_traits<F, std::void_t<decltype(&F::operator())>> {
+struct invocable_traits<
+    F, std::enable_if_t<has_function_call_operator_v<F> && has_umambiguous_function_call_operator_v<F>>> {
   static constexpr invocable_kind kind = invocable_kind::function_object;
   using return_type = typename invocable_traits<decltype(&F::operator())>::return_type;
-  using parameters = typename invocable_traits<decltype(&F::operator())>::parameters;
+  using parameters = typename drop_head<typename invocable_traits<decltype(&F::operator())>::parameters>::type;
+};
+
+template <class F>
+struct invocable_traits<
+    F, std::enable_if_t<has_function_call_operator_v<F> && !has_umambiguous_function_call_operator_v<F>>> {
+  static constexpr invocable_kind kind = invocable_kind::overloaded_function_object;
 };
 
-template <std::size_t N, class F, class TypeList>
-struct is_n_ary_function_impl;
+template <class T, class = void>
+struct has_arity : std::false_type {};
 
-template <std::size_t N, class F, class... Args>
-struct is_n_ary_function_impl<N, F, type_list<Args...>> : std::bool_constant<N == sizeof...(Args)> {};
+template <class T>
+struct has_arity<T, std::void_t<decltype(T::arity)>> : std::true_type {};
 
-template <std::size_t N, class F, class = void>
-struct is_n_ary_function;
+template <class F, std::size_t N, class TypeList, class = void>
+struct is_n_ary_function_impl : std::bool_constant<N == TypeList::size> {};
+
+template <class F, std::size_t N, class TypeList>
+struct is_n_ary_function_impl<F, N, TypeList, std::enable_if_t<has_arity<F>::value>>
+    : std::bool_constant<N == TypeList::size> {
+  static_assert(F::arity == TypeList::size, "arity must match parameters' size");
+};
 
-template <std::size_t N, class F>
-struct is_n_ary_function<N, F, std::enable_if_t<invocable_traits<F>::kind == invocable_kind::generic_function_object>>
+template <class F, std::size_t N, class = void>
+struct is_n_ary_function : std::false_type {};
+
+template <class F, std::size_t N>
+struct is_n_ary_function<
+    F, N,
+    std::enable_if_t<invocable_traits<F>::kind == invocable_kind::overloaded_function_object && !has_arity<F>::value>>
     : std::true_type {};
 
-template <std::size_t N, class F>
-struct is_n_ary_function<N, F, std::enable_if_t<invocable_traits<F>::kind != invocable_kind::generic_function_object>>
-    : is_n_ary_function_impl<N, F, typename invocable_traits<F>::parameters> {};
+template <class F, std::size_t N>
+struct is_n_ary_function<
+    F, N,
+    std::enable_if_t<invocable_traits<F>::kind == invocable_kind::overloaded_function_object && has_arity<F>::value>>
+    : std::bool_constant<N == F::arity> {};
+
+template <class F, std::size_t N>
+struct is_n_ary_function<
+    F, N, std::enable_if_t<invocable_traits<F>::kind != invocable_kind::overloaded_function_object>>
+    : is_n_ary_function_impl<F, N, typename invocable_traits<F>::parameters> {};
 
 }  // namespace detail
 
@@ -138,17 +207,20 @@ struct invocable_traits : detail::invocable_traits<F> {};
 template <class F>
 struct invocable_traits<const F> : invocable_traits<F> {};
 
-template <std::size_t N, class F>
-struct is_n_ary_function : detail::is_n_ary_function<N, F> {};
+template <class F, std::size_t N>
+struct is_n_ary_function : detail::is_n_ary_function<F, N> {};
+
+template <class F, std::size_t N>
+struct is_n_ary_function<const F, N> : is_n_ary_function<F, N> {};
 
 template <class F>
-using is_unary_function = is_n_ary_function<1, F>;
+using is_unary_function = is_n_ary_function<F, 1>;
 
 template <class F>
-using is_binary_function = is_n_ary_function<2, F>;
+using is_binary_function = is_n_ary_function<F, 2>;
 
-template <std::size_t N, class F>
-inline constexpr bool is_n_ary_function_v = is_n_ary_function<N, F>::value;
+template <class F, std::size_t N>
+inline constexpr bool is_n_ary_function_v = is_n_ary_function<F, N>::value;
 
 template <class F>
 inline constexpr bool is_unary_function_v = is_unary_function<F>::value;
@@ -156,6 +228,59 @@ inline constexpr bool is_unary_function_v = is_unary_function<F>::value;
 template <class F>
 inline constexpr bool is_binary_function_v = is_binary_function<F>::value;
 
+template <class F, std::size_t N>
+concept n_ary_function = is_n_ary_function_v<F, N>;
+
+template <class F>
+concept unary_function = n_ary_function<F, 1>;
+
+template <class F>
+concept binary_function = n_ary_function<F, 2>;
+
+namespace detail {
+
+template <class F, class... Fs>
+struct compose_impl;
+template <class F>
+struct compose_impl<F> {
+  YK_NO_UNIQUE_ADDRESS F func;
+
+  constexpr compose_impl(F&& f) noexcept : func(std::forward<F>(f)) {}
+
+  template <class... Args>
+  constexpr decltype(auto) operator()(Args&&... args) const noexcept(noexcept(std::is_nothrow_invocable_v<F, Args...>))
+  {
+    return std::invoke(func, std::forward<Args>(args)...);
+  }
+};
+
+template <class F, class G, class... Fs>
+struct compose_impl<F, G, Fs...> {
+  YK_NO_UNIQUE_ADDRESS F func;
+  YK_NO_UNIQUE_ADDRESS compose_impl<G, Fs...> composed;
+
+  constexpr compose_impl(F f, G g, Fs... fs) noexcept : func(std::move(f)), composed(std::move(g), std::move(fs)...) {}
+
+  template <class... Args>
+  constexpr decltype(auto) operator()(Args&&... args) const noexcept(
+      noexcept(std::invoke(func, std::invoke(composed, std::forward<Args>(args)...)))
+  )
+  {
+    return std::invoke(func, std::invoke(composed, std::forward<Args>(args)...));
+  }
+};
+
+template <class F, class... Fs>
+compose_impl(F, Fs...) -> compose_impl<F, Fs...>;
+
+}  // namespace detail
+
+template <class F, class... Fs>
+[[nodiscard]] constexpr auto compose(F&& f, Fs&&... fs) noexcept
+{
+  return detail::compose_impl{std::forward<F>(f), std::forward<Fs>(fs)...};
+}
+
 }  // namespace yk
 
 #endif  // YK_UTIL_FUNCTIONAL_HPP
diff --git a/include/yk/util/type_list.hpp b/include/yk/util/type_list.hpp
index d5958626..88c1bee4 100644
--- a/include/yk/util/type_list.hpp
+++ b/include/yk/util/type_list.hpp
@@ -1,10 +1,14 @@
 #ifndef YK_UTIL_TYPE_LIST_HPP
 #define YK_UTIL_TYPE_LIST_HPP
 
+#include <cstdint>
+
 namespace yk {
 
 template <class... Ts>
-struct type_list {};
+struct type_list {
+  static constexpr std::size_t size = sizeof...(Ts);
+};
 
 }  // namespace yk
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 038ab56f..3f1c0f73 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 3.24)
 include(CTest)
 if(BUILD_TESTING)
   add_executable(yk_util_test
+    compare.cpp
     enum_bitops.cpp
     hash.cpp
     meta.cpp
diff --git a/test/compare.cpp b/test/compare.cpp
new file mode 100644
index 00000000..45b98444
--- /dev/null
+++ b/test/compare.cpp
@@ -0,0 +1,497 @@
+#include "yk/compare.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+#include <compare>
+#include <limits>
+#include <print>
+#include <ranges>
+#include <string>
+#include <type_traits>
+
+BOOST_AUTO_TEST_SUITE(Compare)
+
+BOOST_AUTO_TEST_CASE(compare_then)
+{
+  using namespace yk::compare;
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 4) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 4) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 4) < 0));
+
+  BOOST_TEST((then(1 <=> 2, 4 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 4 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 4 <=> 3) > 0));
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 3) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 4)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 4)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 4)) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then(4 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(4 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(4 <=> 3)) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 3)) == 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 4; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 4; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 4; }) < 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 4 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 4 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 4 <=> 3; }) > 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 3; }) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 4; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 4; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 4; })) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 4 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 3; })) == 0));
+}
+
+BOOST_AUTO_TEST_CASE(extract_and_comparator_then)
+{
+  using namespace yk::comparators;
+
+  struct S {
+    int id;
+    std::string name;
+    double height;
+  };
+
+  // using `then` comparator adaptor
+  {
+    const auto comp = then(then(extract(&S::id), extract(&S::name)), extract(&S::height));
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "bar", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "bar", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{1, "foo", 3.14}) < 0));
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "foo", 3.14}) == 0));
+  }
+
+  // comparator adaptor is pipeable
+  {
+    const auto comp = extract(&S::id) | then(extract(&S::name)) | then(extract(&S::height));
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "bar", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "bar", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{1, "foo", 3.14}) < 0));
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "foo", 3.14}) == 0));
+  }
+
+  // comparator adaptor closure is associative
+  {
+    const auto comp = extract(&S::id) | (then(extract(&S::name)) | then(extract(&S::height)));
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "bar", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "bar", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{1, "foo", 3.14}) < 0));
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "foo", 3.14}) == 0));
+  }
+
+  // short-hand syntax
+  {
+    const yk::compare::comparator auto comp = extract(&S::id) | &S::name | &S::height;
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "bar", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "bar", 3.14}) > 0));
+
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "bar", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "bar", 3.14}, S{1, "foo", 3.14}) < 0));
+
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "foo", 3.14}) < 0));
+    BOOST_TEST((comp(S{2, "foo", 3.14}, S{1, "foo", 3.14}) > 0));
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "foo", 3.14}) == 0));
+  }
+
+  {
+    struct name_extractor {
+      std::string& log;
+
+      name_extractor(std::string& s) : log(s) { log += "NC"; }
+      name_extractor(const name_extractor& other) noexcept : log(other.log) { log += "CC"; }
+      name_extractor(name_extractor&& other) noexcept : log(other.log) { log += "MC"; }
+      ~name_extractor() { log += "D"; }
+      name_extractor& operator=(const name_extractor&) noexcept
+      {
+        log += "CA";
+        return *this;
+      }
+      name_extractor& operator=(name_extractor&&) noexcept
+      {
+        log += "MA";
+        return *this;
+      }
+      const std::string& operator()(const S& s) const { return s.name; }
+    };
+
+    {
+      std::string log;
+      {
+        const yk::compare::comparator auto comp = extract(&S::id) | name_extractor{log};
+        // construction -> NC
+        // move_construction in extract_comparator -> MC
+        // move_construction in then_comparator -> MC
+        BOOST_TEST(log == "NCMCMCDD");
+        BOOST_TEST((comp(S{0, "foo", 3.14}, S{1, "bar", 6.28}) < 0));
+      }
+      BOOST_TEST(log == "NCMCMCDDD");
+    }
+  }
+
+  // composing range adaptor closure
+  {
+    const auto range_adaptor_closure = std::views::reverse | std::ranges::to<std::string>();
+    const auto comp = extract(&S::name) | range_adaptor_closure;
+    BOOST_TEST((comp(S{1, "foo", 3.14}, S{2, "bar", 1.41}) < 0));
+  }
+
+  {
+    const auto comp = std::strong_order | then(std::strong_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::strong_ordering>);
+  }
+  {
+    const auto comp = std::weak_order | then(std::weak_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::weak_ordering>);
+  }
+  {
+    const auto comp = std::partial_order | then(std::partial_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::partial_ordering>);
+  }
+
+  {
+    const auto comp = std::strong_order | then(std::weak_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::weak_ordering>);
+  }
+  {
+    const auto comp = std::weak_order | then(std::strong_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::weak_ordering>);
+  }
+  {
+    const auto comp = std::weak_order | then(std::partial_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::partial_ordering>);
+  }
+  {
+    const auto comp = std::partial_order | then(std::weak_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::partial_ordering>);
+  }
+  {
+    const auto comp = std::strong_order | then(std::partial_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::partial_ordering>);
+  }
+  {
+    const auto comp = std::partial_order | then(std::strong_order);
+    static_assert(std::is_same_v<std::invoke_result_t<decltype(comp), int, int>, std::partial_ordering>);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(NonCopyable)
+{
+  struct int_comparator {
+    int_comparator() = default;
+    int_comparator(const int_comparator&) = delete;
+    int_comparator(int_comparator&&) = default;
+    std::strong_ordering operator()(int a, int b) const noexcept { return a <=> b; }
+  };
+
+  auto comp [[maybe_unused]] = int_comparator{} | yk::comparators::then(int_comparator{});
+  auto closure [[maybe_unused]] = yk::comparators::then(int_comparator{}) | yk::comparators::then(int_comparator{});
+}
+
+namespace {
+
+[[maybe_unused]] std::strong_ordering compare(int x, int y) { return x <=> y; }
+
+}  // namespace
+
+BOOST_AUTO_TEST_CASE(ClosureTypeTraits)
+{
+  {
+    auto comp [[maybe_unused]] = yk::compare::then_comparator{compare, compare};
+    using F = std::strong_ordering(int, int);
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<F&>, yk::compare::wrapper_comparator<F&>>>
+    );
+  }
+
+  {
+    constexpr struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    } function_object;
+    auto comp = yk::compare::then_comparator{function_object, function_object};
+    static_assert(
+        std::is_same_v<
+            decltype(comp), yk::compare::then_comparator<
+                                yk::compare::wrapper_comparator<const fn&>, yk::compare::wrapper_comparator<const fn&>>>
+    );
+  }
+
+  {
+    struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    } function_object;
+    auto comp = yk::compare::then_comparator{function_object, function_object};
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<fn&>, yk::compare::wrapper_comparator<fn&>>>
+    );
+  }
+
+  {
+    struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    };
+    auto comp = yk::compare::then_comparator{fn{}, fn{}};
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<fn>, yk::compare::wrapper_comparator<fn>>>
+    );
+  }
+  ///////////////////////////////////////////////////////////////////////
+  {
+    auto comp [[maybe_unused]] = yk::comparators::then(compare, compare);
+    using F = std::strong_ordering(int, int);
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<F&>, yk::compare::wrapper_comparator<F&>>>
+    );
+  }
+
+  {
+    constexpr struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    } function_object;
+    auto comp = yk::comparators::then(function_object, function_object);
+    static_assert(
+        std::is_same_v<
+            decltype(comp), yk::compare::then_comparator<
+                                yk::compare::wrapper_comparator<const fn&>, yk::compare::wrapper_comparator<const fn&>>>
+    );
+  }
+
+  {
+    struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    } function_object;
+    auto comp = yk::comparators::then(function_object, function_object);
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<fn&>, yk::compare::wrapper_comparator<fn&>>>
+    );
+  }
+
+  {
+    struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    };
+    auto comp = yk::comparators::then(fn{}, fn{});
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<fn>, yk::compare::wrapper_comparator<fn>>>
+    );
+  }
+
+  {
+    auto closure [[maybe_unused]] = yk::comparators::then(&compare);
+    using F = std::strong_ordering(int, int);
+    static_assert(std::is_same_v<decltype(closure), yk::compare::detail::comp_then_closure<F*>>);
+    static_assert(!yk::compare::detail::RangeAdaptorClosure<decltype(closure)>);
+    auto comp = yk::comparators::wrap(&compare) | closure;
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<F*>, yk::compare::wrapper_comparator<F*&>>>
+    );
+  }
+
+  {
+    auto closure [[maybe_unused]] = yk::comparators::then(compare);
+    using F = std::strong_ordering(int, int);
+    static_assert(std::is_same_v<decltype(closure), yk::compare::detail::comp_then_closure<F&>>);
+    static_assert(!yk::compare::detail::RangeAdaptorClosure<decltype(closure)>);
+    auto comp = yk::comparators::wrap(compare) | closure;
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<F&>, yk::compare::wrapper_comparator<F&>>>
+    );
+  }
+
+  {
+    constexpr struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    } function_object;
+    auto closure [[maybe_unused]] = yk::comparators::then(function_object);
+    static_assert(std::is_same_v<decltype(closure), yk::compare::detail::comp_then_closure<const fn&>>);
+    static_assert(!yk::compare::detail::RangeAdaptorClosure<decltype(closure)>);
+    auto comp = function_object | closure;
+    static_assert(
+        std::is_same_v<
+            decltype(comp), yk::compare::then_comparator<
+                                yk::compare::wrapper_comparator<const fn&>, yk::compare::wrapper_comparator<const fn&>>>
+    );
+  }
+  {
+    struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    } function_object;
+    auto closure [[maybe_unused]] = yk::comparators::then(function_object);
+    static_assert(std::is_same_v<decltype(closure), yk::compare::detail::comp_then_closure<fn&>>);
+    static_assert(!yk::compare::detail::RangeAdaptorClosure<decltype(closure)>);
+    auto comp = function_object | closure;
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<fn&>, yk::compare::wrapper_comparator<fn&>>>
+    );
+  }
+  {
+    struct fn {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    } function_object;
+    auto comp = function_object | yk::comparators::then(function_object);
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<fn&>, yk::compare::wrapper_comparator<fn&>>>
+    );
+  }
+  {
+    struct A {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    };
+    struct B {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    };
+    auto closure [[maybe_unused]] = yk::comparators::then(A{});
+    static_assert(std::is_same_v<decltype(closure), yk::compare::detail::comp_then_closure<A>>);
+    static_assert(!yk::compare::detail::RangeAdaptorClosure<decltype(closure)>);
+    auto comp = B{} | closure;
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<B>, yk::compare::wrapper_comparator<A&>>>
+    );
+  }
+  {
+    struct A {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    };
+    struct B {
+      std::strong_ordering operator()(int x, int y) const noexcept { return x <=> y; }
+    };
+    auto comp = B{} | yk::comparators::then(A{});
+    static_assert(
+        std::is_same_v<
+            decltype(comp),
+            yk::compare::then_comparator<yk::compare::wrapper_comparator<B>, yk::compare::wrapper_comparator<A>>>
+    );
+  }
+}
+
+BOOST_AUTO_TEST_CASE(promotion)
+{
+  using namespace yk::comparators;
+
+  // partial | promote(partial)
+  {
+    const auto partial_comparator = [](double a, double b) -> std::partial_ordering { return a <=> b; };
+
+    auto comp = partial_comparator | promote(partial_comparator);
+    BOOST_TEST((comp(3.14, 1.41) == std::partial_ordering::greater));
+    BOOST_TEST((comp(3.14, std::numeric_limits<double>::quiet_NaN()) == std::partial_ordering::unordered));
+  }
+
+  // partial | promote(weak)
+  {
+    const auto partial_comparator = [](double a, double b) -> std::partial_ordering { return a <=> b; };
+    const auto weak_comparator = [](double a, double b) -> std::weak_ordering { return std::weak_order(a, b); };
+
+    auto comp = partial_comparator | promote(weak_comparator);
+    BOOST_TEST((comp(3.14, 1.41) == std::weak_ordering::greater));
+    BOOST_TEST((comp(3.14, std::numeric_limits<double>::quiet_NaN()) == std::weak_ordering::less));
+  }
+
+  // partial | promote(strong)
+  {
+    const auto partial_comparator = [](double a, double b) -> std::partial_ordering { return a <=> b; };
+    const auto strong_comparator = [](double a, double b) -> std::strong_ordering { return std::strong_order(a, b); };
+
+    auto comp = partial_comparator | promote(strong_comparator);
+    BOOST_TEST((comp(3.14, 1.41) == std::strong_ordering::greater));
+    BOOST_TEST((comp(3.14, std::numeric_limits<double>::quiet_NaN()) == std::strong_ordering::less));
+  }
+
+  // weak | promote(weak)
+  {
+    const auto weak_comparator = [](const std::string& a, const std::string& b) -> std::weak_ordering {
+      return a.size() <=> b.size();
+    };
+    auto comp = weak_comparator | promote(weak_comparator);
+    BOOST_TEST((comp("fooo", "bar") == std::weak_ordering::greater));
+    BOOST_TEST((comp("foo", "bar") == std::weak_ordering::equivalent));
+  }
+
+  // weak | promote(strong)
+  {
+    const auto weak_comparator = [](const std::string& a, const std::string& b) -> std::weak_ordering {
+      return a.size() <=> b.size();
+    };
+    const auto strong_comparator = [](const std::string& a, const std::string& b) -> std::strong_ordering {
+      return a <=> b;
+    };
+    auto comp = weak_comparator | promote(strong_comparator);
+    BOOST_TEST((comp("fooo", "bar") == std::strong_ordering::greater));
+    BOOST_TEST((comp("foo", "bar") == std::strong_ordering::greater));
+  }
+
+  // strong | promote(strong)
+  // unsupported; use then() instead.
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/meta.cpp b/test/meta.cpp
index e1580be2..e24ad1bc 100644
--- a/test/meta.cpp
+++ b/test/meta.cpp
@@ -287,65 +287,65 @@ BOOST_AUTO_TEST_CASE(FunctionTraits)
     using F = decltype(&S::unary_member_function);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::unary_member_function_c);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::unary_member_function_v);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<volatile S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::unary_member_function_cv);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const volatile S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::unary_member_function_n);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::unary_member_function_cn);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::unary_member_function_vn);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<volatile S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::unary_member_function_cvn);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float>>);
-    static_assert(yk::is_unary_function_v<F>);
-    static_assert(!yk::is_binary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const volatile S&, float>>);
+    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(yk::is_binary_function_v<F>);
   }
 
   {
@@ -376,79 +376,79 @@ BOOST_AUTO_TEST_CASE(FunctionTraits)
     using F = decltype(&S::binary_member_function);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::binary_member_function_c);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::binary_member_function_v);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<volatile S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::binary_member_function_cv);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const volatile S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::binary_member_function_n);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::binary_member_function_cn);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::binary_member_function_vn);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<volatile S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
   {
     using F = decltype(&S::binary_member_function_cvn);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::member_function);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<const volatile S&, float, double>>);
     static_assert(!yk::is_unary_function_v<F>);
-    static_assert(yk::is_binary_function_v<F>);
+    static_assert(!yk::is_binary_function_v<F>);
   }
 
   {
     using F = decltype(&S::data_member);
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::data_member);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
-    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<>>);
-    static_assert(!yk::is_unary_function_v<F>);
+    static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<S&>>);
+    static_assert(yk::is_unary_function_v<F>);
     static_assert(!yk::is_binary_function_v<F>);
   }
 
   {
     const auto lambda = [](float, double) -> int { return 42; };
-    using F = decltype(lambda);
+    using F = std::decay_t<decltype(lambda)>;
     static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::function_object);
     static_assert(std::is_same_v<yk::invocable_traits<F>::return_type, int>);
     static_assert(std::is_same_v<yk::invocable_traits<F>::parameters, yk::type_list<float, double>>);
@@ -458,19 +458,43 @@ BOOST_AUTO_TEST_CASE(FunctionTraits)
 
   {
     const auto generic_lambda = [](auto) {};
-    using F = decltype(generic_lambda);
-    static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::generic_function_object);
+    using F = std::decay_t<decltype(generic_lambda)>;
+    static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::overloaded_function_object);
     static_assert(yk::is_unary_function_v<F>);   // fallback
     static_assert(yk::is_binary_function_v<F>);  // fallback
   }
 
   {
     const auto generic_lambda = [](auto, auto) {};
-    using F = decltype(generic_lambda);
-    static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::generic_function_object);
+    using F = std::decay_t<decltype(generic_lambda)>;
+    static_assert(yk::invocable_traits<F>::kind == yk::invocable_kind::overloaded_function_object);
     static_assert(yk::is_unary_function_v<F>);   // fallback
     static_assert(yk::is_binary_function_v<F>);  // fallback
   }
 }
 
+BOOST_AUTO_TEST_CASE(Compose)
+{
+  const auto f = [](int x) -> std::string { return std::to_string(x); };
+  const auto g = [](std::string s) -> std::size_t { return s.size(); };
+
+  BOOST_TEST(yk::compose(g, f)(42) == 2);
+}
+
+BOOST_AUTO_TEST_CASE(HasFunctionCallOperator)
+{
+  {
+    struct S {};
+    static_assert(!yk::has_function_call_operator_v<S>);
+  }
+  {
+    struct S {
+      void operator()() {}
+    };
+    static_assert(yk::has_function_call_operator_v<S>);
+  }
+  static_assert(yk::has_function_call_operator_v<decltype([]{})>);
+  static_assert(yk::has_function_call_operator_v<decltype([](auto){})>);
+}
+
 BOOST_AUTO_TEST_SUITE_END()


Reviews:
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T08:24:50Z
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T08:26:01Z
user: login: yaito3014
state: COMMENTED
author_association: OWNER
submitted_at: 2025-05-09T08:47:25Z
user: login: yaito3014
state: COMMENTED
author_association: OWNER
submitted_at: 2025-05-09T08:47:47Z
user: login: saki7
body: I think the current implementation is ok, as long as the issues I mentioned is fixed.

However, I should note that we need
- support on composing `std::views::transform`
- support handling of rvalues that is generated on-the-fly during the comparison, as in `&my_data::code | [](int code) { return code + 42; }`
- unit tests for those functionalities

Above features are must-have on real life applications.
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T08:55:03Z
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T09:15:28Z
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T09:20:39Z
user: login: yaito3014
state: COMMENTED
author_association: OWNER
submitted_at: 2025-05-09T15:41:14Z
user: login: yaito3014
state: COMMENTED
author_association: OWNER
submitted_at: 2025-05-09T15:46:04Z
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T21:16:59Z
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T21:21:36Z
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-09T21:22:06Z
user: login: saki7
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-13T03:20:50Z
user: login: saki7
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-05-19T21:23:19Z
user: login: saki7
body: TODO: add `nodiscard` to many entities.

Note that it might be appropriate for some classes to have the attribute on their class name itself (i.e. not just on their member functions), because discarding comparator instances is likely a mistake.

It's up to the PR author to determine how the attribute can be applied.
state: CHANGES_REQUESTED
author_association: COLLABORATOR
submitted_at: 2025-05-19T22:58:39Z

Review comments:
diff_hunk: @@ -0,0 +1,126 @@
+#include "yk/compare/comparator.hpp"
+#include "yk/compare/then.hpp"
path: test/compare.cpp
user: login: saki7
body: We should provide a mega header that includes these "main" features, so that users using yk::compare::* can use this just by `#include "yk/compare.hpp"`, similar as `#include <compare>`
created_at: 2025-05-09T08:24:50Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,126 @@
+#include "yk/compare/comparator.hpp"
+#include "yk/compare/then.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+#include <compare>
+
+BOOST_AUTO_TEST_SUITE(Compare)
+
+BOOST_AUTO_TEST_CASE(compare_then)
+{
+  using namespace yk::compare;
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 4) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 4) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 4) < 0));
+
+  BOOST_TEST((then(1 <=> 2, 4 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 4 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 4 <=> 3) > 0));
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 3) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 4)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 4)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 4)) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then(4 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(4 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(4 <=> 3)) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 3)) == 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 4; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 4; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 4; }) < 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 4 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 4 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 4 <=> 3; }) > 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 3; }) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 4; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 4; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 4; })) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 4 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 3; })) == 0));
+}
+
+BOOST_AUTO_TEST_CASE(extract_and_comparator_then)
+{
+  using namespace yk::comparators;
+
+  struct S {
+    int id;
+    std::string name;
+    double height;
+  };
+
+  {
+    const auto comp = extract(&S::id) | then(extract(&S::name)) | then(extract(&S::height));
path: test/compare.cpp
user: login: saki7
body: We need tests for validating the three-way comparison category is correctly synthesized and propagated, even if multiple categories are mixed together.
created_at: 2025-05-09T08:26:01Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,126 @@
+#include "yk/compare/comparator.hpp"
+#include "yk/compare/then.hpp"
path: test/compare.cpp
user: login: yaito3014
body: added `yk/compare.hpp`
created_at: 2025-05-09T08:47:25Z
author_association: OWNER
diff_hunk: @@ -0,0 +1,126 @@
+#include "yk/compare/comparator.hpp"
+#include "yk/compare/then.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+#include <compare>
+
+BOOST_AUTO_TEST_SUITE(Compare)
+
+BOOST_AUTO_TEST_CASE(compare_then)
+{
+  using namespace yk::compare;
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 4) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 4) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 4) < 0));
+
+  BOOST_TEST((then(1 <=> 2, 4 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 4 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 4 <=> 3) > 0));
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 3) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 4)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 4)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 4)) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then(4 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(4 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(4 <=> 3)) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 3)) == 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 4; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 4; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 4; }) < 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 4 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 4 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 4 <=> 3; }) > 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 3; }) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 4; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 4; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 4; })) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 4 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 3; })) == 0));
+}
+
+BOOST_AUTO_TEST_CASE(extract_and_comparator_then)
+{
+  using namespace yk::comparators;
+
+  struct S {
+    int id;
+    std::string name;
+    double height;
+  };
+
+  {
+    const auto comp = extract(&S::id) | then(extract(&S::name)) | then(extract(&S::height));
path: test/compare.cpp
user: login: yaito3014
body: added `common_ordering` meta function and tests
created_at: 2025-05-09T08:47:47Z
author_association: OWNER
diff_hunk: @@ -23,7 +23,7 @@ template <class Comp>
 inline constexpr bool enable_comparator = std::derived_from<Comp, comparator_interface>;
 
 template <class Comp>
-concept comparator = yk::binary_function<Comp> && enable_comparator<Comp>;
+concept comparator = yk::binary_function<Comp> && std::movable<Comp> && enable_comparator<Comp>;
path: include/yk/compare/comparator.hpp
user: login: saki7
body: I'm not sure, does this subsume copyable-but-not-movable functors?
created_at: 2025-05-09T09:15:28Z
author_association: COLLABORATOR
diff_hunk: @@ -138,6 +138,24 @@ BOOST_AUTO_TEST_CASE(extract_and_comparator_then)
     BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "foo", 3.14}) == 0));
   }
 
+  // using lambda
+  {
+    const yk::compare::comparator auto comp =
+        extract(&S::id) | [](const S& s) { return s.name; } | [](const auto& s) { return s.height; };
path: test/compare.cpp
user: login: saki7
body: In order to *prove* this works, we need to test the rvalues are preserved and not destroyed on the comparison. We need a custom type for tracking lifetime ~~(i.e. counts up on constructor, counts down on destructor)~~. Existing types such as `int` and `std::string` can not prove that they are not destroyed; since the actual behavior of UB can not be determinably observed as long as we are using non-trackable types.
created_at: 2025-05-09T09:20:39Z
author_association: COLLABORATOR
diff_hunk: @@ -23,7 +23,7 @@ template <class Comp>
 inline constexpr bool enable_comparator = std::derived_from<Comp, comparator_interface>;
 
 template <class Comp>
-concept comparator = yk::binary_function<Comp> && enable_comparator<Comp>;
+concept comparator = yk::binary_function<Comp> && std::movable<Comp> && enable_comparator<Comp>;
path: include/yk/compare/comparator.hpp
user: login: yaito3014
body: no. any use case of copyable-but-not-movable class?
```cpp
template <bool Copy, bool Move>
struct S {
  S() = default;
  S(const S&) requires   Copy  = default;
  S(const S&) requires (!Copy) = delete;
  S(S&&) requires   Move  = default;
  S(S&&) requires (!Move) = delete;
  S& operator=(const S&) requires   Copy  = default;
  S& operator=(const S&) requires (!Copy) = delete;
  S& operator=(S&&) requires   Move  = default;
  S& operator=(S&&) requires (!Move) = delete;
};

template <class T>
constexpr int func(T&&) { return 1; }

template <class T>
  requires std::movable<std::remove_cvref_t<T>>
constexpr int func(T&&) { return 2; }

template <class T>
  requires std::copyable<std::remove_cvref_t<T>>
constexpr int func(T&&) { return 3; }

static_assert(func(S< true, true>{}) == 3);
static_assert(func(S<false, true>{}) == 2);
static_assert(func(S< true,false>{}) == 1);
static_assert(func(S<false,false>{}) == 1);
```
created_at: 2025-05-09T15:41:13Z
author_association: OWNER
diff_hunk: @@ -0,0 +1,126 @@
+#include "yk/compare/comparator.hpp"
+#include "yk/compare/then.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+#include <compare>
+
+BOOST_AUTO_TEST_SUITE(Compare)
+
+BOOST_AUTO_TEST_CASE(compare_then)
+{
+  using namespace yk::compare;
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 4) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 4) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 4) < 0));
+
+  BOOST_TEST((then(1 <=> 2, 4 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 4 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 4 <=> 3) > 0));
+
+  BOOST_TEST((then(1 <=> 2, 3 <=> 3) < 0));
+  BOOST_TEST((then(2 <=> 1, 3 <=> 3) > 0));
+  BOOST_TEST((then(1 <=> 1, 3 <=> 3) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 4)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 4)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 4)) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then(4 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(4 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(4 <=> 3)) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then(3 <=> 3)) < 0));
+  BOOST_TEST((((2 <=> 1) | then(3 <=> 3)) > 0));
+  BOOST_TEST((((1 <=> 1) | then(3 <=> 3)) == 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 4; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 4; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 4; }) < 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 4 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 4 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 4 <=> 3; }) > 0));
+
+  BOOST_TEST((then_with(1 <=> 2, [] { return 3 <=> 3; }) < 0));
+  BOOST_TEST((then_with(2 <=> 1, [] { return 3 <=> 3; }) > 0));
+  BOOST_TEST((then_with(1 <=> 1, [] { return 3 <=> 3; }) == 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 4; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 4; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 4; })) < 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 4 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 4 <=> 3; })) > 0));
+
+  BOOST_TEST((((1 <=> 2) | then_with([] { return 3 <=> 3; })) < 0));
+  BOOST_TEST((((2 <=> 1) | then_with([] { return 3 <=> 3; })) > 0));
+  BOOST_TEST((((1 <=> 1) | then_with([] { return 3 <=> 3; })) == 0));
+}
+
+BOOST_AUTO_TEST_CASE(extract_and_comparator_then)
+{
+  using namespace yk::comparators;
+
+  struct S {
+    int id;
+    std::string name;
+    double height;
+  };
+
+  {
+    const auto comp = extract(&S::id) | then(extract(&S::name)) | then(extract(&S::height));
path: test/compare.cpp
user: login: yaito3014
body: there is `std::common_comparison_category`... I didn't remember it.
created_at: 2025-05-09T15:46:04Z
author_association: OWNER
diff_hunk: @@ -20,18 +20,12 @@ namespace compare {
 namespace detail {
 
 // is there more better way to detect range adaptor closure? idk
-template <class T>
-inline constexpr bool is_range_adaptor_closure_v =
-#if defined(__GLIBCXX__)
-    std::views::__adaptor::__is_range_adaptor_closure<T>
-#elif defined(_LIBCPP_VERSION)
-    std::ranges::_RangeAdaptorClosure<T>
-#elif defined(_MSC_VER)
-    std::ranges::_Pipe::_Range_adaptor_closure_object<T>
-#else
-    false
-#endif
-    ;
+template <class Closure>
+concept RangeAdaptorClosure = requires(Closure closure) {
+  closure(std::views::empty<int>);
path: include/yk/compare/comparator.hpp
user: login: saki7
body: Instantiating the specific type `std::views::empty<int>` for a more generic concept seems not elegant. I think we should define a minimal class that models a range, and use it solely as our internal type.

```cpp
namespace detail {
struct just_a_range : ... { ... }; // For example. You can make a decision on the class name; choose it wisely.
}
```
created_at: 2025-05-09T21:16:59Z
author_association: COLLABORATOR
diff_hunk: @@ -138,6 +138,24 @@ BOOST_AUTO_TEST_CASE(extract_and_comparator_then)
     BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "foo", 3.14}) == 0));
   }
 
+  // using lambda
+  {
+    const yk::compare::comparator auto comp =
+        extract(&S::id) | [](const S& s) { return s.name; } | [](const auto& s) { return s.height; };
path: test/compare.cpp
user: login: saki7
body: Even after the pair programming session on this morning, I'm not sure how we can test the lifetime expiration. We have done it on a meta-programming level, but we still need to test it also on a runtime level.
created_at: 2025-05-09T21:21:36Z
author_association: COLLABORATOR
diff_hunk: @@ -138,6 +138,24 @@ BOOST_AUTO_TEST_CASE(extract_and_comparator_then)
     BOOST_TEST((comp(S{1, "foo", 3.14}, S{1, "foo", 3.14}) == 0));
   }
 
+  // using lambda
+  {
+    const yk::compare::comparator auto comp =
+        extract(&S::id) | [](const S& s) { return s.name; } | [](const auto& s) { return s.height; };
path: test/compare.cpp
user: login: saki7
body: ASan was not working, at least.
created_at: 2025-05-09T21:22:06Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,23 @@
+#ifndef YK_BOOLEAN_TESTABLE_HPP
+#define YK_BOOLEAN_TESTABLE_HPP
+
+#include <concepts>
+#include <utility>
+
+namespace yk {
+
+namespace detail {
+
+template <class T>
+concept boolean_testable_impl = std::convertible_to<T, bool>;
+
+}  // namespace detail
+
+template <class T>
+concept boolean_testable = detail::boolean_testable_impl<T> && requires(T&& t) {
+  { !std::forward<T>(t) } -> detail::boolean_testable_impl;
path: include/yk/boolean_testable.hpp
user: login: saki7
body: `static_cast` is sufficient here.

MSVC STL:

```cpp
template <class _Ty>
concept _Boolean_testable_impl = convertible_to<_Ty, bool>;

template <class _Ty>
concept _Boolean_testable = _Boolean_testable_impl<_Ty> && requires(_Ty&& __t) {
    { !static_cast<_Ty&&>(__t) } -> _Boolean_testable_impl;
};
```
created_at: 2025-05-13T03:20:49Z
author_association: COLLABORATOR

PR comments:
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T08:09:21Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921101#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921124#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921094#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921091#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921137#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921111#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921090#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921093#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921106#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921112#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921088#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921077#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921136#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921143#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921127#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901715302/job/41854921125#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T08:20:14Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565932#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565913#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565883#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565901#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565914#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565950#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565887#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565899#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565907#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565922#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565894#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565900#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565933#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565938#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565934#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14901917906/job/41855565912#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T10:16:42Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360452#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360461#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360425#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360450#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360464#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360446#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360440#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360442#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360483#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360470#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360412#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360456#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360472#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360466#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360479#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904073244/job/41862360475#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T11:05:11Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013270#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013268#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013240#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013253#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013281#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013262#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013246#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013255#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013275#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013271#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013238#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013259#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013291#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013303#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013272#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14904924294/job/41865013280#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T11:22:43Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002454#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002446#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002404#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002429#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002486#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002458#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002418#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002416#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002439#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002462#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002421#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002414#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002465#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002491#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002466#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14905239636/job/41866002492#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T18:07:11Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796780#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796781#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796736#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796792#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796771#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796763#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796750#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796764#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796769#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796778#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796728#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796773#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796772#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796783#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796770#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913012651/job/41891796775#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: yaito3014
created_at: 2025-05-08T18:23:03Z
body: pointer to data member can be considered as unary function actually.
author_association: OWNER
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T18:25:11Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859111#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859137#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859102#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859120#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859114#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859132#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859127#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859105#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859100#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859097#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859118#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859101#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859139#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859131#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859152#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913333174/job/41892859144#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-08T18:34:55Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443520#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443495#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443498#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443526#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443552#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443514#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443479#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443493#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443528#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443521#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443512#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443557#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443517#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443536#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443508#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14913517311/job/41893443515#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T07:56:39Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237400#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237391#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237379#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237376#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237393#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237410#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237370#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237375#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237377#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237389#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237372#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237371#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237420#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237394#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237390#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924193455/job/41925237385#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T08:06:09Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712805#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712813#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712764#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712791#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712858#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712815#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712777#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712782#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712780#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712823#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712776#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712774#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712833#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712828#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712817#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14924343757/job/41925712876#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: yaito3014
created_at: 2025-05-09T08:49:36Z
body: テストの通らないコードをプッシュしないでください！
すいません
author_association: OWNER
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T08:54:37Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395053#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395052#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928394999#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395039#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395031#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395027#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395000#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395029#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395033#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395055#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928394988#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395034#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395023#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395062#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395032#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925195800/job/41928395035#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T09:09:58Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253713#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253685#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253634#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253679#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253705#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253691#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253653#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253667#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253671#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253681#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253627#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253664#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253689#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253714#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253700#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14925468237/job/41929253709#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T12:29:19Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927496#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927544#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927524#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927492#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927521#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927530#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927467#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927471#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927503#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927532#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927460#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927482#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927531#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927542#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927528#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14928874827/job/41939927511#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T14:11:26Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234940#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234960#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234919#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234942#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234975#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234943#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234924#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234959#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234941#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234962#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234926#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234938#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234987#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234990#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234956#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14930780455/job/41946234973#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: saki7
created_at: 2025-05-09T14:16:13Z
body: > テストの通らないコードをプッシュしないでください！
> すいません

It is perfectly fine to push untested code in a PR, as we're running super sophisticated test matrix making it a nice playground to test your code :)
author_association: COLLABORATOR
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T14:35:41Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838240#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838257#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838229#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838218#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838248#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838238#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838215#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838222#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838225#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838236#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838208#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838219#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838272#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838290#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838249#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14931254614/job/41947838261#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T21:16:02Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244452#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244422#step:12:1">⚠️warning</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244407#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244411#step:12:1">⚠️warning</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244429#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244420#step:12:1">⚠️warning</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244406#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244421#step:12:1">⚠️warning</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244430#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244432#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244404#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244402#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244437#step:13:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244435#step:13:1">⚠️warning</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244436#step:13:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937808375/job/41969244442#step:13:1">⚠️warning</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-09T21:25:52Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662631#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662642#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662627#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662623#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662645#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662651#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662625#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662632#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662630#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662640#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662619#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662633#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662652#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662657#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662663#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14937945888/job/41969662661#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-11T12:58:21Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703764#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703775#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703760#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703767#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703771#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703778#step:12:1">⚠️warning</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703765#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703769#step:12:1">⚠️warning</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703774#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703777#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703766#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703763#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703782#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703783#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703781#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14955992368/job/42011703780#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-11T13:21:26Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163383#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163382#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163371#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163366#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163385#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163381#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163369#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163376#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163380#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163386#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163374#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163367#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163390#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163377#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163384#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956189292/job/42012163389#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-11T13:34:58Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411694#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411698#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411682#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411696#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411695#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411705#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411697#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411691#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411700#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411720#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411684#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411688#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411706#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411713#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411704#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14956300451/job/42012411710#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-12T06:33:03Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254827#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254826#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254793#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254797#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254807#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254816#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254795#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254810#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254820#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254811#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254812#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254798#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254833#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254828#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254834#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965359797/job/42034254836#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-12T06:39:42Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535007#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535053#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034534996#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535015#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535040#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535044#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535016#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535012#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535008#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535028#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034534999#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535010#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535029#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535052#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535037#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14965459348/job/42034535043#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-12T16:12:36Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203893#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203891#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203870#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203880#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203871#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203878#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203875#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203872#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203882#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203879#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203859#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203874#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203890#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203898#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203889#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977133153/job/42072203894#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-12T16:20:21Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726348#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726359#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726318#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726331#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726334#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726372#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726312#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726315#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726322#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726321#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726313#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726325#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726374#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726353#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726350#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14977292114/job/42072726357#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-13T02:09:21Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495805#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495811#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495787#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495798#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495808#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495810#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495800#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495799#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495803#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495812#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495784#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495796#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495815#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495816#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495813#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14986561674/job/42101495826#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-13T04:25:55Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826277#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826260#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826246#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826245#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826284#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826269#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826247#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826248#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826271#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826265#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826244#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826250#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826268#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826266#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826272#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988122312/job/42105826276#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-13T04:37:17Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176644#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176662#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176628#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176655#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176649#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176659#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176633#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176651#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176650#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176656#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176625#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176636#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176660#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176668#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176664#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/14988252329/job/42106176658#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: saki7
created_at: 2025-05-15T05:24:47Z
body: If my understanding is correct, the only remaining task is https://github.com/yaito3014/yk_util/pull/69#pullrequestreview-2827653346
author_association: COLLABORATOR
user: login: cppwarningnotifier[bot]
created_at: 2025-05-15T07:14:15Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722132#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722154#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722117#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722125#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722146#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722171#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722143#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722135#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722130#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722144#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722116#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722175#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722173#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722177#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722161#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15038856196/job/42265722205#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-15T10:36:39Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144163#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144170#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144159#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144182#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144168#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144174#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144132#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144207#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144188#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144205#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144181#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144164#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144197#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144193#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144201#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15042760122/job/42278144183#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: saki7
created_at: 2025-05-16T05:55:52Z
body: https://github.com/yaito3014/yk_util/pull/69#issuecomment-2882480612

I have noticed that we have one another very important task: performance analysis.

We should check that `yk::extract`-based approach is at least equivalently fast as `std::tie`-based approach. Otherwise we must admit that we miserably failed, because performance is everything for comparisons that can be called millions of times in real life applications.

In order to check this, I must investigate the actual assembly code generated by above 2 approaches and compare them. I'm going to do this investigation now.
author_association: COLLABORATOR
user: login: saki7
created_at: 2025-05-16T07:48:11Z
body: > In order to check this, I must investigate the actual assembly code generated by above 2 approaches and compare them

<https://godbolt.org/z/W596brW6h>

I think the optimizations work very well across all 3 major compilers. On GCC/Clang, yk's approach generates assembly identical to `std::tie`. There's a slight difference on MSVC where it chooses the different asm operation order on synthesizing multiple components, but it seems negligible.

author_association: COLLABORATOR
user: login: saki7
created_at: 2025-05-16T08:15:12Z
body: Now I have this feeling: Why is this feature not included in the C++ standard? 🤔 It's so ****ing fundamental, and we've proved that it can be implemented in zero-overhead manner. This should be definitely included in yk_util.
author_association: COLLABORATOR
user: login: cppwarningnotifier[bot]
created_at: 2025-05-19T21:46:20Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814971#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814996#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814955#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814980#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814974#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814967#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814972#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814965#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814981#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814985#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814963#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814970#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814976#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814995#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814984#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15123779212/job/42511814979#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: saki7
created_at: 2025-05-19T22:00:24Z
body: I want `promote`!

```cpp
using namespace yk::comparators;

auto const comp =
    [](LoadoutData const& a, LoadoutData const& b) {  // weak
        return ArmorDNATraits<>::compare{}(a.dna, b.dna);
    } |
    then([](LoadoutData const& a, LoadoutData const& b) { // weak
        if (a.loadout.charm) {
            if (!b.loadout.charm) return std::weak_ordering::less;
        } else if (b.loadout.charm) {
            return std::weak_ordering::greater;
        }
        return std::weak_ordering::equivalent;
    }) |
    promote([](LoadoutData const& a, LoadoutData const& b) {
        return ArmorDNATraits<>::compare_skill_id{}(a.dna, b.dna); // strong
    });

return comp(*this, other); // strong
```
author_association: COLLABORATOR
user: login: cppwarningnotifier[bot]
created_at: 2025-05-20T00:28:36Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002788#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002798#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002755#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002779#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002800#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002791#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002764#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002783#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002789#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002797#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002761#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002765#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002806#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002805#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002807#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15125981086/job/42518002801#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-20T01:39:53Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422900#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422923#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422895#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422902#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422907#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422933#step:12:1">⚠️warning</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422890#step:12:1">⚠️warning</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422910#step:12:1">⚠️warning</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422908#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422903#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422901#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422891#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422926#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422913#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422912#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15126874024/job/42520422916#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-20T02:01:48Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163576#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163578#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163563#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163575#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163582#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163586#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163580#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163583#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163573#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163581#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163577#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163569#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163587#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163589#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163584#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127146044/job/42521163579#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-20T02:10:59Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448780#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448791#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448761#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448777#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448781#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448801#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448765#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448785#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448850#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448800#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448776#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448782#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448784#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448779#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448787#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15127249699/job/42521448792#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T10:53:37Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066704#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066718#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066671#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066711#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066713#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066726#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066681#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066685#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066716#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066710#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066677#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066684#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066728#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066731#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066722#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184632311/job/42702066739#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T11:02:21Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592449#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592487#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592452#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592471#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592468#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592508#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592461#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592451#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592483#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592480#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592450#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592464#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592514#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592511#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592494#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15184795250/job/42702592500#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T11:37:47Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704788005#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704788018#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787983#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787977#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787986#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704788021#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787987#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787992#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787985#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787989#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787973#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787980#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704788027#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704788016#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704788004#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185486146/job/42704787996#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T12:03:28Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372822#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372868#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372821#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372840#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372833#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372857#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372815#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372838#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372842#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372862#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372816#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372819#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372866#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372860#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372846#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15185979278/job/42706372852#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T12:36:34Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639252#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639275#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639209#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639240#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639249#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639245#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639208#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639233#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639257#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639256#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639226#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639219#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639287#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639283#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639265#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15186662873/job/42708639253#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T13:27:56Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413776#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413813#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413777#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413834#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413806#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413812#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413781#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413786#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413787#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413814#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413763#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413799#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413810#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413809#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413792#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187781709/job/42712413795#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T13:33:25Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838146#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838156#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838105#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838130#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838254#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838176#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838133#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838118#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838123#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838147#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838100#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838122#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838230#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838244#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838199#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15187905648/job/42712838174#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T14:13:19Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038444#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038500#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038459#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038501#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038462#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038490#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038466#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038479#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038445#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038498#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038512#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038457#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038548#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038533#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038485#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15188832948/job/42716038539#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T14:41:24Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334591#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334632#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334602#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334580#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334638#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334636#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334585#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334612#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334579#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334635#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334583#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334613#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334637#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334658#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334617#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189507421/job/42718334641#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: cppwarningnotifier[bot]
created_at: 2025-05-22T14:44:41Z
body: 
  <table>
    <thead>
      <th colspan=4>Environment</th>
      <th>C++23</th>
      <th>C++26</th>
    </thead>
    <tbody>
    <tr><th rowspan="6">ubuntu24.04</th><th rowspan="4">Clang</th><th rowspan="2">19</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594413#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594412#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594340#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594356#step:12:1">✅success</a></td></tr><tr><th rowspan="2">20</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594367#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594395#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594380#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594375#step:12:1">✅success</a></td></tr><tr><th rowspan="2">GCC</th><th rowspan="2">14</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594390#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594400#step:12:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594328#step:12:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594350#step:12:1">✅success</a></td></tr><tr><th rowspan="2">windows2022</th><th rowspan="2">MSVC</th><th rowspan="2">v142</th><th>Debug</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594479#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594456#step:13:1">✅success</a></td></tr><tr><th>Release</th><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594447#step:13:1">✅success</a></td><td><a href="https://github.com/yaito3014/yk_util/actions/runs/15189581292/job/42718594472#step:13:1">✅success</a></td>
    </tbody>
  </table>
  
author_association: NONE
user: login: saki7
created_at: 2025-05-22T14:48:47Z
body: 𝙎𝙪𝙥𝙚𝙧 𝙏𝙝𝙖𝙣𝙠𝙨
author_association: COLLABORATOR