Compiler Explorer

Source code

/**
 * Shows how to write a C++14 compile time version of of filter_map for tuples.
 *  This is similar to Ocaml's List.filter_map, but over C++ tuples lol.
 *  For a tuple<Elements...> each element that fails a user defined check
 *  is filtered out, then a functor f is applied over the non-failing elements.
 *
 * If you are using C++17 you can skip down to line 200 and ignore the 
 *  evaluator struct stuff
 */

#include <functional>
#include <tuple>
#include <utility>
#include <vector>
// Just for printing
#include <iostream>

namespace internal {
/*
 * Invoke the functor f with arguments given in t and indexed in the index
 * sequence I
 *
 * @tparam F Type of functor
 * @tparam Tuple Type of tuple containing arguments
 * @tparam I Parameter pack of an index sequence going from 0 to
 * std::tuple_size<T>::value - 1 inclusive
 * @param f functor callable
 * @param t tuple of arguments
 * @param i placeholder variable for index sequence
 */
template <class F, class Tuple, std::size_t... I>
inline constexpr decltype(auto) apply_impl(F&& f, Tuple&& t,
                                           std::index_sequence<I...> /* i */) {
    return f(std::forward<decltype(std::get<I>(t))>(std::get<I>(t))...);
}

/*
 * Call the functor f with the tuple of arguments t, like:
 *
 * f(std::get<0>(t), std::get<1>(t), ...)
 *
 * TODO: replace this with implementation in C++ std when C++17 is available
 *
 * @tparam F Type of functor
 * @tparam Tuple Type of tuple containing arguments
 * @param f functor callable
 * @param t tuple of arguments
 */
template <class F, class Tuple>
inline constexpr decltype(auto) apply(F&& f, Tuple&& t) {
    return internal::apply_impl(
        std::forward<F>(f), std::forward<Tuple>(t),
        std::make_index_sequence<
            std::tuple_size<std::remove_reference_t<Tuple>>{}>{});
}

/**
 * Evaluator for true and false cases of filtering when calling `filter_map`
 * @tparam IncludeElem
 */
template <bool IncludeElem>
struct filter_map_evaluator;

template <>
struct filter_map_evaluator<true> {
    /**
     * Base case with no more arguments left to check so the accumulated tuple
     * is returned.
     */
    template <template <typename> typename Filter, typename F,
              typename... AccArgs, typename PassArg>
    inline static auto run(F&& f, std::tuple<AccArgs...>&& acc_tuple,
                           PassArg&& arg) {
        return std::tuple_cat(std::move(acc_tuple),
                              std::make_tuple(f(std::forward<PassArg>(arg))));
    }

/*
     * `true` path where the `f` is applied to the element and it's result is
     * added to the result tuple
     *
     * @tparam Filter a struct that accepts one template parameter and has a
     * static constexpr bool member named value
     * @tparam F Type of functor
     * @tparam AccArgs Parameter pack of arguments that will be returned in the
     * final tuple
     * @tparam PassArg First template parameter peeled off from `OtherArgs` that
     * passed the check
     * @tparam CheckArg Second template parameter peeled off from `OtherArgs` to
     * check
     * @tparam OtherArgs Rest of the parameter pack of arguments
     * @param f functor callable
     * @param acc_tuple Tuple of arguments that passed filter and had `f`
     * applied to them.
     * @param arg Argument peeled from parameter pack that can now be added to
     * final tuple
     * @param curr_arg The current argument to be evaluated
     * @param args objects to be filtered and mapped
     */
    template <template <typename> typename Filter, typename F,
              typename... AccArgs, typename PassArg, typename CheckArg,
              typename... OtherArgs>
    inline static decltype(auto) run(F&& f, std::tuple<AccArgs...>&& acc_tuple,
                                     PassArg&& arg, CheckArg&& next_arg,
                                     OtherArgs&&... args) {
        return filter_map_evaluator<Filter<CheckArg>::value>::template run<
            Filter>(
            std::forward<F>(f),
            std::tuple_cat(std::move(acc_tuple),
                           std::make_tuple(f(std::forward<PassArg>(arg)))),
            std::forward<CheckArg>(next_arg), std::forward<OtherArgs>(args)...);
    }
};

template <>
struct filter_map_evaluator<false> {
    /**
     * Base case with no more arguments left to check so the accumulated tuple
     * is returned.
     */
    template <template <typename> typename Filter, typename F,
              typename... AccArgs, typename FailArg>
    inline static auto run(F&& /* f */, std::tuple<AccArgs...>&& acc_tuple,
                           FailArg&& /* arg */) {
        return std::move(acc_tuple);
    }

/*
     * `false` path where we do not add the argument to the end parameter pack
     *
     * @tparam Filter a struct that accepts one template parameter and has a
     * static constexpr bool member named value
     * @tparam F Type of functor
     * @tparam AccArgs Parameter pack of arguments that will be returned in the
     * final tuple
     * @tparam FailArg First template parameter peeled off from `OtherArgs` that
     * failed the check
     * @tparam CheckArg Second template parameter peeled off from `OtherArgs` to
     * check
     * @tparam OtherArgs Rest of the parameter pack of arguments
     * @param f functor callable
     * @param acc_tuple Tuple of arguments that passed filter and had `f`
     * applied to them.
     * @param curr_arg The current argument to be evaluated
     * @param args objects to be filtered and mapped
     */
    template <template <typename> typename Filter, typename F,
              typename... AccArgs, typename FailArg, typename CheckArg,
              typename... OtherArgs>
    inline static decltype(auto) run(F&& f, std::tuple<AccArgs...>&& acc_tuple,
                                     FailArg&& /* arg */, CheckArg&& curr_arg,
                                     OtherArgs&&... args) {
        return filter_map_evaluator<Filter<CheckArg>::value>::template run<
            Filter>(std::forward<F>(f), std::move(acc_tuple),
                    std::forward<CheckArg>(curr_arg),
                    std::forward<OtherArgs>(args)...);
    }
};

/**
 * Base case for no arguments to filter which returns an empty tuple. This is
 * only called when `filter_map` receives no inputs to traverse so it can just
 * return an empty tuple.
 * @tparam Filter a struct that accepts one template parameter and has a static
 *   constexpr bool member named value
 * @tparam F Type of functor
 * @tparam AccArgs A parameter pack of arguments
 */
template <template <typename> typename Filter, typename F, typename... AccArgs>
inline constexpr decltype(auto) filter_map_impl(
    F&& /* */, std::tuple<AccArgs...>&& /* acc_tuple */) {
    return std::tuple<>{};
}

/*
 * Subset a parameter pack by a compile time filter on the types and return a
 * tuple with an unary functor applied to each element where the filter was
 * true:
 *
 * @tparam Filter a struct that accepts one template parameter and has a static
 *   constexpr bool member named value
 * @tparam F Type of functor
 * @tparam AccArgs A parameter pack of arguments that will be returned in the
 * final tuple
 * @tparam CheckArg The first parameter in the parameter pack of `filter_map`
 * @tparam OtherArgs A parameter pack of arguments
 * @param f functor callable
 * @param acc_tuple Tuple of arguments that passed filter and had `f` applied to
 * them.
 * @param check_arg The first argument in the parameter pack given to
 * `filter_map`.
 * @param args objects to be filtered and mapped
 */
template <template <typename> typename Filter, typename F, typename... AccArgs,
          typename CheckArg, typename... OtherArgs>
inline constexpr decltype(auto) filter_map_impl(
    F&& f, std::tuple<AccArgs...>&& acc_tuple, CheckArg&& first_arg,
    OtherArgs&&... args) {
    return filter_map_evaluator<Filter<CheckArg>::value>::template run<Filter>(
        std::forward<F>(f), std::move(acc_tuple),
        std::forward<CheckArg>(first_arg), std::forward<OtherArgs>(args)...);
    /*
    NOTE:!!! If you have C++17 you can ignore all of the above
    filter_map_evaluator blahblah and instead just use this as the body,
    deleting the return above this comment.
    if constexpr (Filter<CheckArg>::value) {
        return filter_map_impl<Filter>(
            std::forward<F>(f),
            std::tuple_cat(std::move(acc_tuple),
                           std::make_tuple(f(std::forward<CheckArg>(arg)))),
            std::forward<OtherArgs>(args)...);
    } else {
        return filter_map_impl<Filter>(std::forward<F>(f), std::move(acc_tuple),
                                       std::forward<OtherArgs>(args)...);
    }
    */
}

}  // namespace internal

