#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;
}