#include <cassert>

#include <utility>
#include <iostream>
#include <tuple>

// Named tuple for C++
// Example code from http://vitiy.info/
// Written by Victor Laskin (victor.laskin@gmail.com)

// Parts of code were taken from: https://gist.github.com/Manu343726/081512c43814d098fe4b

namespace foonathan {
    namespace string_id {
        namespace detail
        {
            using hash_type = std::uint64_t;
            
            constexpr hash_type fnv_basis = 14695981039346656037ull;
            constexpr hash_type fnv_prime = 109951162821ull;
            
            // FNV-1a 64 bit hash
            constexpr hash_type sid_hash(const char *str, hash_type hash = fnv_basis) noexcept
            {
                return *str ? sid_hash(str + 1, (hash ^ *str) * fnv_prime) : hash;
            }
        }
    }
} // foonathan::string_id::detail


    namespace fn_detail {
        
         /// Named parameter (could be empty!)
        template <typename Hash, typename... Ts>
        struct named_param : public std::tuple<std::decay_t<Ts>...> {
            using hash = Hash;                                                              ///< key
            
            named_param(Ts&&... ts) : std::tuple<std::decay_t<Ts>...>(std::forward<Ts>(ts)...){ };        ///< constructor
            
            template <typename P>
            named_param<Hash,P> operator=(P&& p){ return named_param<Hash,P>(std::forward<P>(p)); };
            
            
        };
    
        template <typename Hash>
        using make_named_param = named_param<Hash>;
        
        

        
        /// Named tuple is just tuple of named params
        template <typename... Params>
        struct named_tuple : public std::tuple<Params...>
        {
            
            template <typename... Args>
            named_tuple(Args&&... args) : std::tuple<Args...>(std::forward<Args>(args)...) {}
            
            static const std::size_t error = -1;
            
            template<std::size_t I = 0, typename Hash>
            constexpr typename std::enable_if<I == sizeof...(Params), const std::size_t>::type
            static get_element_index()
            {
                return error;
            }
            
            template<std::size_t I = 0, typename Hash>
            constexpr typename std::enable_if<I < sizeof...(Params), const std::size_t>::type
            static get_element_index()
            {
                using elementType = typename std::tuple_element<I, std::tuple<Params...>>::type;
                //return (typeid(typename elementType::hash) == typeid(Hash)) ? I : get_element_index<I + 1, Hash>();
                return (std::is_same<typename elementType::hash, Hash>::value) ? I : get_element_index<I + 1, Hash>();
            }
            
            template<typename Hash>
            const auto& get() const
            {
                constexpr std::size_t index = get_element_index<0, Hash>();
                static_assert((index != error), "Wrong named tuple key");
                auto& param = (std::get< index >(static_cast<const std::tuple<Params...>&>(*this)));
                return std::get<0>( param );
            }
            
            template<typename NP>
            const auto& operator[](NP&& param)
            {
                return get<typename NP::hash>();
            }
             
        };
        
            

    }
    
    template <typename... Args>
    auto make_named_tuple(Args&&... args)
    {
        return fn_detail::named_tuple<Args...>(std::forward<Args>(args)...);
    }
    
#define param(x) fn_detail::make_named_param< std::integral_constant<foonathan::string_id::detail::hash_type, foonathan::string_id::detail::sid_hash(x)> >{}


auto foo() {
     return make_named_tuple(param("x") = 10, param("y") = 20, param("z") = 30);
}

int main()
{
    auto r = foo();
    assert( r[param("x")] == 10 );
    assert( r[param("y")] == 20 );
    assert( r[param("z")] == 30 );
    
    std::cout << "ok\n";
}

namespace named_tuples
{
    #define NT_DEFINE_FIELD( T, x ) \
        struct x ## _field { T x; NT_IMPL_OPERATOR_JOIN( x ## _field  ) }; \
        inline x ## _field x ( T&& arg ) { return x##_field { std::move(arg) }; };
    #define NT_DEFINE_AUTO_FIELD( x ) \
        template<typename T> struct x ## _field { T x; NT_IMPL_OPERATOR_JOIN( x ## _field <T> ) }; \
        template<typename T> x ## _field<T> x ( T&& arg ) { return x##_field<T> { std::move(arg) }; };
    #define NT_IMPL_OPERATOR_JOIN(Tleft) \
        template<typename Tright> \
        friend ::named_tuples::join_result<Tleft,Tright> operator & ( Tleft&& a1, Tright&& a2 ) \
        { return ::named_tuples::join_result<Tleft,Tright> ( std::move(a1), std::move(a2) ); }

    template<typename T1, typename T2>
    struct join_result : T1, T2
    {
        typedef join_result<T1,T2> my_type;
        join_result( T1&&a1,  T2&&a2)
           : T1( std::move(a1)), T2(std::move(a2))
        {}
        join_result( join_result&& ) = default;
        join_result( const join_result& ) = default;
        NT_IMPL_OPERATOR_JOIN(my_type)
    };
}

//
namespace my_fields
{
NT_DEFINE_FIELD( int    , a ) // Если поле может быть только фиксированного типа
NT_DEFINE_FIELD( double , b )
NT_DEFINE_FIELD( float  , c )

NT_DEFINE_AUTO_FIELD( x ) // Если тип не определен.
NT_DEFINE_AUTO_FIELD( y )
NT_DEFINE_AUTO_FIELD( z )
}

auto foo()
{
    // ....
    return my_fields::x(10)
         & my_fields::y(20)
         & my_fields::z(30)
         & my_fields::a(40)
         & my_fields::c(60)
         ;
}

...
    auto xyz = foo();
    assert( xyz.x==10 );
    assert( xyz.y==20 );
    assert( xyz.z==30 );
    static_assert( (std::is_same_v<decltype(xyz.c), float> ), "check fixed type" );    
    static_assert( (std::is_same_v<decltype(xyz.x), decltype(10) > ), "check auto type" );