/*
 * Subset a tuple by a compile time filter on the types and return a
 * tuple with an unary functor applied to each element where the filter was
 * true:
 *
 * @tparam Filter a struct that accepts one template parameter and has a static
 *   constexpr bool member named value
 * @tparam F Type of functor
 * @tparam Args A parameter pack of arguments
 * @param f functor callable
 * @param args parameter pack of args
 */
template <template <typename> typename Filter, typename F, typename... Args>
inline constexpr decltype(auto) filter_map(F&& f, std::tuple<Args...>&& args) {
    return internal::apply(
        [&f](auto&&... args) {
            return internal::filter_map_impl<Filter>(f, std::tuple<>{},
                                                     std::move(args)...);
        },
        std::move(args));
}

/*
 * Subset a tuple by a compile time filter on the types and return a
 * tuple with an unary functor applied to each element where the filter was
 * true:
 *
 * @tparam Filter a struct that accepts one template parameter and has a static
 *   constexpr bool member named value
 * @tparam F Type of functor
 * @tparam Args A parameter pack of arguments
 * @param f functor callable
 * @param args parameter pack of args
 */
template <template <typename> typename Filter, typename F, typename... Args>
inline constexpr decltype(auto) filter_map(F&& f,
                                           const std::tuple<Args...>& args) {
    return internal::apply(
        [&f](auto&&... args) {
            return internal::filter_map_impl<Filter>(f, std::tuple<>{},
                                                     args...);
        },
        args);
}

