Date: Sun, 19 Apr 2026 13:01:13 +0500
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
>
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:01:29