optional : C++26での参照への部分特殊化に対応 #1498

Author: faithandbrave

reference/optional/optional.md

@@ -9,6 +9,10 @@ namespace std {
   template <class T>
   class optional;
 
+  // 参照に対する部分特殊化 (C++26)
+  template <class T>
+  class optional<T&>;
+
 
   // viewコンセプトを有効化する (C++26)
   template<class T>
@@ -17,6 +21,10 @@ namespace std {
   // std::formatによるフォーマットを無効化する (C++26)
   template<class T>
   constexpr auto format_kind<optional<T>> = range_format::disabled;
+
+  // borrowed_rangeコンセプトを有効化する (C++26)
+  template<class T>
+  constexpr bool ranges::enable_borrowed_range<optional<T&>> = true;
 }
 ```
 
@@ -41,7 +49,7 @@ namespace std {
 
 
 ## テンプレートパラメータ制約
-型`T`が以下のいずれかに該当してはならない：
+プライマリテンプレート`optional<T>`の型`T`が以下のいずれかに該当してはならない：
 
 - 参照型
 - (CV修飾された)[`std::in_place_t`](/reference/utility/in_place_t.md)
@@ -50,11 +58,21 @@ namespace std {
 また、型`T`は[`std::destructible`](/reference/concepts/destructible.md)要件を満たすこと。
 
 
+## 参照に対する部分特殊化 (C++26)
+このクラスは、`optional<T&>`のように参照を保持できる。内部的には`T`へのポインタとして保持され、代入時には参照先を再束縛 (rebind) する。
+
+`optional<T&>`は以下の特徴をもつ：
+
+- ダングリング参照を防ぐため、一時オブジェクトから構築するオーバーロードは削除定義される
+- 代入は参照先の再束縛 (rebind) を行う（参照先オブジェクトへの代入ではない）
+- [`emplace()`](optional/emplace.md)は参照先の再束縛を行う意味論であるため、可変長引数版や[`std::initializer_list`](/reference/initializer_list/initializer_list.md)版はなく、単一引数のみ受け取る
+- `optional<T&>`はトリビアルコピー可能 (trivially copyable) である
+- モナド操作 ([`and_then()`](optional/and_then.md), [`transform()`](optional/transform.md), [`or_else()`](optional/or_else.md)) も使用可能
+
+
 ## 備考
 このクラスの前身となった[Boost Optional Library](https://boost.org/libs/optional)では、`optional<int&>`のように左辺値参照を要素型とした場合に、無効値の領域を最適化する機能が入っていた。
 
-標準ライブラリの`optional`クラスには現在、参照を持たせることはできない。
-
 
 ## メンバ関数
 ### 構築・破棄
@@ -199,6 +217,64 @@ error
 ```
 
 
+### 参照型を保持する例 (C++26)
+```cpp example
+#include <print>
+#include <optional>
+#include <map>
+#include <string>
+
+// コンテナからの要素検索。見つからない場合は無効値を返す
+std::optional<const std::string&>
+  find_value(const std::map<int, std::string>& m, int key)
+{
+  auto it = m.find(key);
+  if (it != m.end()) {
+    return it->second;  // 要素への参照を返す (コピーは発生しない)
+  }
+  return std::nullopt;
+}
+
+int main()
+{
+  std::map<int, std::string> m = {
+    {1, "Alice"},
+    {2, "Bob"},
+    {3, "Charlie"}
+  };
+
+  // 値が見つかった場合
+  if (auto name = find_value(m, 2)) {
+    // コピーではなく参照を保持しているため、効率的にアクセスできる
+    std::println("{}", name.value());
+  }
+
+  // 値が見つからなかった場合
+  if (auto name = find_value(m, 99); !name) {
+    std::println("not found");
+  }
+
+  // モナド操作との組み合わせ
+  auto result = find_value(m, 1)
+    .transform([](const std::string& s) { return s.size(); })
+    .value_or(0u);
+  std::println("{}", result);
+}
+```
+* std::nullopt[link nullopt_t.md]
+* std::println[link /reference/print/println.md]
+* name.value()[link optional/value.md]
+* .transform[link optional/transform.md]
+* .value_or[link optional/value_or.md]
+
+#### 出力
+```
+Bob
+not found
+5
+```
+
+
 ## バージョン
 ### 言語
 - C++17
@@ -230,3 +306,7 @@ error
 - [P0504R0 Revisiting in-place tag types for `any`/`optional`/`variant`](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0504r0.html)
 - [LWG Issue 3196. `std::optional<T>` is ill-formed is `T` is an array](https://wg21.cmeerw.net/lwg/issue3196)
 - [P0798R8 Monadic operations for std::optional](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0798r8.html)
+- [P2988R12 `std::optional<T&>`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2988r12.pdf)
+    - C++26で参照型`T&`に対する部分特殊化を追加
+- [P3836R2 `optional<T&>` Should Be Trivially Copyable](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3836r2.html)
+    - C++26で`optional<T&>`がトリビアルコピー可能であることを保証

reference/optional/optional/and_then.md

@@ -6,16 +6,28 @@
 * cpp23[meta cpp]
 
 ```cpp
-template <class F> constexpr auto and_then(F&& f) &;       // (1)
-template <class F> constexpr auto and_then(F&& f) &&;      // (2)
-template <class F> constexpr auto and_then(F&& f) const&;  // (3)
-template <class F> constexpr auto and_then(F&& f) const&&; // (4)
+// optional<T>版のオーバーロード
+template <class F> constexpr auto and_then(F&& f) &;       // (1) C++23
+template <class F> constexpr auto and_then(F&& f) &&;      // (2) C++23
+template <class F> constexpr auto and_then(F&& f) const&;  // (3) C++23
+template <class F> constexpr auto and_then(F&& f) const&&; // (4) C++23
+
+// optional<T&>版のオーバーロード (C++26)
+template <class F> constexpr auto and_then(F&& f) const;   // (5) C++26
 ```
 
 ## 概要
 有効値を保持していれば、値に対して`f`を適用した結果を`optional`として返す。
 有効値を保持していなければ、[`std::nullopt`](../nullopt_t.md)を返す。
 
+- (1) : `*this`が非`const`左辺値の場合
+- (2) : `*this`が非`const`右辺値の場合
+- (3) : `*this`が`const`左辺値の場合
+- (4) : `*this`が`const`右辺値の場合
+- (5) : `optional<T&>`の場合
+
+`optional<T>`では (1)～(4) が定義され、`optional<T&>`では (5) のみが定義される。
+
 実際には複数オーバーロードが提供されるが、大まかには下記シグニチャのようにみなせる。
 `and_then`へは、引数リストに1個の`T`型をとり`std::optional<Return>`型を返す関数や関数オブジェクトを与える。
 
@@ -34,6 +46,7 @@ class optional {
 
 - (1), (3) : [`invoke_result_t`](/reference/type_traits/invoke_result.md)`<F, decltype(`[`value()`](value.md)`)>`
 - (2), (4) : [`invoke_result_t`](/reference/type_traits/invoke_result.md)`<F, decltype(`[`std::move`](/reference/utility/move.md)`(`[`value()`](value.md)`))>`
+- (5) : [`invoke_result_t`](/reference/type_traits/invoke_result.md)`<F, decltype(*val)>` (説明専用メンバ`val`は`T*`型)
 
 [`remove_cvref_t`](/reference/type_traits/remove_cvref.md)`<U>`は`optional`の特殊化であること
 
@@ -64,6 +77,17 @@ class optional {
     * std::move[link /reference/utility/move.md]
     * value()[link value.md]
 
+- (5) : 次と等価
+
+    ```cpp
+    if (*this) {
+      return invoke(std::forward<F>(f), *val);
+    } else {
+      return remove_cvref_t<U>();
+    }
+    ```
+    * invoke[link /reference/functional/invoke.md]
+
 
 ## 備考
 `and_then`は、メソッドチェーンをサポートするモナド風(monadic)操作として導入された。
@@ -126,3 +150,5 @@ int main()
 
 ## 参照
 - [P0798R8 Monadic operations for std::optional](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p0798r8.html)
+- [P2988R12 `std::optional<T&>`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2988r12.pdf)
+    - C++26で参照型`T&`に対する部分特殊化を追加

reference/optional/optional/emplace.md

@@ -6,6 +6,7 @@
 * cpp17[meta cpp]
 
 ```cpp
+// optional<T>版のオーバーロード
 template <class... Args>
 T& emplace(Args&&... args);                                        // (1) C++17
 template <class... Args>
@@ -15,24 +16,32 @@ template <class U, class... Args>
 T& emplace(std::initializer_list<U> il, Args&&... args);           // (2) C++17
 template <class U, class... Args>
 constexpr T& emplace(std::initializer_list<U> il, Args&&... args); // (2) C++23
+
+// optional<T&>版のオーバーロード (C++26)
+template <class U>
+constexpr T& emplace(U&& u) noexcept(see below);                   // (3) C++26
 ```
 
 ## 概要
 要素型のコンストラクタ引数から直接構築する。
 
 - (1) : 可変個の引数をとり、それを型`T`のコンストラクタ引数として渡して、この関数内で型`T`の有効値を構築して保持する
 - (2) : 初期化子リストと可変個の引数をとり、それらを型`T`のコンストラクタ引数として渡して、この関数内で型`T`の有効値を構築して保持する
+- (3) : `optional<T&>`の参照先を再束縛する。変換可能な単一引数を受け取る
+
+`optional<T>`では (1), (2) が定義され、`optional<T&>`では (3) のみが定義される。
 
 
-## 要件
+## テンプレートパラメータ制約
 - (1) : [`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T, Args&&...> == true`であること
+- (3) : [`is_constructible_v`](/reference/type_traits/is_constructible.md)`<T&, U> == true`であり、[`reference_constructs_from_temporary_v`](/reference/type_traits/reference_constructs_from_temporary.md)`<T&, U> == false`であること
 
 
 ## 効果
-まず、共通の動作として、[`reset()`](reset.md)メンバ関数を呼び出す。
-
-- (1) : 型`T`の有効値を、[`std::forward<Args>`](/reference/utility/forward.md)`(args)...`を引数として構築する
-- (2) : 型`T`の有効値を、`il`と[`std::forward<Args>`](/reference/utility/forward.md)`(args)...`を引数として構築する
+- (1), (2) : まず[`reset()`](reset.md)メンバ関数を呼び出す
+    - (1) : 型`T`の有効値を、[`std::forward<Args>`](/reference/utility/forward.md)`(args)...`を引数として構築する
+    - (2) : 型`T`の有効値を、`il`と[`std::forward<Args>`](/reference/utility/forward.md)`(args)...`を引数として構築する
+- (3) : 参照先を`u`に再束縛する
 
 
 ## 戻り値
@@ -49,6 +58,7 @@ constexpr T& emplace(std::initializer_list<U> il, Args&&... args); // (2) C++23
 
 ## 備考
 - (2) : このオーバーロードは主に、コンテナをアロケータ付きで、初期化子リスト代入するためにある
+- (3) : 一時オブジェクトから参照を構築するとダングリングになるケースでは、このオーバーロードは削除定義される
 
 
 ## 例
@@ -114,3 +124,5 @@ int main()
 - [LWG Issue 2857. {`variant`,`optional`,`any`}`::emplace` should return the constructed value](https://wg21.cmeerw.net/lwg/issue2857)
 - [P0084R2 Emplace Return Type (Revision 2)](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0084r2.pdf)
 - [P2231R1 Missing `constexpr` in `std::optional` and `std::variant`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2231r1.html)
+- [P2988R12 `std::optional<T&>`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2988r12.pdf)
+    - C++26で参照型`T&`に対する部分特殊化を追加

reference/optional/optional/op_arrow.md

@@ -6,20 +6,32 @@
 * cpp17[meta cpp]
 
 ```cpp
-constexpr const T* operator->() const;
-constexpr T* operator->();
+// optional<T>版のオーバーロード
+constexpr const T* operator->() const; // (1) C++17
+constexpr T* operator->();             // (2) C++17
+
+// optional<T&>版のオーバーロード (C++26)
+constexpr T* operator->() const noexcept; // (3) C++26
 ```
 
 ## 概要
 保持している有効値のメンバにアクセスする。
 
+- (1) : `optional<T>`のconst版。`const T*`を返す
+- (2) : `optional<T>`の非const版。`T*`を返す
+- (3) : `optional<T&>`の場合。`T*`を返す
+
+`optional<T>`では (1), (2) が定義され、`optional<T&>`では (3) のみが定義される。
+
 
 ## 堅牢化された事前条件
 `*this`が有効な値を保持していること
 
 
 ## 戻り値
-保持している有効値へのポインタを返す。
+- (1) : 有効値への`const T*`
+- (2) : 有効値への`T*`
+- (3) : 参照先への`T*`
 
 
 ## 例外
@@ -72,3 +84,5 @@ int main()
 - [LWG Issue 2740. `constexpr optional<T>::operator->`](https://wg21.cmeerw.net/lwg/issue2740)
 - [P3471R4 Standard library hardening](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3471r4.html)
 - [P3878R1 Standard library hardening should not use the 'observe' semantic](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3878r1.html)
+- [P2988R12 `std::optional<T&>`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2988r12.pdf)
+    - C++26で参照型`T&`に対する部分特殊化を追加

reference/optional/optional/op_assign.md

@@ -29,6 +29,9 @@ template <class U>
 optional& operator=(optional<U>&& rhs);                            // (6) C++17
 template <class U>
 constexpr optional& operator=(optional<U>&& rhs);                  // (6) C++23
+
+// optional<T&>固有のオーバーロード (C++26)
+constexpr optional& operator=(const optional&) noexcept = default; // (7) C++26
 ```
 * nullopt_t[link /reference/optional/nullopt_t.md]
 
@@ -39,14 +42,17 @@ constexpr optional& operator=(optional<U>&& rhs);                  // (6) C++23
 - (4) : 要素型`T`に変換可能な値をムーブ代入
 - (5) : `optional<T>`に変換可能な`optional`オブジェクトをコピー代入
 - (6) : `optional<T>`に変換可能な`optional`オブジェクトをムーブ代入
+- (7) : `optional<T&>`のコピー代入。参照先の再束縛 (rebind) を行う (`noexcept = default`)
+
+`optional<T>`では (1)～(6) が定義される。`optional<T&>`では (1), (7) が定義される。
 
 
 ## テンプレートパラメータ制約
 - (4), (5), (6) : 型`U`が型`T`に変換可能であること
 
 
 ## 効果
-いずれのオーバーロードでも、`*this` と `rhs` が有効な値を持っているか否かによって以下のような挙動となる。
+(1)～(6) では、`*this` と `rhs` が有効な値を持っているか否かによって以下のような挙動となる。
 
 |                                    | `*this` が有効な値を持っている                                        | `*this` が有効な値を持っていない                                     |
 |------------------------------------|-----------------------------------------------------------------------|----------------------------------------------------------------------|
@@ -61,6 +67,8 @@ constexpr optional& operator=(optional<U>&& rhs);                  // (6) C++23
 - (3), (6): [`std::move`](../../utility/move.md)`(*rhs)`
 - (4): [`std::forward`](../../utility/forward.md)`<U>(rhs)`
 
+(7) では、`rhs`が保持する参照先ポインタをコピーする (参照先の再束縛)。
+
 
 ## 戻り値
 `*this`
@@ -87,6 +95,11 @@ constexpr optional& operator=(optional<U>&& rhs);                  // (6) C++23
 - (2) : 型`T`が、[トリビアルにコピー構築可能](/reference/type_traits/is_trivially_copy_constructible.md)であり[トリビアルにコピー代入可能](/reference/type_traits/is_trivially_copy_assignable.md)かつ、[トリビアルに破棄可能](/reference/type_traits/is_trivially_destructible.md)である
 - (3) : 型`T`が、[トリビアルにムーブ構築可能](/reference/type_traits/is_trivially_move_constructible.md)であり[トリビアルにムーブ代入可能](/reference/type_traits/is_nothrow_move_assignable.md)かつ、[トリビアルに破棄可能](/reference/type_traits/is_trivially_destructible.md)である
 
+## 備考
+- (7) : `optional<T&>`への代入は、参照先オブジェクトへの代入ではなく、参照先の再束縛 (rebind) を行う。これはポインタの代入と同じセマンティクスである
+- `optional<T&>`では、値の代入や異なる型の`optional`からの変換代入は提供されない。値を代入する場合は、暗黙の変換による`optional<T&>`の構築とコピー代入 (7) を通じて行われる
+
+
 ## 例
 ```cpp example
 #include <cassert>
@@ -180,3 +193,5 @@ int main()
 - [LWG Issue 2756. `optional<T>` should `forward` `T`'s implicit conversions](https://wg21.cmeerw.net/lwg/issue2756)
 - [P0602R4 `variant` and `optional` should propagate copy/move triviality](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0602r4.html)
 - [P2231R1 Missing `constexpr` in `std::optional` and `std::variant`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2231r1.html)
+- [P2988R12 `std::optional<T&>`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2988r12.pdf)
+    - C++26で参照型`T&`に対する部分特殊化を追加