/* Just helper funcs so the ASM shows up */
template <class Tp>
inline __attribute__((always_inline)) void DoNotOptimize(Tp const& value) {
    asm volatile("" : : "r,m"(value) : "memory");
}

template <class Tp>
inline __attribute__((always_inline)) void DoNotOptimize(Tp& value) {
#if defined(__clang__)
    asm volatile("" : "+r,m"(value) : : "memory");
#else
    asm volatile("" : "+m,r"(value) : : "memory");
#endif
}

#define ASM_COMMENTER(comment) __asm__("#" comment)

int main() {
    auto lazy_func = [](auto&& x) { return std::forward<decltype(x)>(x); };
    ASM_COMMENTER("begin1");
    auto test1 = filter_map<std::is_arithmetic>(
        lazy_func, lazy_func, 1.0, 2.0, std::array<double, 3>{},
        std::vector<double>{}, 3.0, 4.0);
    DoNotOptimize(test1);
    ASM_COMMENTER("end1");

ASM_COMMENTER("begin2");
    auto test2 = filter_map<std::is_arithmetic>(
        lazy_func, std::make_tuple(1, std::array<double, 3>{}, 666.0, 69.0, [](){},
                                   std::vector<double>{}, 420.0));
    DoNotOptimize(test2);
    ASM_COMMENTER("end2");

ASM_COMMENTER("begin3");
    auto test3 = filter_map<std::is_arithmetic>(lazy_func, 1.0, 2.0, lazy_func,
                                                std::vector<double>{}, 3.0, 
                                                std::vector<double>{}, 4.0, 5.0);
    DoNotOptimize(test3);
    ASM_COMMENTER("end3");

ASM_COMMENTER("begin4");
    auto test4 = filter_map<std::is_arithmetic>(lazy_func);
    DoNotOptimize(test4);
    ASM_COMMENTER("end4");

ASM_COMMENTER("begin5");
    auto test5 = filter_map<std::is_arithmetic>(lazy_func, 1.0);
    DoNotOptimize(test5);
    ASM_COMMENTER("end5");

ASM_COMMENTER("begin6");
    auto test6 = filter_map<std::is_arithmetic>(lazy_func, std::vector<double>{});
    DoNotOptimize(test6);
    ASM_COMMENTER("end6");

/* If you just want the ASM you can comment out the below */
    puts("");
    std::cout << "\ntest1 Tuple Size: "
              << std::tuple_size<std::decay_t<decltype(test1)>>::value;
    std::cout << "\nTuple Vals (0): " << std::get<0>(test1);
    std::cout << "\nTuple Vals (1): " << std::get<1>(test1);
    std::cout << "\nTuple Vals (2): " << std::get<2>(test1);
    std::cout << "\nTuple Vals (3): " << std::get<3>(test1);

puts("");
    std::cout << "\ntest2 Tuple Size: "
              << std::tuple_size<std::decay_t<decltype(test2)>>::value;
    std::cout << "\nTuple Vals (0): " << std::get<0>(test2);
    std::cout << "\nTuple Vals (1): " << std::get<1>(test2);
    std::cout << "\nTuple Vals (2): " << std::get<2>(test2);
    std::cout << "\nTuple Vals (3): " << std::get<3>(test2);

puts("");
    std::cout << "\ntest3 Tuple Size: "
              << std::tuple_size<std::decay_t<decltype(test3)>>::value;
    std::cout << "\nTuple Vals (0): " << std::get<0>(test3);
    std::cout << "\nTuple Vals (1): " << std::get<1>(test3);
    std::cout << "\nTuple Vals (2): " << std::get<2>(test3);
    std::cout << "\nTuple Vals (3): " << std::get<3>(test3);
    std::cout << "\nTuple Vals (4): " << std::get<4>(test3);
    puts("");
    std::cout << "\ntest4 Tuple Size: "
              << std::tuple_size<std::decay_t<decltype(test4)>>::value;

return 0;
}