История изменений

Вот на range, обгоняет Haskell в два раза на моем компьютере. Так что compose на С++ хороший, в Haskell лучше быть не может, это машинное ограничение.

Я думаю тебе не хватает опыта в статических языках и в С++. Я например С++ тоже не знаю, но бенчмарками копий std::vector не занимаюсь все же.

#include <iostream>
#include <string>
#include <ranges>

template <typename F1, typename F2> struct compose {
    F1 f1; F2 f2;
    compose(F1 f1, F2 f2) : f1{f1}, f2{f2} {}
    auto operator ()(auto x) { return f1(f2(x)); }
};

template <typename T, typename R> R sum(T x) {
    R sum = 0;
    for (R i : x) sum += i;
    return sum;
}

auto filter(auto f) {
    return [&](auto a) {
        return a | std::views::filter([&](auto x) { return f(x); });
    };
}

int main(int argc, char **argv) {
    auto v = std::views::iota(0l, atol(argv[1]) + 1);
    auto cond = compose([](auto x) { return x == 0; }, [](auto x){return x % 2;});
    std::cout << compose(sum<decltype(filter(cond)(v)), long>, filter(cond))(v) << std::endl;
}

Вот на range, обгоняет Haskell в два раза на моем компьютере. Так что compose на С++ хороший, в Haskell лучше быть не может, это машинное ограничение.

Я думаю тебе не хватает опыта в статических языках и в С++.

#include <iostream>
#include <string>
#include <ranges>

template <typename F1, typename F2> struct compose {
    F1 f1; F2 f2;
    compose(F1 f1, F2 f2) : f1{f1}, f2{f2} {}
    auto operator ()(auto x) { return f1(f2(x)); }
};

template <typename T, typename R> R sum(T x) {
    R sum = 0;
    for (R i : x) sum += i;
    return sum;
}

auto filter(auto f) {
    return [&](auto a) {
        return a | std::views::filter([&](auto x) { return f(x); });
    };
}

int main(int argc, char **argv) {
    auto v = std::views::iota(0l, atol(argv[1]) + 1);
    auto cond = compose([](auto x) { return x == 0; }, [](auto x){return x % 2;});
    std::cout << compose(sum<decltype(filter(cond)(v)), long>, filter(cond))(v) << std::endl;
}

Вот на range, обгоняет Haskell в два раза на моем компьютере. Так что compose на С++ хороший, в Haskell лучше быть не может, это машинное ограничение.

#include <iostream>
#include <string>
#include <ranges>

template <typename F1, typename F2> struct compose {
    F1 f1; F2 f2;
    compose(F1 f1, F2 f2) : f1{f1}, f2{f2} {}
    auto operator ()(auto x) { return f1(f2(x)); }
};

template <typename T, typename R> R sum(T x) {
    R sum = 0;
    for (R i : x) sum += i;
    return sum;
}

auto filter(auto f) {
    return [&](auto a) {
        return a | std::views::filter([&](auto x) { return f(x); });
    };
}

int main(int argc, char **argv) {
    auto v = std::views::iota(0l, atol(argv[1]) + 1);
    auto cond = compose([](auto x) { return x == 0; }, [](auto x){return x % 2;});
    std::cout << compose(sum<decltype(filter(cond)(v)), long>, filter(cond))(v) << std::endl;
}