C++26対応としてapplyの戻り値型を取得するメタ関数を追加 #1522

Author: faithandbrave

lang/cpp26.md

@@ -464,9 +464,9 @@ C++26とは、2026年中に改訂される予定の、C++バージョンの通
     - [`begin()`](/reference/optional/optional/begin.md)メンバ関数
     - [`end()`](/reference/optional/optional/end.md)メンバ関数
 - [`std::optional`](/reference/optional/optional.md)に、参照を保持するための`T&`の部分特殊化を追加
-- [`std::apply`](/reference/tuple/apply.md)の戻り値型推論をやめて、戻り値型用の[`std::apply_result`](/reference/tuple/apply_result.md.nolink)クラスを追加し、関連する以下の機能を追加
-    - [`std::is_applicable`](/reference/type_traits/is_applicable.md.nolink)型特性
-    - [`std::is_nothrow_applicable`](/reference/type_traits/is_nothrow_applicable.md.nolink)型特性
+- [`std::apply`](/reference/tuple/apply.md)の戻り値型推論をやめて、戻り値型用の[`std::apply_result`](/reference/type_traits/apply_result.md)クラスを追加し、関連する以下の機能を追加
+    - [`std::is_applicable`](/reference/type_traits/is_applicable.md)型特性
+    - [`std::is_nothrow_applicable`](/reference/type_traits/is_nothrow_applicable.md)型特性
 - [`std::ignore`](/reference/tuple/ignore.md)をファーストクラス・オブジェクトとして型を詳細に定義
 - [`std::bitset`](/reference/bitset/bitset.md)に、[`std::basic_string_view`](/reference/string_view/basic_string_view.md)を受け取るコンストラクタを追加
 - [`<ratio>`](/reference/ratio.md)に、新たなSI接頭辞として、以下を追加

reference/tuple/apply.md

