Date: Sun, 19 Apr 2026 15:17:33 +0500
I am really sorry for sending many emails at once but I had mistakenly used
size_t instead of std::size_t. I just wanted to fix it.
this is the github link:
https://github.com/HjaldrKhilji/Future-potential-ISO-porposals/blob/main/Runtime_Indexed_Tuples_Proposal_Official%20(1).docx
(in case your email client cant see the linked file)
On Sun, Apr 19, 2026 at 2:27 PM Muneem <itfllow123_at_[hidden]> wrote:
> I also updated my proposal to include this example. If anyone has any
> issues with it, please tell me, and I will answer everyone tomorrow and
> also all the other questions that I haven't answered yet.
>
> On Sun, Apr 19, 2026 at 1:46 PM Muneem <itfllow123_at_[hidden]> wrote:
>
>> The previous code that I posted worked on visual studio 2026, but couldnt
>> on gdb online debugger, but here version that works on gdb as well:
>> https://onlinegdb.com/IBsomUfmPI
>> #include <iostream>
>> #include <type_traits>
>> #include <variant>
>> #include <functional>
>> #include <array>
>> template<typename Head, typename ... Types>
>> struct tuple_impl :tuple_impl<Types...>
>> {
>> Head head;
>> tuple_impl(Head&& a, Types... types) :
>> tuple_impl<Types...>(types...), head{ a } {}
>> tuple_impl(Head& a, Types... types) :
>> tuple_impl<Types...>(types...), head{ a } {}
>> };
>> template<typename Head>
>> struct tuple_impl<Head> {
>> Head head;
>> tuple_impl(Head&& a) : head{ a } {}
>> tuple_impl(Head& a) : head{ a } {}
>> };
>>
>> template<typename T, typename Head_t>
>> const constexpr bool Is_unique() { // requires() couldnt work here for
>> overloading
>> return true;
>> }
>>
>> template<typename T, typename Head_t, typename... Tail>
>> const constexpr std::enable_if_t < (sizeof...(Tail) > 0), bool >
>> Is_unique() {
>> return
>> !((std::is_same_v<T, Head_t>) && (Is_unique<T, Tail...>()))
>> &&
>> ((std::is_same_v<T, Head_t>) || (Is_unique<T, Tail...>()));
>> }
>>
>>
>> template<typename Head_t, typename ... Types >
>> constexpr bool is_unique_from_after_on() {
>> return Is_unique<Head_t, Types...>();
>> };
>> template<typename Head_t>
>> constexpr bool is_unique_from_after_on() {
>> return true;
>> }
>>
>>
>>
>> template<typename Head, typename ... Types>
>> struct tuple:tuple_impl<Types>... {
>> Head head;
>>
>> using complex_elem = std::variant <
>> std::enable_if_t<
>> is_unique_from_after_on<Head, Types...>(), Head*
>> >,
>> std::enable_if_t <
>> is_unique_from_after_on<Types...>(), Types*
>> >...
>> >;
>> std::array<complex_elem, (sizeof...(Types))+1> book_keeper;
>> template<typename Head_, typename ... Types_>
>> constexpr tuple(Head_&& a, Types_&&... b ) :head{
>> std::forward<Head>(a) }, tuple_impl<Types>{std::forward<Types>(b)}...,
>> book_keeper{
>> &head, &(this->tuple_impl<Types>::head)...}
>> {
>>
>> }
>> complex_elem operator[](size_t index) {
>> return book_keeper[index];
>> }
>> };
>> template<typename Head>
>> struct tuple<Head>{
>> Head head;
>> tuple(Head&& a ) : head{ a } {}
>> tuple(Head& a) : head{ a } {}
>> std::variant<Head*> operator[](size_t index) {
>> return head;
>> }
>> };
>>
>>
>>
>> int main() {
>> tuple<int, double, float> list{1, 2.0, 3.0f};
>> std::cout << *std::get<0>(list[0]) << std::endl;
>> std::cout << *std::get<1>(list[1]) << std::endl;
>> std::cout << *std::get<2>(list[2]) << std::endl;
>> return 0;
>> }
>>
>> //the reason it didn't work was template parameter name shadowing, but it
>> still worked in visual studio 2026
>>
>> On Sun, Apr 19, 2026 at 1:01 PM Muneem <itfllow123_at_[hidden]> wrote:
>>
>>> Sorry for taking so much time for such a basic implementation, and I
>>> won't be able to answer any questions until tomorrow because I am really
>>> tired. I hope that we can continue this discussion tomorrow. I am sorry for
>>> being hesitant to give out a proper implementation sooner.
>>> This is the example implementation code:
>>>
>>> #include <iostream>#include <type_traits>#include <variant>#include <functional>#include <array>template<typename Head, typename ... Types>struct tuple_impl :tuple_impl<Types...>
>>> {
>>> Head head;
>>> tuple_impl(Head&& a, Types... types) : tuple_impl<Types...>(types...), head{ a } {}
>>> tuple_impl(Head& a, Types... types) : tuple_impl<Types...>(types...), head{ a } {}
>>> };template<typename Head>struct tuple_impl<Head> {
>>> Head head;
>>> tuple_impl(Head&& a) : head{ a } {}
>>> tuple_impl(Head& a) : head{ a } {}
>>> };
>>> template<typename T, typename Head_t>const constexpr bool Is_unique() { // requires() couldnt work here for overloading
>>> return true;
>>> }
>>> template<typename T, typename Head_t, typename... Tail>const constexpr std::enable_if_t < (sizeof...(Tail) > 0), bool > Is_unique() {
>>> return
>>> !((std::is_same_v<T, Head_t>) && (Is_unique<T, Tail...>()))
>>> &&
>>> ((std::is_same_v<T, Head_t>) || (Is_unique<T, Tail...>()));
>>> }
>>>
>>> template<typename Head_t, typename ... Types >constexpr bool is_unique_from_after_on() {
>>> return Is_unique<Head_t, Types...>();
>>> };template<typename Head_t>constexpr bool is_unique_from_after_on() {
>>> return true;
>>> }
>>>
>>>
>>> template<typename Head, typename ... Types>struct tuple:tuple_impl<Types>... {
>>> Head head;
>>>
>>> using complex_elem = std::variant <
>>> std::enable_if_t<
>>> is_unique_from_after_on<Head, Types...>(), Head*
>>> >,
>>> std::enable_if_t <
>>> is_unique_from_after_on<Types...>(), Types*
>>> >...
>>> >;
>>> std::array<complex_elem, (sizeof...(Types))+1> book_keeper;
>>> template<typename Head, typename ... Types>
>>> constexpr tuple(Head&& a, Types&&... b ) :head{ std::forward<Head>(a) }, tuple_impl<Types>{std::forward<Types>(b)}...,
>>> book_keeper{
>>> &head, &(this->tuple_impl<Types>::head)...}
>>> {
>>>
>>> }
>>> complex_elem operator[](size_t index) {
>>> return book_keeper[index];
>>> }
>>> };template<typename Head>struct tuple<Head>{
>>> Head head;
>>> tuple(Head&& a ) : head{ a } {}
>>> tuple(Head& a) : head{ a } {}
>>> std::variant<Head*> operator[](size_t index) {
>>> return head;
>>> }
>>> };
>>>
>>>
>>> int main() {
>>> tuple<int, double, float> list{1, 2.0, 3.0f};
>>> std::cout << *std::get<0>(list[0]) << std::endl;
>>> std::cout << *std::get<1>(list[1]) << std::endl;
>>> std::cout << *std::get<2>(list[2]) << std::endl;
>>> return 0;
>>> }
>>>
>>>
>>>
>>> On Sat, Apr 18, 2026 at 9:48 PM Jonathan Wakely via Std-Proposals <
>>> std-proposals_at_[hidden]> wrote:
>>>
>>>>
>>>>
>>>> On Sat, 18 Apr 2026, 11:01 Giuseppe D'Angelo via Std-Proposals, <
>>>> std-proposals_at_[hidden]> wrote:
>>>>
>>>>> Hello,
>>>>>
>>>>> On 18/04/2026 05:04, Muneem via Std-Proposals wrote:
>>>>> > I updated my proposal:https://docs.google.com/document/d/1srd5nKI-
>>>>> > QZy0vpUdkQoD45JyKIDWhom8/edit?
>>>>> > usp=sharing&ouid=114869935649093915681&rtpof=true&sd=true <https://
>>>>> > docs.google.com/document/d/1srd5nKI-QZy0vpUdkQoD45JyKIDWhom8/edit?
>>>>> > usp=sharing&ouid=114869935649093915681&rtpof=true&sd=true>
>>>>> > Thank you a lot to everyone for giving their feedback that led me to
>>>>> > refine my proposal
>>>>>
>>>>> First and foremost: this isn't a proposal. It's just an abstract idea.
>>>>> A
>>>>> proposal has to go in detail: discuss tradeoffs, provide a reference
>>>>> implementation, tentative wording.
>>>>>
>>>>>
>>>>> In 2.1 there's this claim:
>>>>>
>>>>> > Existing tuples cannot be optimized for runtime indexing without
>>>>> breaking the Application Binary Interface (ABI). Furthermore, switch
>>>>> statements are not guaranteed to be the fastest option for tuples with many
>>>>> elements.
>>>>>
>>>>> Could you show some data supporting this statement?
>>>>>
>>>>> Do you have a prototype implementation where you add such runtime
>>>>> `get(index)` to an existing std::tuple implementation, as well as a
>>>>> prototype implementation of the proposed runtime_index_tuple, and show
>>>>> that the new class brings significant performance gains (... that
>>>>> can't
>>>>> otherwise be achieved without breaking std::variant's ABI)?
>>>>>
>>>>> > This proposal introduces a specialization for std::variant<T&...>
>>>>> with the following properties:
>>>>> > No Valueless State: The variant cannot be valueless by exception.
>>>>> > Immutable Type Selection: Every std::variant<T&...> is constructed
>>>>> with a reference to a type T that it holds for its entire lifetime.
>>>>> > Assignment Logic: Assignment modifies the underlying value referred
>>>>> to by the variant rather than changing the active type.
>>>>>
>>>>> 1) These are extraordinary claims that aren't backed by extraordinary
>>>>> facts.
>>>>>
>>>>> 2) Adding support for references in std::variant deserves its own
>>>>> paper.
>>>>> It's something that was there originally and then removed by P0510.
>>>>>
>>>>
>>>>
>>>> Until this idea has been implemented and tested, this whole thread is a
>>>> waste of time.
>>>>
>>>> Try to implement it, then come back with a real proposal with numbers
>>>> to prove the claims.
>>>>
>>>>
>>>> --
>>>> Std-Proposals mailing list
>>>> Std-Proposals_at_[hidden]
>>>> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>>>>
>>>
size_t instead of std::size_t. I just wanted to fix it.
this is the github link:
https://github.com/HjaldrKhilji/Future-potential-ISO-porposals/blob/main/Runtime_Indexed_Tuples_Proposal_Official%20(1).docx
(in case your email client cant see the linked file)
On Sun, Apr 19, 2026 at 2:27 PM Muneem <itfllow123_at_[hidden]> wrote:
> I also updated my proposal to include this example. If anyone has any
> issues with it, please tell me, and I will answer everyone tomorrow and
> also all the other questions that I haven't answered yet.
>
> On Sun, Apr 19, 2026 at 1:46 PM Muneem <itfllow123_at_[hidden]> wrote:
>
>> The previous code that I posted worked on visual studio 2026, but couldnt
>> on gdb online debugger, but here version that works on gdb as well:
>> https://onlinegdb.com/IBsomUfmPI
>> #include <iostream>
>> #include <type_traits>
>> #include <variant>
>> #include <functional>
>> #include <array>
>> template<typename Head, typename ... Types>
>> struct tuple_impl :tuple_impl<Types...>
>> {
>> Head head;
>> tuple_impl(Head&& a, Types... types) :
>> tuple_impl<Types...>(types...), head{ a } {}
>> tuple_impl(Head& a, Types... types) :
>> tuple_impl<Types...>(types...), head{ a } {}
>> };
>> template<typename Head>
>> struct tuple_impl<Head> {
>> Head head;
>> tuple_impl(Head&& a) : head{ a } {}
>> tuple_impl(Head& a) : head{ a } {}
>> };
>>
>> template<typename T, typename Head_t>
>> const constexpr bool Is_unique() { // requires() couldnt work here for
>> overloading
>> return true;
>> }
>>
>> template<typename T, typename Head_t, typename... Tail>
>> const constexpr std::enable_if_t < (sizeof...(Tail) > 0), bool >
>> Is_unique() {
>> return
>> !((std::is_same_v<T, Head_t>) && (Is_unique<T, Tail...>()))
>> &&
>> ((std::is_same_v<T, Head_t>) || (Is_unique<T, Tail...>()));
>> }
>>
>>
>> template<typename Head_t, typename ... Types >
>> constexpr bool is_unique_from_after_on() {
>> return Is_unique<Head_t, Types...>();
>> };
>> template<typename Head_t>
>> constexpr bool is_unique_from_after_on() {
>> return true;
>> }
>>
>>
>>
>> template<typename Head, typename ... Types>
>> struct tuple:tuple_impl<Types>... {
>> Head head;
>>
>> using complex_elem = std::variant <
>> std::enable_if_t<
>> is_unique_from_after_on<Head, Types...>(), Head*
>> >,
>> std::enable_if_t <
>> is_unique_from_after_on<Types...>(), Types*
>> >...
>> >;
>> std::array<complex_elem, (sizeof...(Types))+1> book_keeper;
>> template<typename Head_, typename ... Types_>
>> constexpr tuple(Head_&& a, Types_&&... b ) :head{
>> std::forward<Head>(a) }, tuple_impl<Types>{std::forward<Types>(b)}...,
>> book_keeper{
>> &head, &(this->tuple_impl<Types>::head)...}
>> {
>>
>> }
>> complex_elem operator[](size_t index) {
>> return book_keeper[index];
>> }
>> };
>> template<typename Head>
>> struct tuple<Head>{
>> Head head;
>> tuple(Head&& a ) : head{ a } {}
>> tuple(Head& a) : head{ a } {}
>> std::variant<Head*> operator[](size_t index) {
>> return head;
>> }
>> };
>>
>>
>>
>> int main() {
>> tuple<int, double, float> list{1, 2.0, 3.0f};
>> std::cout << *std::get<0>(list[0]) << std::endl;
>> std::cout << *std::get<1>(list[1]) << std::endl;
>> std::cout << *std::get<2>(list[2]) << std::endl;
>> return 0;
>> }
>>
>> //the reason it didn't work was template parameter name shadowing, but it
>> still worked in visual studio 2026
>>
>> On Sun, Apr 19, 2026 at 1:01 PM Muneem <itfllow123_at_[hidden]> wrote:
>>
>>> Sorry for taking so much time for such a basic implementation, and I
>>> won't be able to answer any questions until tomorrow because I am really
>>> tired. I hope that we can continue this discussion tomorrow. I am sorry for
>>> being hesitant to give out a proper implementation sooner.
>>> This is the example implementation code:
>>>
>>> #include <iostream>#include <type_traits>#include <variant>#include <functional>#include <array>template<typename Head, typename ... Types>struct tuple_impl :tuple_impl<Types...>
>>> {
>>> Head head;
>>> tuple_impl(Head&& a, Types... types) : tuple_impl<Types...>(types...), head{ a } {}
>>> tuple_impl(Head& a, Types... types) : tuple_impl<Types...>(types...), head{ a } {}
>>> };template<typename Head>struct tuple_impl<Head> {
>>> Head head;
>>> tuple_impl(Head&& a) : head{ a } {}
>>> tuple_impl(Head& a) : head{ a } {}
>>> };
>>> template<typename T, typename Head_t>const constexpr bool Is_unique() { // requires() couldnt work here for overloading
>>> return true;
>>> }
>>> template<typename T, typename Head_t, typename... Tail>const constexpr std::enable_if_t < (sizeof...(Tail) > 0), bool > Is_unique() {
>>> return
>>> !((std::is_same_v<T, Head_t>) && (Is_unique<T, Tail...>()))
>>> &&
>>> ((std::is_same_v<T, Head_t>) || (Is_unique<T, Tail...>()));
>>> }
>>>
>>> template<typename Head_t, typename ... Types >constexpr bool is_unique_from_after_on() {
>>> return Is_unique<Head_t, Types...>();
>>> };template<typename Head_t>constexpr bool is_unique_from_after_on() {
>>> return true;
>>> }
>>>
>>>
>>> template<typename Head, typename ... Types>struct tuple:tuple_impl<Types>... {
>>> Head head;
>>>
>>> using complex_elem = std::variant <
>>> std::enable_if_t<
>>> is_unique_from_after_on<Head, Types...>(), Head*
>>> >,
>>> std::enable_if_t <
>>> is_unique_from_after_on<Types...>(), Types*
>>> >...
>>> >;
>>> std::array<complex_elem, (sizeof...(Types))+1> book_keeper;
>>> template<typename Head, typename ... Types>
>>> constexpr tuple(Head&& a, Types&&... b ) :head{ std::forward<Head>(a) }, tuple_impl<Types>{std::forward<Types>(b)}...,
>>> book_keeper{
>>> &head, &(this->tuple_impl<Types>::head)...}
>>> {
>>>
>>> }
>>> complex_elem operator[](size_t index) {
>>> return book_keeper[index];
>>> }
>>> };template<typename Head>struct tuple<Head>{
>>> Head head;
>>> tuple(Head&& a ) : head{ a } {}
>>> tuple(Head& a) : head{ a } {}
>>> std::variant<Head*> operator[](size_t index) {
>>> return head;
>>> }
>>> };
>>>
>>>
>>> int main() {
>>> tuple<int, double, float> list{1, 2.0, 3.0f};
>>> std::cout << *std::get<0>(list[0]) << std::endl;
>>> std::cout << *std::get<1>(list[1]) << std::endl;
>>> std::cout << *std::get<2>(list[2]) << std::endl;
>>> return 0;
>>> }
>>>
>>>
>>>
>>> On Sat, Apr 18, 2026 at 9:48 PM Jonathan Wakely via Std-Proposals <
>>> std-proposals_at_[hidden]> wrote:
>>>
>>>>
>>>>
>>>> On Sat, 18 Apr 2026, 11:01 Giuseppe D'Angelo via Std-Proposals, <
>>>> std-proposals_at_[hidden]> wrote:
>>>>
>>>>> Hello,
>>>>>
>>>>> On 18/04/2026 05:04, Muneem via Std-Proposals wrote:
>>>>> > I updated my proposal:https://docs.google.com/document/d/1srd5nKI-
>>>>> > QZy0vpUdkQoD45JyKIDWhom8/edit?
>>>>> > usp=sharing&ouid=114869935649093915681&rtpof=true&sd=true <https://
>>>>> > docs.google.com/document/d/1srd5nKI-QZy0vpUdkQoD45JyKIDWhom8/edit?
>>>>> > usp=sharing&ouid=114869935649093915681&rtpof=true&sd=true>
>>>>> > Thank you a lot to everyone for giving their feedback that led me to
>>>>> > refine my proposal
>>>>>
>>>>> First and foremost: this isn't a proposal. It's just an abstract idea.
>>>>> A
>>>>> proposal has to go in detail: discuss tradeoffs, provide a reference
>>>>> implementation, tentative wording.
>>>>>
>>>>>
>>>>> In 2.1 there's this claim:
>>>>>
>>>>> > Existing tuples cannot be optimized for runtime indexing without
>>>>> breaking the Application Binary Interface (ABI). Furthermore, switch
>>>>> statements are not guaranteed to be the fastest option for tuples with many
>>>>> elements.
>>>>>
>>>>> Could you show some data supporting this statement?
>>>>>
>>>>> Do you have a prototype implementation where you add such runtime
>>>>> `get(index)` to an existing std::tuple implementation, as well as a
>>>>> prototype implementation of the proposed runtime_index_tuple, and show
>>>>> that the new class brings significant performance gains (... that
>>>>> can't
>>>>> otherwise be achieved without breaking std::variant's ABI)?
>>>>>
>>>>> > This proposal introduces a specialization for std::variant<T&...>
>>>>> with the following properties:
>>>>> > No Valueless State: The variant cannot be valueless by exception.
>>>>> > Immutable Type Selection: Every std::variant<T&...> is constructed
>>>>> with a reference to a type T that it holds for its entire lifetime.
>>>>> > Assignment Logic: Assignment modifies the underlying value referred
>>>>> to by the variant rather than changing the active type.
>>>>>
>>>>> 1) These are extraordinary claims that aren't backed by extraordinary
>>>>> facts.
>>>>>
>>>>> 2) Adding support for references in std::variant deserves its own
>>>>> paper.
>>>>> It's something that was there originally and then removed by P0510.
>>>>>
>>>>
>>>>
>>>> Until this idea has been implemented and tested, this whole thread is a
>>>> waste of time.
>>>>
>>>> Try to implement it, then come back with a real proposal with numbers
>>>> to prove the claims.
>>>>
>>>>
>>>> --
>>>> Std-Proposals mailing list
>>>> Std-Proposals_at_[hidden]
>>>> https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals
>>>>
>>>
Received on 2026-04-19 10:17:51