compare : C++26対応としてtype_orderを追加 (close #1506)

Author: faithandbrave

lang/cpp26.md

@@ -512,7 +512,7 @@ C++26とは、2026年中に改訂される予定の、C++バージョンの通
 - [`<memory>`](/reference/memory.md)に、ポインタのアライメントを判定する[`std::is_sufficiently_aligned()`](/reference/memory/is_sufficiently_aligned.md)関数を追加。
 - [`<utility>`](/reference/utility.md)に、タイムトラベル最適化を抑止するための観測可能ポイントとして[`std::observable_checkpoint()`](/reference/utility/observable_checkpoint.md)を追加
 - [`std::exception_ptr`](/reference/exception/exception_ptr.md)を指定した例外型にキャストする[`std::exception_ptr_cast()`](/reference/exception/exception_ptr_cast.md)関数を追加
-- [`<compare>`](/reference/compare.md)に、型の順序を取得する[`std::type_order`](/reference/compare/type_order.md.nolink)クラスを追加
+- [`<compare>`](/reference/compare.md)に、型の順序を取得する[`std::type_order`](/reference/compare/type_order.md)クラスを追加
 
 
 ### デバッグ

lang/cpp26/feature_test_macros.md

@@ -158,7 +158,7 @@
 |`__cpp_lib_to_string`|`202306L`|[`std::to_string`](/reference/string/to_string.md)の変換結果を`sprintf()`ベースから`std::format()`ベースに変更|[`<string>`](/reference/string.md)|
 |`__cpp_lib_trivially_relocatable`|`202502L`|トリビアルな再配置|[`<memory>`](/reference/memory.md), [`<type_traits>`](/reference/type_traits.md)|
 |`__cpp_lib_tuple_like`|`202311L`|[`std::complex`](/reference/complex/complex.md)にタプルインタフェースの特殊化を追加|[`<utility>`](/reference/utility.md), [`<tuple>`](/reference/tuple.md), [`<map>`](/reference/map.md), [`<unordered_map>`](/reference/unordered_map.md)|
-|`__cpp_lib_type_order`|`202506L`|[`std::type_info::before`](/reference/typeinfo/type_info/before.md)のconstexpr化|[`<compare>`](/reference/compare.md)|
+|`__cpp_lib_type_order`|`202506L`|[`std::type_order`](/reference/compare/type_order.md)を追加|[`<compare>`](/reference/compare.md)|
 |`__cpp_lib_variant`|`202306L`|[`std::variant`](/reference/variant/variant.md)クラスに、メンバ関数版の[`visit()`](/reference/variant/variant/visit.md)を追加|[`<variant>`](/reference/variant.md)|
 
 実装依存のマクロ。

reference/compare.md

@@ -35,6 +35,13 @@
 | [`common_comparison_category`](compare/common_comparison_category.md) | 指定された全ての型の共通比較カテゴリ型を求める | C++20          |
 | [`compare_three_way_result`](compare/compare_three_way_result.md)     | 指定された型の間での`<=>`による比較結果の型を求める          | C++20          |
 
+
+## 型の順序
+
+| 名前                                  | 説明                                              | 対応バージョン |
+| ------------------------------------- | ------------------------------------------------- | -------------- |
+| [`type_order`](compare/type_order.md) | 2つの型の間の実装定義の全順序を取得する (class template) | C++26          |
+
 ## コンセプト
 
 | 名前                                                                        | 説明                                                                                        | 対応バージョン |

reference/compare/type_order.md

@@ -0,0 +1,94 @@
+# type_order
+* compare[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class T, class U>
+  struct type_order {
+    static constexpr strong_ordering value = TYPE-ORDER(T, U); // 説明専用
+
+    using value_type = strong_ordering;
+
+    constexpr operator value_type() const noexcept { return value; }
+    constexpr value_type operator()() const noexcept { return value; }
+  };
+
+  template <class T, class U>
+  constexpr strong_ordering type_order_v = type_order<T, U>::value;
+}
+```
+* strong_ordering[link strong_ordering.md]
+
+## 概要
+2つの型`T`と`U`の間の、コンパイル時の全順序を取得する。
+
+これを使用することにより、型リストの正規化（例えば`typeset<A, B>`と`typeset<B, A>`を同じ型として扱う）や、複数の翻訳単位にわたって型の順序を一貫させることができる。
+
+
+## 効果
+`TYPE-ORDER(T, U)`は実装定義であり、すべての型に対する全順序を表す。以下の保証がある：
+
+- 反射律: `type_order_v<T, T>`は[`strong_ordering::equal`](strong_ordering.md)
+- 反対称律: `type_order_v<T, U>`が`less`であれば、`type_order_v<U, T>`は`greater`
+- 推移律: 通常の推移性
+- CV修飾や参照修飾の異なる型は別個の型として区別される（例: `int`、`const int`、`int&`は順序として`equal`ではない）
+
+実装は、型の同名異シグニチャ化に使用される既存のABIマングリング基盤を利用することが想定される。実装は推奨事項として、テンプレートの第i引数のみが異なる場合に、`X<...,T,...>`と`X<...,U,...>`の順序が`T`と`U`の順序と一致するように再帰的な一貫性を提供することができる。
+
+
+## 備考
+- C++26より前は、型の全順序を得るためには`__PRETTY_FUNCTION__`等の処理系固有の機能を使うか、`typeid`を実行時に比較する必要があった。`type_order`は、コンパイル時に取得できる、実装定義であるが安定した型の全順序を提供する
+- このクラスは不完全型に対しても動作する
+- 実装定義の全順序の具体的な順番には依存すべきではないが、同じ実装のなかでは翻訳単位の境界をまたいでも安定する
+
+
+## 例
+```cpp example
+#include <compare>
+#include <type_traits>
+
+struct A {};
+struct B {};
+
+int main() {
+  // 同じ型同士の比較はequal
+  static_assert(std::type_order_v<int, int> == std::strong_ordering::equal);
+
+  // 異なる型同士の順序は実装定義だが、反対称性は保証される
+  constexpr auto ord_ab = std::type_order_v<A, B>;
+  constexpr auto ord_ba = std::type_order_v<B, A>;
+  static_assert(ord_ab != std::strong_ordering::equal);
+  static_assert((ord_ab < 0) == (ord_ba > 0));
+  static_assert((ord_ab > 0) == (ord_ba < 0));
+
+  // CV修飾の違いも区別される
+  static_assert(std::type_order_v<int, const int> != std::strong_ordering::equal);
+}
+```
+
+### 出力
+```
+```
+
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 16 [mark verified]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`strong_ordering`](strong_ordering.md)
+- [`std::meta::type_order`](/reference/meta/type_order.md)
+
+
+## 参照
+- [P2830R10 Constexpr Type Ordering](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2830r10.html)
+- [P3778R0 Fix for `type_order` template definition](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3778r0.html)

reference/meta/type_order.md

@@ -14,6 +14,8 @@ namespace std::meta {
 ## 概要
 2つの型のリフレクション間の順序を取得する。[`std::meta::info`](info.md)は`<=>`をサポートしないが、この関数により型のリフレクション間で一貫した全順序を得ることができる。
 
+[`std::type_order`](/reference/compare/type_order.md)のリフレクション版である。
+
 
 ## 戻り値
 `type_a`と`type_b`が型を表す場合、それらの間の実装定義の全順序を[`strong_ordering`](/reference/compare/strong_ordering.md)として返す。
@@ -23,7 +25,19 @@ namespace std::meta {
 `type_a`または`type_b`が型を表さない場合、[`std::meta::exception`](exception.md)例外を送出する。
 
 
+## 備考
+型のリフレクションを並べ替えるユースケースで使用される。具体的には以下のような場面で必要になる：
+
+- **型リストの正規化**: 型集合（`typeset<A, B>`と`typeset<B, A>`を同じ型にする）の実装
+- **`std::variant`の候補型の正規化**: 候補型の順序を一意化することで、`variant<A, B>`と`variant<B, A>`を同じ型として扱える
+- **`std::expected`のエラー型の集約**: 複数の翻訳単位にわたって安定したエラー型のマージ
+- **`std::execution`等の非同期処理**: 中継型を一意化することで安定したシグニチャを得る
+
+実装定義の全順序の具体的な順番には依存すべきではないが、ある実装の中では翻訳単位の境界をまたいでも安定する。
+
+
 ## 例
+### 基本的な使い方
 ```cpp example
 #include <meta>
 #include <compare>
@@ -40,6 +54,42 @@ int main() {
 ```
 ```
 
+### 型リフレクションを順序付けする
+[`type_order()`](type_order.md)を比較関数として使用することで、型リフレクションのコレクションを安定した順序にソートできる。
+
+```cpp example
+#include <meta>
+#include <algorithm>
+#include <vector>
+
+consteval std::vector<std::meta::info> sort_types(std::vector<std::meta::info> types) {
+  std::ranges::sort(types,
+    [](std::meta::info a, std::meta::info b) {
+      return std::meta::type_order(a, b) == std::strong_ordering::less;
+    });
+  return types;
+}
+
+int main() {
+  // 入力順序に関わらず、同じ型集合は同じ並びにソートされる
+  static constexpr auto sorted1 = std::define_static_array(
+    sort_types({^^int, ^^double, ^^char}));
+  static constexpr auto sorted2 = std::define_static_array(
+    sort_types({^^char, ^^int, ^^double}));
+
+  // 並びが一致することを確認
+  static_assert(sorted1.size() == sorted2.size());
+  static_assert(sorted1[0] == sorted2[0]);
+  static_assert(sorted1[1] == sorted2[1]);
+  static_assert(sorted1[2] == sorted2[2]);
+}
+```
+* std::ranges::sort[link /reference/algorithm/ranges_sort.md]
+
+### 出力
+```
+```
+
 
 ## バージョン
 ### 言語