#include <iostream>
#include <list>
#include <tuple>

template<typename T>
struct depended_false : std::false_type { };

template<typename ... Ts>
struct type_list
{
  template<std::size_t N>
  using type_t = typename std::tuple_element<N, std::tuple<Ts...>>::type;

  template<typename T, std::size_t N = 0>
  constexpr static std::size_t type_ndx()
  {
    if constexpr(N == sizeof...(Ts))
      static_assert(depended_false<T>::value, "Doesn't contain type");
    else if constexpr(std::is_same_v<T, type_t<N>>)
        return N;
    else
      return type_ndx<T, N + 1>();
  }
};

template<typename T>
struct tag
{
  using value_t = typename T::value_t;
  tag() : init_value() { }
  template<typename TT> tag(TT&& __init) : init_value(std::forward<TT>(__init)) { }
  value_t init_value;
};

template<typename ... TagTypes>
struct tag_tuple : std::tuple<typename TagTypes::value_t...>
{
  using base_type = std::tuple<typename TagTypes::value_t...>;

  template<typename ... Ts>
  tag_tuple(Ts&& ... values)
    : base_type(std::forward<Ts>(values)...)
  { }

  tag_tuple(tag<TagTypes>&& ... init_values)
    : base_type(std::move(init_values.init_value)...)
  { }
};

template<typename ... TagTypes>
tag_tuple(TagTypes&& ... Tags) -> tag_tuple<TagTypes...>;

template<typename Tag, typename ... TagTypes>
typename Tag::value_t&
get(tag_tuple<TagTypes...>& t)
{
  return std::template get<type_list<TagTypes...>::template type_ndx<Tag>()>(t);
}

using namespace std;

int main()
{
  struct t1 { using value_t = float; };
  struct t2 { using value_t = float; };

  tag_tuple ttt { tag<t1>(1.f), tag<t2>(2.f) };

  cout << get<0>(ttt) << endl;

  return 0;
}