#include <iostream>
#include <set>
#include <unordered_map>
#include <tuple>

// as in http://stackoverflow.com/questions/15103975/my-stdhash-for-stdtuples-any-improvements
namespace std
{
    template<typename... TTypes>
    class hash<std::tuple<TTypes...>>
    {
    private:
        typedef std::tuple<TTypes...> Tuple;

        template<int N>
        size_t operator()(Tuple value) const { return 0; }

        template<int N, typename THead, typename... TTail>
        size_t operator()(Tuple value) const
        {
            constexpr int Index = N - sizeof...(TTail) - 1;
            return hash<THead>()(std::get<Index>(value)) ^ operator()<N, TTail...>(value);
        }

    public:
        size_t operator()(Tuple value) const
        {
            return operator()<sizeof...(TTypes), TTypes...>(value);
        }
    };
}

template <class set_type, class... addl_set_types>
class Function {

private:
    static constexpr size_t set_dimensions_ = sizeof...(addl_set_types) + 1;
    std::tuple<std::set<set_type>, std::set<addl_set_types>...> sets_;
    std::unordered_map<std::tuple<set_type, addl_set_types...>, double> map_;

public:
    Function(std::set<set_type> first_set, std::set<addl_set_types>... addl_sets): sets_(first_set, addl_sets...) {};

    template <size_t index = 0>
            bool is_in_domain(std::tuple<set_type, addl_set_types...> const& t) const {
            const auto& set = std::get<index>(sets_);
            if (set.find(std::get<index>(t)) != set.end()) {
                if (index + 1 < set_dimensions_) {
                    return is_in_domain<index + 1>(t);
                }
                else return true;
            }
            return false;
        }
};

int main() {

    std::set<int> s1;
    std::set<std::string> s2;

    s1.insert(2);
    s1.insert(4);
    s2.insert("foo");
    s2.insert("bar");

    Function<int, std::string> f(s1, s2);
    auto const point = std::make_tuple(2,"bar");
    f.is_in_domain(point); // comment to compile
}