Date: Sun, 19 Apr 2026 13:46:08 +0500
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
>>
>
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 08:46:24