C++: is_iterable, map

helper.cpp

#include <iostream>
#include <string>
#include <vector>
#include <functional>
#include <type_traits>

template <typename T, typename = void>
struct is_iterable : std::false_type {};

template <typename T>
struct is_iterable<T, std::void_t<decltype(std::begin(std::declval<T&>())),
                                  decltype(std::end(std::declval<T&>())),
                                  decltype(++std::declval<decltype(std::begin(std::declval<T&>()))&>()), // operator ++
                                  decltype(void(*begin(std::declval<T&>()))) //operator *
                                 > > : std::true_type {};


template <typename T>
constexpr bool is_iterable_v = is_iterable<T>::value;

template<typename F, template<typename> typename T, typename A, 
         typename B = decltype(std::declval<F&>()(std::declval<A&>())),
         typename = std::enable_if_t<is_iterable_v<T<A>>>,
         typename = decltype(std::declval<T<B>&>().push_back(std::declval<B&>()) )
         >
T<B> map(T<A> c, F f) {    
    T<B> result;
    for(A& a: c) {
        result.push_back(f(a));
    }
    
    return std::move(result);
}


// template<typename F, template<typename> typename T, typename A, 
//          typename B = std::invoke_result_t<F,A>>
// T<B> map(T<A> c, F f) {
//     static_assert(is_iterable<T<A>>::value);
    
//     return T<B>();
// }

// template<typename F, template<typename> typename T, typename A>
// auto map(T<A> c, F f) -> T<decltype(f(std::declval<A>()))> {
//     using B = decltype(f(std::declval<A>()));
//     static_assert(is_iterable<T<A>>::value);
    
//     return T<B>();
// }

int main()
{
    map(std::vector{1,2}, [](auto i){return i+1;});
    // map(std::set{1,2}, [](auto i){return i+1;});
}