@@ -13,10 +13,18 @@ namespace std {
   template<class F, tuple-like Tuple>
   constexpr decltype(auto)
     apply(F&& f, Tuple&& t) noexcept(see below); // (1) C++23
+
+  template<class F, tuple-like Tuple>
+  constexpr apply_result_t<F, Tuple>
+    apply(F&& f, Tuple&& t)
+      noexcept(is_nothrow_applicable_v<F, Tuple>); // (1) C++26
 }
 ```
 * tuple-like[link tuple-like.md]
 * tuple-like[link tuple-like.md]
+* tuple-like[link tuple-like.md]
+* apply_result_t[link /reference/type_traits/apply_result.md]
+* is_nothrow_applicable_v[link /reference/type_traits/is_nothrow_applicable.md]
 
 ## 概要
 タプルを展開し、関数の引数に適用してその関数を実行する。
@@ -69,7 +77,8 @@ return apply-impl(std::forward<F>(f), std::forward<Tuple>(t),
 
 
 ## 例外
-C++23から : `I`をパラメータパック`0, 1, ..., (`[`tuple_size_v`](tuple_size.md)`<`[`remove_reference_t`](/reference/type_traits/remove_reference.md)`<Tuple>>-1)`としたとき、例外指定の式は次と等価 : `noexcept(`[`invoke`](/reference/functional/invoke.md)`(std::forward<F>(f), get<I>(std::forward<Tuple>(t))...))`
+- C++23から : `I`をパラメータパック`0, 1, ..., (`[`tuple_size_v`](tuple_size.md)`<`[`remove_reference_t`](/reference/type_traits/remove_reference.md)`<Tuple>>-1)`としたとき、例外指定の式は次と等価 : `noexcept(`[`invoke`](/reference/functional/invoke.md)`(std::forward<F>(f), get<I>(std::forward<Tuple>(t))...))`
+- C++26から : 例外指定は[`is_nothrow_applicable_v`](/reference/type_traits/is_nothrow_applicable.md)`<F, Tuple>`
 
 
 ## 例
@@ -117,6 +126,9 @@ hello
 - [`std::tuple`](../tuple.md)
 - [INVOKE](/reference/concepts/Invoke.md)
 - [`tuple-like`](tuple-like.md)
+- [`apply_result`](/reference/type_traits/apply_result.md)
+- [`is_applicable`](/reference/type_traits/is_applicable.md)
+- [`is_nothrow_applicable`](/reference/type_traits/is_nothrow_applicable.md)
 
 
 ## 参照
@@ -130,3 +142,5 @@ hello
     - C++20から効果説明の`decay_t`を`remove_cvref_t`へ変更。
 - [P2517R1 Add a conditional `noexcept` specification to `std::apply`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2517r1.html)
     - C++23から条件付きで`noexcept`例外指定が行われる。
+- [P1317R2 Remove return type deduction in `std::apply`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p1317r2.pdf)
+    - C++26から戻り値型が`decltype(auto)`から`apply_result_t<F, Tuple>`に変更され、SFINAEフレンドリーになった。

reference/type_traits.md

@@ -182,6 +182,8 @@
 | [`is_invocable_r`](type_traits/is_invocable_r.md) | 関数呼び出し可能でその戻り値型がある型へ変換可能かを調べる (class template) | C++17 |
 | [`is_nothrow_invocable`](type_traits/is_nothrow_invocable.md) | 例外を投げずに関数呼び出し可能かを調べる (class template) | C++17 |
 | [`is_nothrow_invocable_r`](type_traits/is_nothrow_invocable_r.md) | 例外を投げずに関数呼び出し可能でその戻り値型がある型へ変換可能かを調べる (class template) | C++17 |
+| [`is_applicable`](type_traits/is_applicable.md) | タプルを展開して関数呼び出し可能かを調べる (class template) | C++26 |
+| [`is_nothrow_applicable`](type_traits/is_nothrow_applicable.md) | 例外を投げずにタプルを展開して関数呼び出し可能かを調べる (class template) | C++26 |
 
 
 ## その他の変換
@@ -202,6 +204,7 @@
 | [`underlying_type`](type_traits/underlying_type.md) | 列挙型の基底型を取得する (class template) | C++11 |
 | [`result_of`](type_traits/result_of.md) | 関数の戻り値の型を取得する (class template) | C++11 |
 | [`invoke_result`](type_traits/invoke_result.md) | 関数の戻り値の型を取得する (class template) | C++17 |
+| [`apply_result`](type_traits/apply_result.md) | タプルを展開して関数を呼び出した場合の戻り値の型を取得する (class template) | C++26 |
 | [`unwrap_reference`](type_traits/unwrap_reference.md) | [`reference_wrapper<T>`](/reference/functional/reference_wrapper.md)型を`T&`型に展開する (class template) | C++20 |
 | [`unwrap_ref_decay`](type_traits/unwrap_ref_decay.md) | [`reference_wrapper<T>`](/reference/functional/reference_wrapper.md)型を`T&`型に展開し、型推論規則による型変換を行う (class template) | C++20 |
 

reference/type_traits/apply_result.md

@@ -0,0 +1,88 @@
+# apply_result
+* type_traits[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class F, class Tuple>
+  struct apply_result;
+
+  template <class F, class Tuple>
+  using apply_result_t = typename apply_result<F, Tuple>::type;
+}
+```
+
+## 概要
+関数呼び出し可能な型`F`に対して、[`tuple-like`](/reference/tuple/tuple-like.md)な型`Tuple`の要素を展開して[`apply`](/reference/tuple/apply.md)した場合の戻り値型を取得する。
+
+[`invoke_result`](invoke_result.md)の[`apply`](/reference/tuple/apply.md)版であり、タプルの要素を引数として関数を呼び出した結果の型を求める。
+
+
+## 要件
+型`F`および`Tuple`が、完全型であること。もしくは`const`/`volatile`修飾された(あるいはされていない)`void`か、要素数不明の配列型であること。
+
+
+## 効果
+`ELEMS-OF(T)`を、`make_index_sequence<tuple_size_v<remove_reference_t<T>>>`が示す`index_sequence`の特殊化のテンプレート引数である`size_t`のパラメータパック`N`に対する、パラメータパック`get<N>(declval<T>())`とする。
+
+式[*INVOKE*](/reference/concepts/Invoke.md)`(declval<F>(), ELEMS-OF(Tuple)...)`が未評価オペランドとして扱われたときに適格であるならば、メンバ型`type`は`decltype(`[*INVOKE*](/reference/concepts/Invoke.md)`(declval<F>(), ELEMS-OF(Tuple)...))`を示す。そうでなければ、メンバ型`type`は定義されない。
+
+アクセスチェックは`F`および`Tuple`と無関係なコンテキストで行われる。式の直接のコンテキストの妥当性のみが考慮される。
+
+
+## 備考
+このメタ関数はC++26で追加された。C++23まで[`apply`](/reference/tuple/apply.md)の戻り値型は`decltype(auto)`による型推論が使われていたが、これはSFINAEフレンドリーではなかった。`apply_result`を使うことで、[`apply`](/reference/tuple/apply.md)の呼び出し可能性をコンセプトやSFINAEで判定できるようになった。
+
+
+## 例
+```cpp example
+#include <tuple>
+#include <type_traits>
+#include <string>
+
+int add(int a, int b) { return a + b; }
+
+int main()
+{
+  using args_t = std::tuple<int, int>;
+
+  // apply(add, tuple<int, int>) の戻り値型は int
+  static_assert(std::is_same_v<
+    std::apply_result_t<decltype(&add), args_t>,
+    int
+  >);
+
+  // 呼び出し不可能な場合、apply_result にはメンバ型 type がない
+  // （SFINAEフレンドリー）
+  static_assert(!requires {
+    typename std::apply_result_t<decltype(&add), std::tuple<std::string>>;
+  });
+}
+```
+* std::apply_result_t[color ff0000]
+
+### 出力
+```
+```
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 15 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`invoke_result`](invoke_result.md)
+- [`is_applicable`](is_applicable.md)
+- [`is_nothrow_applicable`](is_nothrow_applicable.md)
+- [`apply`](/reference/tuple/apply.md)
+
+
+## 参照
+- [P1317R2 Remove return type deduction in `std::apply`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p1317r2.pdf)

