Pack indexing (since C++26)

int runtime_idx();
void bar(auto... args)
{
    auto a = args...[0];
    const int n = 1;
    auto b = args...[n];
    int m = 2;
    auto c = args...[m]; // エラー: 'm' は定数式ではありません
    auto d = args...[runtime_idx()]; // エラー: 'runtime_idx()' は定数式ではありません
}

template <template <typename...> typename... Temps>
using A = Temps...[0]<>; // エラー: 'Temps' はテンプレートテンプレートパラメータのパックです
template <template <typename...> typename... Temps>
using B = Temps<>...[0]; // エラー: 'Temps<>' はパック名を表していません
                         // 単純テンプレートIDではありますが

template <std::size_t I, typename... Ts>
constexpr auto element_at(Ts... args)
{
    // 関数パラメータパック宣言で導入された 'args'
    return args...[I];
}
static_assert(element_at<0>(3, 5, 9) == 3);
static_assert(element_at<2>(3, 5, 9) == 9);
static_assert(element_at<3>(3, 5, 9) == 4); // エラー: 範囲外
static_assert(element_at<0>() == 1); // エラー: 範囲外、空のパック
template <std::size_t I, typename Tup>
constexpr auto structured_binding_element_at(Tup tup)
{
    auto [...elems] = tup;
    // 構造化バインディングパック宣言で導入された 'elems'
    return elems...[I];
}
struct A { bool a; int b; };
static_assert(structured_binding_element_at<0>(A {true, 4}) == true);
static_assert(structured_binding_element_at<1>(A {true, 4}) == 4);
// 定数テンプレートパラメータパック宣言で導入された 'Vals'
template <std::size_t I, std::size_t... Vals>
constexpr std::size_t double_at = Vals...[I] * 2; // OK
template <std::size_t I, typename... Args>
constexpr auto foo(Args... args)
{
    return [...members = args](Args...[I] op)
    {
        // ラムダ初期化キャプチャパックで導入された 'members'
        return members...[I] + op;
    };
}
static_assert(foo<0>(4, "Hello", true)(5) == 9);
static_assert(foo<1>(3, std::string("C++"))("26") == "C++26");

template <std::size_t I, auto... Vals>
constexpr auto identity_at = (Vals)...[I]; // エラー
// 代わりに 'Vals...[I]' を使用
template <std::size_t I, std::size_t... Vals>
constexpr std::size_t triple_at = (Vals * 3)...[I]; // エラー
// 代わりに 'Vals...[I] * 3' を使用
template <std::size_t I, typename... Args>
constexpr decltype(auto) get(Args&&... args) noexcept
{
    return std::forward<Args>(args)...[I]; // エラー
    // 代わりに 'std::forward<Args...[I]>(args...[I])' を使用
}

void f() 
{
    [](auto... args)
    {
        using T0 = decltype(args...[0]);   // 'T0' は 'double' 型
        using T1 = decltype((args...[0])); // 'T1' は 'double&' 型
    }(3.14);
}

template <typename... Ts>
using last_type_t = Ts...[sizeof...(Ts) - 1];
static_assert(std::is_same_v<last_type_t<>, int>); // エラー: 範囲外
static_assert(std::is_same_v<last_type_t<int>, int>);
static_assert(std::is_same_v<last_type_t<bool, char>, char>);
static_assert(std::is_same_v<last_type_t<float, int, bool*>, bool*>);

template <typename...>
struct type_seq {};
template <typename... Ts>
auto f(Ts...[0] arg, type_seq<Ts...>)
{
    return arg;
}
// OK: "Hello" は暗黙的に 'std::string_view' に変換される
std::same_as<std::string_view> auto a = f("Hello", type_seq<std::string_view>{});
// エラー: "Ok" は 'int' に変換できない
std::same_as<int> auto b = f("Ok", type_seq<int, const char*>{});

template <typename... Ts>
void f(Ts... [1]);
template <typename... Ts>
void g(Ts... args[1]);
template <typename... Ts>
void h(Ts*...); // より明確だがより許容的: Ts...はcv voidまたは関数型を含む可能性がある
void foo() 
{
    f<char, bool>(nullptr, nullptr);
    // 動作 #1 (C++26以前):
    //  void 'f<char, bool>(char*, bool*)' (別名 'f<char, bool>(char[1], bool[1])') を呼び出す
    // 動作 #2 (C++26以降): 
    //  エラー: 'void f<char, bool>(bool)' が呼び出されたと推定されるが
    //  1つの引数ではなく2つの引数が指定されている
    g<char, bool>(nullptr, nullptr);
    // 'g<char, bool>(char*, bool*)' (別名 'g<char, bool>(char[1], bool[1])') を呼び出す
    h<char, bool>(nullptr, nullptr);
    // 'h<char, bool>(char*, bool*)' を呼び出す
}