std::tuple map and foldl

tupleop.h

// c++17
#pragma once

#include <tuple>
#include <utility>

namespace detail {
    template<class T, class F, size_t ...N>
    auto constexpr tuple_map_impl(const T &t, F &&f, std::index_sequence<N...>) {
        return std::make_tuple(std::forward<F>(f)(std::get<N>(t))...);
    }

    template<size_t cnt, class T, class T1, class F>
    auto constexpr tuple_reduce_impl(const T &t, F &&f, T1 &&acc) {
        if constexpr (cnt == std::tuple_size_v<T>)
            return acc;
        else
            return tuple_reduce_impl<cnt+1>(t, std::forward<F>(f),
                std::forward<F>(f)(std::forward<T1>(acc), std::get<cnt>(t)));
    }
}

template<class T, class F>
auto constexpr tuple_map(const T &t, F &&f) {
    auto constexpr sz = std::tuple_size_v<T>;
    return detail::tuple_map_impl(t, std::forward<F>(f), std::make_index_sequence<sz>{});
}

template<class T, class F>
auto constexpr tuple_reduce(const T &t, F &&f) {
    return detail::tuple_reduce_impl<1>(t, std::forward<F>(f), std::get<0>(t));
}

template<class T, class F, class InitT>
auto constexpr tuple_reduce(const T &t, F &&f, InitT &&init) {
    return detail::tuple_reduce_impl<0>(t, std::forward<F>(f), std::forward<InitT>(init));
}

//auto v = std::make_tuple(1,2,3,4.4,4.4);
//auto vm = tuple_map(v, [](auto x) {return x+1;});
//std::cout << std::get<0>(vm) << std::endl; // 2
//std::cout << tuple_reduce(v, [](auto x, auto y){return x+y;}) << std::endl; // 14.8
// std::cout << tuple_reduce(v, [](auto x, auto y){return x+y;}, 0) << std::endl; // 14.8