reference/type_traits/is_applicable.md

@@ -0,0 +1,88 @@
+# is_applicable
+* type_traits[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class F, class Tuple>
+  struct is_applicable;
+
+  template <class F, class Tuple>
+  inline constexpr bool is_applicable_v = std::is_applicable<F, Tuple>::value;
+}
+```
+
+## 概要
+関数呼び出し可能な型`F`に対して、[`tuple-like`](/reference/tuple/tuple-like.md)な型`Tuple`の要素を展開して[`apply`](/reference/tuple/apply.md)による呼び出しが可能かどうかを調べる。
+
+[`is_invocable`](is_invocable.md)の[`apply`](/reference/tuple/apply.md)版である。
+
+
+## 要件
+型`F`および`Tuple`が、完全型であること。もしくは`const`/`volatile`修飾された(あるいはされていない)`void`か、要素数不明の配列型であること。
+
+
+## 効果
+`ELEMS-OF(T)`を、`make_index_sequence<tuple_size_v<remove_reference_t<T>>>`が示す`index_sequence`の特殊化のテンプレート引数である`size_t`のパラメータパック`N`に対する、パラメータパック`get<N>(declval<T>())`とする。
+
+[`tuple-like`](/reference/tuple/tuple-like.md)`<Tuple>`が`true`であり、かつ式[*INVOKE*](/reference/concepts/Invoke.md)`(declval<F>(), ELEMS-OF(Tuple)...)`が未評価オペランドとして扱われたときに適格であるならば[`true_type`](true_type.md)から派生し、そうでなければ[`false_type`](false_type.md)から派生する。
+
+
+## 例
+```cpp example
+#include <tuple>
+#include <type_traits>
+#include <string>
+#include <iostream>
+
+int add(int a, int b) { return a + b; }
+void no_args() {}
+
+int main()
+{
+  std::cout << std::boolalpha;
+
+  // add(int, int) に tuple<int, int> を展開して呼び出し可能
+  std::cout << std::is_applicable_v<decltype(&add), std::tuple<int, int>> << std::endl;
+
+  // add(int, int) に tuple<int> では引数が足りない
+  std::cout << std::is_applicable_v<decltype(&add), std::tuple<int>> << std::endl;
+
+  // no_args() に空のタプルで呼び出し可能
+  std::cout << std::is_applicable_v<decltype(&no_args), std::tuple<>> << std::endl;
+
+  // no_args() に tuple<int> は引数が多すぎる
+  std::cout << std::is_applicable_v<decltype(&no_args), std::tuple<int>> << std::endl;
+}
+```
+* std::is_applicable_v[color ff0000]
+
+### 出力
+```
+true
+false
+true
+false
+```
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 15 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`is_invocable`](is_invocable.md)
+- [`is_nothrow_applicable`](is_nothrow_applicable.md)
+- [`apply_result`](apply_result.md)
+- [`apply`](/reference/tuple/apply.md)
+
+
+## 参照
+- [P1317R2 Remove return type deduction in `std::apply`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p1317r2.pdf)

reference/type_traits/is_nothrow_applicable.md

@@ -0,0 +1,84 @@
+# is_nothrow_applicable
+* type_traits[meta header]
+* std[meta namespace]
+* class template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  template <class F, class Tuple>
+  struct is_nothrow_applicable;
+
+  template <class F, class Tuple>
+  inline constexpr bool is_nothrow_applicable_v
+    = std::is_nothrow_applicable<F, Tuple>::value;
+}
+```
+
+## 概要
+関数呼び出し可能な型`F`に対して、[`tuple-like`](/reference/tuple/tuple-like.md)な型`Tuple`の要素を展開して[`apply`](/reference/tuple/apply.md)による呼び出しが可能であり、かつその呼び出しに際して例外を投げないかどうかを調べる。
+
+[`is_nothrow_invocable`](is_nothrow_invocable.md)の[`apply`](/reference/tuple/apply.md)版である。
+
+
+## 要件
+型`F`および`Tuple`が、完全型であること。もしくは`const`/`volatile`修飾された(あるいはされていない)`void`か、要素数不明の配列型であること。
+
+
+## 効果
+`ELEMS-OF(T)`を、`make_index_sequence<tuple_size_v<remove_reference_t<T>>>`が示す`index_sequence`の特殊化のテンプレート引数である`size_t`のパラメータパック`N`に対する、パラメータパック`get<N>(declval<T>())`とする。
+
+[`is_applicable_v`](is_applicable.md)`<F, Tuple>`が`true`であり、かつ式[*INVOKE*](/reference/concepts/Invoke.md)`(declval<F>(), ELEMS-OF(Tuple)...)`がいかなる例外も投げない場合[`true_type`](true_type.md)から派生し、そうでなければ[`false_type`](false_type.md)から派生する。
+
+
+## 例
+```cpp example
+#include <tuple>
+#include <type_traits>
+#include <iostream>
+
+int add(int a, int b) noexcept { return a + b; }
+int may_throw(int a, int b) { return a + b; }
+
+int main()
+{
+  std::cout << std::boolalpha;
+
+  // add(int, int) noexcept
+  std::cout << std::is_nothrow_applicable_v<decltype(&add), std::tuple<int, int>> << std::endl;
+
+  // may_throw(int, int) は noexcept ではない
+  std::cout << std::is_nothrow_applicable_v<decltype(&may_throw), std::tuple<int, int>> << std::endl;
+
+  // 呼び出し不可能
+  std::cout << std::is_nothrow_applicable_v<decltype(&add), std::tuple<int>> << std::endl;
+}
+```
+* std::is_nothrow_applicable_v[color ff0000]
+
+### 出力
+```
+true
+false
+false
+```
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): 22 [mark noimpl]
+- [GCC](/implementation.md#gcc): 15 [mark noimpl]
+- [Visual C++](/implementation.md#visual_cpp): 2026 Update 2 [mark noimpl]
+
+
+## 関連項目
+- [`is_nothrow_invocable`](is_nothrow_invocable.md)
+- [`is_applicable`](is_applicable.md)
+- [`apply_result`](apply_result.md)
+- [`apply`](/reference/tuple/apply.md)
+
+
+## 参照
+- [P1317R2 Remove return type deduction in `std::apply`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p1317r2.pdf)