transduders.cpp

int main(int argc, char *argv[]) {
        std::vector<unsigned> arr{1, 2, 3, 4}, out;

        const auto reduce = [](auto it, const auto end,
                               auto &&f, auto &&result) {
                using lambda_t = decltype(f);
                using value_t  = typename std::remove_reference<decltype(*it)>::type;
                using res_t    = typename std::result_of<lambda_t(decltype(result), value_t)>::type;

                while (it != end) {
                        result = f(result, *it);
                        ++it;
                }

                return result;
        };

        const auto map = [&](auto &&f, auto &col) {
                using value_t = typename std::remove_reference<decltype(col.front())>::type;

                return reduce(col.begin(), col.end(),
                              [&f](auto &&result, const auto x) {
                                      result.push_back(f(x));
                                      return result;
                              },
                              std::vector<value_t>{});
        };

        const auto mapper = [](auto &&f) {
                return [&f](auto &&result, const auto x) {
                        result.push_back(f(x));
                        return result;
                };
        };

        const auto MAPPER = [](auto &&f) {
                return [&f](auto &&combine) {
                        return [&f, &combine](auto &&result, const auto x) {
                                return combine(result, f(x));
                        };
                };
        };

        const auto append = [](auto &&arr, const auto x) {
                arr.push_back(x);
                return arr;
        };

        const auto V = reduce(arr.begin(), arr.end(),
                              [](auto &&a, const auto x) { a.push_back(x + 1); return a; },
                              std::vector<uint32_t>{});

        Print("V:", values_repr(V.data(), V.size()), "\n");

        const auto v2 = map([](const auto x) { return x + 1; }, arr);

        SLog("v2:", values_repr(v2.data(), v2.size()), "\n");

        const auto v3 = reduce(arr.begin(), arr.end(),
                               mapper([](const auto x) { return x + 1; }), std::vector<uint32_t>{});

        SLog("v3:", values_repr(v3.data(), v3.size()), "\n");

        const auto v4 = reduce(arr.begin(), arr.end(),
                               MAPPER([](const auto x) { return x + 1; })(append), std::vector<uint32_t>{});

        SLog("v4:", values_repr(v4.data(), v4.size()), "\n");

        const auto v5 = reduce(arr.begin(), arr.end(),
                               MAPPER([](const auto x) { return x * 2; })(
                                   MAPPER([](const auto x) { return x + 1; })(append)),
                               std::vector<uint32_t>());

        SLog("v5:", values_repr(v5.data(), v5.size()), "\n");

        const auto filterer = [](auto &&f) {
                return [&f](auto &&combine) {
                        return [&combine, &f](auto &&result, const auto x) {
                                return f(x) ? combine(result, x) : result;
                        };
                };
        };

        auto v51 = reduce(arr.begin(), arr.end(),
                          filterer([](const auto x) { return x > 2; })(append), std::vector<uint32_t>{});

        auto v6 = reduce(arr.begin(), arr.end(),
                         filterer([](const auto x) { return x > 2; })(
                             MAPPER([](const auto x) { return x * 2; })(append)),
                         std::vector<uint32_t>{});

        SLog("v6:", values_repr(v6.data(), v6.size()), "\n");

#if 0
        auto v7 = reduce(arr.begin(), arr.end(),
                         compose(
                             filterer([](const auto x) { return x > 2; }),
                             MAPPER([](const auto x) { return x * 2; })
                          )(append),
                         std::vector<uint32_t>{});
#endif

        return 0;
}