libostd/ostd/algorithm.hh

/* Algorithms for libostd.
 *
 * This file is part of libostd. See COPYING.md for futher information.
 */

#ifndef OSTD_ALGORITHM_HH
#define OSTD_ALGORITHM_HH

#include <cmath>
#include <utility>
#include <functional>
#include <type_traits>
#include <algorithm>

#include "ostd/range.hh"

namespace ostd {

/* partitioning */

/** @brief Partitions a range.
 *
 * Given a predicate `pred`, this rearranges the range so that items for
 * which the predicate returns true are in the first part of the range.
 *
 * The range must be at least ostd::forward_range_tag. The range must also
 * meet the conditions of ostd::is_range_element_swappable.
 *
 * The predicate is applied `N` times and the swap is done at most `N` times.
 *
 * @returns The second part of the range.
 */
template<typename R, typename U>
inline R partition(R range, U pred) {
    static_assert(
        is_range_element_swappable<R>,
        "The range element accessors must allow swapping"
    );
    R ret = range;
    for (; !range.empty(); range.pop_front()) {
        if (pred(range.front())) {
            using std::swap;
            swap(range.front(), ret.front());
            ret.pop_front();
        }
    }
    return ret;
}

/** @brief A pipeable version of ostd::partition().
 *
 * The predicate is forwarded.
 */
template<typename F>
inline auto partition(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return partition(obj, std::forward<F>(func));
    };
}

/** @brief Checks if a range is partitioned as in ostd::partition().
 *
 * First, all elements matching `pred` are skipped and then if any of
 * the elements following that match `pred`, false is returned. Otherwise,
 * true is returned.
 *
 * The predicate is applied at most `N` times.
 */
template<typename R, typename P>
inline bool is_partitioned(R range, P pred) {
    for (; !range.empty() && pred(range.front()); range.pop_front());
    for (; !range.empty(); range.pop_front()) {
        if (pred(range.front())) {
            return false;
        }
    }
    return true;
}

/** @brief A pipeable version of ostd::is_partitioned().
 *
 * The predicate is forwarded.
 */
template<typename F>
inline auto is_partitioned(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return is_partitioned(obj, std::forward<F>(func));
    };
}

/* sorting */

namespace detail {
    template<typename R, typename C>
    static void insort(R range, C &compare) {
        range_size_t<R> rlen = range.size();
        for (range_size_t<R> i = 1; i < rlen; ++i) {
            range_size_t<R> j = i;
            range_value_t<R> v{std::move(range[i])};
            while (j > 0 && !compare(range[j - 1], v)) {
                range[j] = std::move(range[j - 1]);
                --j;
            }
            range[j] = std::move(v);
        }
    }

    template<typename R, typename C>
    static void hs_sift_down(
        R range, range_size_t<R> s, range_size_t<R> e, C &compare
    ) {
        range_size_t<R> r = s;
        while ((r * 2 + 1) <= e) {
            range_size_t<R> ch = r * 2 + 1;
            range_size_t<R> sw = r;
            if (compare(range[sw], range[ch])) {
                sw = ch;
            }
            if (((ch + 1) <= e) && compare(range[sw], range[ch + 1])) {
                sw = ch + 1;
            }
            if (sw != r) {
                using std::swap;
                swap(range[r], range[sw]);
                r = sw;
            } else {
                return;
            }
        }
    }

    template<typename R, typename C>
    static void heapsort(R range, C &compare) {
        range_size_t<R> len = range.size();
        range_size_t<R> st = (len - 2) / 2;
        for (;;) {
            detail::hs_sift_down(range, st, len - 1, compare);
            if (st-- == 0) {
                break;
            }
        }
        range_size_t<R> e = len - 1;
        while (e > 0) {
            using std::swap;
            swap(range[e], range[0]);
            --e;
            detail::hs_sift_down(range, 0, e, compare);
        }
    }

    template<typename R, typename C>
    static void introloop(R range, C &compare, range_size_t<R> depth) {
        using std::swap;
        if (range.size() <= 10) {
            detail::insort(range, compare);
            return;
        }
        if (depth == 0) {
            detail::heapsort(range, compare);
            return;
        }
        swap(range[range.size() / 2], range.back());
        range_size_t<R> pi = 0;
        R pr = range;
        pr.pop_back();
        for (; !pr.empty(); pr.pop_front()) {
            if (compare(pr.front(), range.back())) {
                swap(pr.front(), range[pi++]);
            }
        }
        swap(range[pi], range.back());
        detail::introloop(range.slice(0, pi), compare, depth - 1);
        detail::introloop(range.slice(pi + 1), compare, depth - 1);
    }

    template<typename R, typename C>
    inline void introsort(R range, C &compare) {
        detail::introloop(range, compare, static_cast<range_size_t<R>>(
            2 * (std::log(range.size()) / std::log(2))
        ));
    }
} /* namespace detail */

/** @brief Sorts a range given a comparison function.
 *
 * The range must be at least ostd::finite_random_access_range_tag. The
 * comparison function takes two `ostd::range_reference_t<R>` and must
 * return a boolean equivalent to `a < b` for ascending order.
 *
 * The items are swapped in the range, which means the range must also
 * meet the conditions of ostd::is_range_element_swappable.
 *
 * The worst-case and average performance of this algorithm os `O(n log n)`.
 * The best-case performance is `O(n)`. This happens when the range is small
 * enough and already sorted (insertion sort is used for small ranges).
 *
 * The actual algorithm used is a hybrid algorithm between quicksort and
 * heapsort (intosort) with insertion sort for small ranges.
 *
 * @see ostd::sort()
 */
template<typename R, typename C>
inline R sort_cmp(R range, C compare) {
    static_assert(
        is_range_element_swappable<R>,
        "The range element accessors must allow swapping"
    );
    detail::introsort(range, compare);
    return range;
}

/** @brief A pipeable version of ostd::sort_cmp().
 *
 * The comparison function is forwarded.
 */
template<typename C>
inline auto sort_cmp(C &&compare) {
    return [compare = std::forward<C>(compare)](auto &obj) mutable {
        return sort_cmp(obj, std::forward<C>(compare));
    };
}

/** @brief Like ostd::sort_cmp() using `std::less<ostd::range_value_t<R>>{}`. */
template<typename R>
inline R sort(R range) {
    static_assert(
        is_range_element_swappable<R>,
        "The range element accessors must allow swapping"
    );
    return sort_cmp(range, std::less<range_value_t<R>>{});
}

/** @brief A pipeable version of ostd::sort(). */
inline auto sort() {
    return [](auto &obj) { return sort(obj); };
}

/* min/max(_element) */

/** @brief Finds the smallest element in the range.
 *
 * It works like std::min_element(). The range must be at least
 * ostd::forward_range_tag. The `<` operator is used for comparisons.
 *
 * @see ostd::min_element_cmp(), ostd::max_element()
 */
template<typename R>
inline R min_element(R range) {
    R r = range;
    for (; !range.empty(); range.pop_front()) {
        if (std::min(r.front(), range.front()) == range.front()) {
            r = range;
        }
    }
    return r;
}

/** @brief Finds the smallest element in the range.
 *
 * It works like std::min_element. The range must be at least
 * ostd::forward_range_tag. The `compare` function is used for comparisons.
 *
 * @see ostd::min_element(), ostd::max_element_cmp()
 */
template<typename R, typename C>
inline R min_element_cmp(R range, C compare) {
    R r = range;
    for (; !range.empty(); range.pop_front()) {
        if (std::min(r.front(), range.front(), compare) == range.front()) {
            r = range;
        }
    }
    return r;
}

/** @brief A pipeable version of ostd::min_element(). */
inline auto min_element() {
    return [](auto &obj) {
        return min_element(obj);
    };
}

/** @brief A pipeable version of ostd::min_element_cmp().
 *
 * The comparison function is forwarded.
 */
template<typename C>
inline auto min_element_cmp(C &&compare) {
    return [compare = std::forward<C>(compare)](auto &obj) mutable {
        return min_element_cmp(obj, std::forward<C>(compare));
    };
}

/** @brief Finds the largest element in the range.
 *
 * It works like std::max_element(). The range must be at least
 * ostd::forward_range_tag. The `<` operator is used for comparisons.
 *
 * @see ostd::max_element_cmp(), ostd::min_element()
 */
template<typename R>
inline R max_element(R range) {
    R r = range;
    for (; !range.empty(); range.pop_front()) {
        if (std::max(r.front(), range.front()) == range.front()) {
            r = range;
        }
    }
    return r;
}

/** @brief Finds the largest element in the range.
 *
 * It works like std::max_element. The range must be at least
 * ostd::forward_range_tag. The `compare` function is used for comparisons.
 *
 * @see ostd::max_element(), ostd::min_element_cmp()
 */
template<typename R, typename C>
inline R max_element_cmp(R range, C compare) {
    R r = range;
    for (; !range.empty(); range.pop_front()) {
        if (std::max(r.front(), range.front(), compare) == range.front()) {
            r = range;
        }
    }
    return r;
}

/** @brief A pipeable version of ostd::max_element(). */
inline auto max_element() {
    return [](auto &obj) {
        return max_element(obj);
    };
}

/** @brief A pipeable version of ostd::max_element_cmp().
 *
 * The comparison function is forwarded.
 */
template<typename C>
inline auto max_element_cmp(C &&compare) {
    return [compare = std::forward<C>(compare)](auto &obj) mutable {
        return max_element_cmp(obj, std::forward<C>(compare));
    };
}

/* lexicographical compare */

/** @brief Like std::lexicographical_compare(), but for ranges.
 *
 * This version uses the `<` operator for comparisons. This algorithm
 * is not multi-pass, so an ostd::input_range_tag is perfectly fine here.
 *
 * @see ostd::lexicographical_compare_cmp()
 */
template<typename R1, typename R2>
inline bool lexicographical_compare(R1 range1, R2 range2) {
    while (!range1.empty() && !range2.empty()) {
        if (range1.front() < range2.front()) {
            return true;
        }
        if (range2.front() < range1.front()) {
            return false;
        }
        range1.pop_front();
        range2.pop_front();
    }
    return (range1.empty() && !range2.empty());
}

/** @brief A pipeable version of ostd::lexicographical_compare().
 *
 * The range is forwarded.
 */
template<typename R>
inline auto lexicographical_compare(R &&range) {
    return [range = std::forward<R>(range)](auto &obj) mutable {
        return lexicographical_compare(obj, std::forward<R>(range));
    };
}

/** @brief Like std::lexicographical_compare(), but for ranges.
 *
 * This version uses the `compare` function for comparisons. This algorithm
 * is not multi-pass, so an ostd::input_range_tag is perfectly fine here.
 *
 * @see ostd::lexicographical_compare()
 */
template<typename R1, typename R2, typename C>
inline bool lexicographical_compare_cmp(R1 range1, R2 range2, C compare) {
    while (!range1.empty() && !range2.empty()) {
        if (compare(range1.front(), range2.front())) {
            return true;
        }
        if (compare(range2.front(), range1.front())) {
            return false;
        }
        range1.pop_front();
        range2.pop_front();
    }
    return (range1.empty() && !range2.empty());
}

/** @brief A pipeable version of ostd::lexicographical_compare_cmp().
 *
 * The range and comparison function are forwarded.
 */
template<typename R, typename C>
inline auto lexicographical_compare_cmp(R &&range, C &&compare) {
    return [
        range = std::forward<R>(range), compare = std::forward<C>(compare)
    ](auto &obj) mutable {
        return lexicographical_compare_cmp(
            obj, std::forward<R>(range), std::forward<C>(compare)
        );
    };
}

/* algos that don't change the range */

/** @brief Executes `func` on each element of `range`.
 *
 * The `func` is called like `func(range.front())`. The algorithm is
 * not multi-pass, so an ostd::input_range_tag is perfectly fine.
 *
 * @returns The `func` by move.
 */
template<typename R, typename F>
inline F for_each(R range, F func) {
    for (; !range.empty(); range.pop_front()) {
        func(range.front());
    }
    return std::move(func);
}

/** @brief A pipeable version of ostd::for_each().
 *
 * The function is forwarded.
 */
template<typename F>
inline auto for_each(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return for_each(obj, std::forward<F>(func));
    };
}

/** @brief Checks if every element of `range` matches `pred`.
 *
 * The `pred` has to return true when called like `pred(range.front())`.
 * If it doesn't, `false` is returned.
 *
 * The predicate is called at most `N` times, where `N` is the range length.
 * The range is an ostd::input_range_tag or better.
 *
 * @see ostd::any_of(), ostd::none_of()
 */
template<typename R, typename P>
inline bool all_of(R range, P pred) {
    for (; !range.empty(); range.pop_front()) {
        if (!pred(range.front())) {
            return false;
        }
    }
    return true;
}

/** @brief A pipeable version of ostd::all_of().
 *
 * The function is forwarded.
 */
template<typename F>
inline auto all_of(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return all_of(obj, std::forward<F>(func));
    };
}

/** @brief Checks if any element of `range` matches `pred`.
 *
 * As soon as `pred` returns true when called like `pred(range.front())`,
 * this returns true. Otherwise it returns false.
 *
 * The predicate is called at most `N` times, where `N` is the range length.
 * The range is an ostd::input_range_tag or better.
 *
 * @see ostd::all_of(), ostd::none_of()
 */
template<typename R, typename P>
inline bool any_of(R range, P pred) {
    for (; !range.empty(); range.pop_front())
        if (pred(range.front())) return true;
    return false;
}

/** @brief A pipeable version of ostd::any_of().
 *
 * The function is forwarded.
 */
template<typename F>
inline auto any_of(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return any_of(obj, std::forward<F>(func));
    };
}

/** @brief Checks if no element of `range` matches `pred`.
 *
 * As soon as `pred` returns true when called like `pred(range.front())`,
 * this returns false. Otherwise it returns true.
 *
 * The predicate is called at most `N` times, where `N` is the range length.
 * The range is an ostd::input_range_tag or better.
 *
 * @see ostd::all_of(), ostd::any_of()
 */
template<typename R, typename P>
inline bool none_of(R range, P pred) {
    for (; !range.empty(); range.pop_front())
        if (pred(range.front())) return false;
    return true;
}

/** @brief A pipeable version of ostd::none_of().
 *
 * The function is forwarded.
 */
template<typename F>
inline auto none_of(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return none_of(obj, std::forward<F>(func));
    };
}

/** @brief Finds `v` in `range`.
 *
 * Iterates the range and as soon as `range.front()` is equal to `v`,
 * returns `range`. The `range` is at least ostd::input_range_tag.
 *
 * @sse ostd::find_last(), ostd::find_if(), ostd::find_if_not(),
 *      ostd::find_one_of()
 */
template<typename R, typename T>
inline R find(R range, T const &v) {
    for (; !range.empty(); range.pop_front()) {
        if (range.front() == v) {
            break;
        }
    }
    return range;
}

/** @brief A pipeable version of ostd::find().
 *
 * The `v` is forwarded.
 */
template<typename T>
inline auto find(T &&v) {
    return [v = std::forward<T>(v)](auto &obj) mutable {
        return find(obj, std::forward<T>(v));
    };
}

/** @brief Finds the last occurence of `v` in `range`.
 *
 * Keeps attempting ostd::find() from the point of previous ostd::find()
 * until no next matching element is found. As this algorithm has to save
 * the previous result of ostd::find() in case nothing is found next, this
 * algortihm requires `range` to be at least ostd::forward_range_tag.
 *
 * @sse ostd::find(), ostd::find_if(), ostd::find_if_not(),
 *      ostd::find_one_of()
 */
template<typename R, typename T>
inline R find_last(R range, T const &v) {
    range = find(range, v);
    if (!range.empty()) {
        for (;;) {
            R prev = range;
            prev.pop_front();
            R r = find(prev, v);
            if (r.empty()) {
                break;
            }
            range = r;
        }
    }
    return range;
}

/** @brief A pipeable version of ostd::find_last().
 *
 * The `v` is forwarded.
 */
template<typename T>
inline auto find_last(T &&v) {
    return [v = std::forward<T>(v)](auto &obj) mutable {
        return find_last(obj, std::forward<T>(v));
    };
}

/** @brief Finds an element matching `pred` in `range`.
 *
 * Iterates the range and as soon as `pred(range.front())` is true,
 * returns `range`. The `range` is at least ostd::input_range_tag.
 *
 * @sse ostd::find(), ostd::find_last(), ostd::find_if_not(),
 *      ostd::find_one_of()
 */
template<typename R, typename P>
inline R find_if(R range, P pred) {
    for (; !range.empty(); range.pop_front()) {
        if (pred(range.front())) {
            break;
        }
    }
    return range;
}

/** @brief A pipeable version of ostd::find_if().
 *
 * The `pred` is forwarded.
 */
template<typename P>
inline auto find_if(P &&pred) {
    return [pred = std::forward<P>(pred)](auto &obj) mutable {
        return find_if(obj, std::forward<P>(pred));
    };
}

/** @brief Finds an element not matching `pred` in `range`.
 *
 * Iterates the range and as soon as `!pred(range.front())` is true,
 * returns `range`. The `range` is at least ostd::input_range_tag.
 *
 * @sse ostd::find(), ostd::find_last(), ostd::find_if(), ostd::find_one_of()
 */
template<typename R, typename P>
inline R find_if_not(R range, P pred) {
    for (; !range.empty(); range.pop_front()) {
        if (!pred(range.front())) {
            break;
        }
    }
    return range;
}

/** @brief A pipeable version of ostd::find_if_not().
 *
 * The `pred` is forwarded.
 */
template<typename P>
inline auto find_if_not(P &&pred) {
    return [pred = std::forward<P>(pred)](auto &obj) mutable {
        return find_if_not(obj, std::forward<P>(pred));
    };
}

/** @brief Finds the first element matching any element in `values`.
 *
 * The `compare` function is used to compare the values. The `range`
 * is iterated and each item is compared with each item in `values`
 * and once a match is found, `range` is returned.
 *
 * The `range` has to be at least ostd::input_iterator_tag as it's
 * iterated only once, `values` has to be ostd::forward_range_tag or
 * better.
 *
 * The time complexity is up to `N * M` where `N` is the length of
 * `range` and `M` is the length of `values`.
 *
 * Use ostd::find_one_of() if you want to use the `==` operator
 * instead of calling `compare`.
 *
 * @sse ostd::find(), ostd::find_last(), ostd::find_if(), ostd::find_if_not(),
 *      ostd::find_one_of()
 */
template<typename R1, typename R2, typename C>
inline R1 find_one_of_cmp(R1 range, R2 values, C compare) {
    for (; !range.empty(); range.pop_front()) {
        for (R2 rv = values; !rv.empty(); rv.pop_front()) {
            if (compare(range.front(), rv.front())) {
                return range;
            }
        }
    }
    return range;
}

/** @brief A pipeable version of ostd::find_one_of_cmp().
 *
 * The `values` and `compare` are forwarded.
 */
template<typename R, typename C>
inline auto find_one_of_cmp(R &&values, C &&compare) {
    return [
        values = std::forward<R>(values), compare = std::forward<C>(compare)
    ](auto &obj) mutable {
        return find_one_of_cmp(
            obj, std::forward<R>(values), std::forward<C>(compare)
        );
    };
}

/** @brief Finds the first element matching any element in `values`.
 *
 * The `==` operator is used to compare the values. The `range`
 * is iterated and each item is compared with each item in `values`
 * and once a match is found, `range` is returned.
 *
 * The `range` has to be at least ostd::input_iterator_tag as it's
 * iterated only once, `values` has to be ostd::forward_range_tag or
 * better.
 *
 * The time complexity is up to `N * M` where `N` is the length of
 * `range` and `M` is the length of `values`.
 *
 * Use ostd::find_one_of_cmp() if you want to use a comparison
 * function instead of the `==` operator.
 *
 * @sse ostd::find(), ostd::find_last(), ostd::find_if(), ostd::find_if_not(),
 *      ostd::find_one_of_cmp()
 */
template<typename R1, typename R2>
inline R1 find_one_of(R1 range, R2 values) {
    for (; !range.empty(); range.pop_front()) {
        for (R2 rv = values; !rv.empty(); rv.pop_front()) {
            if (range.front() == rv.front()) {
                return range;
            }
        }
    }
    return range;
}
template<typename R>
inline auto find_one_of(R &&values) {
    return [values = std::forward<R>(values)](auto &obj) mutable {
        return find_one_of(obj, std::forward<R>(values));
    };
}

template<typename R, typename T>
inline range_size_t<R> count(R range, T const &v) {
    range_size_t<R> ret = 0;
    for (; !range.empty(); range.pop_front()) {
        if (range.front() == v) {
            ++ret;
        }
    }
    return ret;
}

template<typename T>
inline auto count(T &&v) {
    return [v = std::forward<T>(v)](auto &obj) mutable {
        return count(obj, std::forward<T>(v));
    };
}

template<typename R, typename P>
inline range_size_t<R> count_if(R range, P pred) {
    range_size_t<R> ret = 0;
    for (; !range.empty(); range.pop_front()) {
        if (pred(range.front())) {
            ++ret;
        }
    }
    return ret;
}

template<typename F>
inline auto count_if(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return count_if(obj, std::forward<F>(func));
    };
}

template<typename R, typename P>
inline range_size_t<R> count_if_not(R range, P pred) {
    range_size_t<R> ret = 0;
    for (; !range.empty(); range.pop_front()) {
        if (!pred(range.front())) {
            ++ret;
        }
    }
    return ret;
}

template<typename F>
inline auto count_if_not(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return count_if_not(obj, std::forward<F>(func));
    };
}

template<typename R>
inline bool equal(R range1, R range2) {
    for (; !range1.empty(); range1.pop_front()) {
        if (range2.empty() || (range1.front() != range2.front())) {
            return false;
        }
        range2.pop_front();
    }
    return range2.empty();
}

template<typename R>
inline auto equal(R &&range) {
    return [range = std::forward<R>(range)](auto &obj) mutable {
        return equal(obj, std::forward<R>(range));
    };
}

/* algos that modify ranges or work with output ranges */

template<typename R1, typename R2>
inline R2 copy(R1 irange, R2 orange) {
    range_put_all(orange, irange);
    return orange;
}

template<typename R1, typename R2, typename P>
inline R2 copy_if(R1 irange, R2 orange, P pred) {
    for (; !irange.empty(); irange.pop_front()) {
        if (pred(irange.front())) {
            orange.put(irange.front());
        }
    }
    return orange;
}

template<typename R1, typename R2, typename P>
inline R2 copy_if_not(R1 irange, R2 orange, P pred) {
    for (; !irange.empty(); irange.pop_front()) {
        if (!pred(irange.front())) {
            orange.put(irange.front());
        }
    }
    return orange;
}

template<typename R1, typename R2>
inline R2 move(R1 irange, R2 orange) {
    for (; !irange.empty(); irange.pop_front()) {
        orange.put(std::move(irange.front()));
    }
    return orange;
}

template<typename R>
inline void reverse(R range) {
    while (!range.empty()) {
        using std::swap;
        swap(range.front(), range.back());
        range.pop_front();
        range.pop_back();
    }
}

template<typename R1, typename R2>
inline R2 reverse_copy(R1 irange, R2 orange) {
    for (; !irange.empty(); irange.pop_back()) {
        orange.put(irange.back());
    }
    return orange;
}

template<typename R, typename T>
inline void fill(R range, T const &v) {
    for (; !range.empty(); range.pop_front()) {
        range.front() = v;
    }
}

template<typename R, typename F>
inline void generate(R range, F gen) {
    for (; !range.empty(); range.pop_front()) {
        range.front() = gen();
    }
}

template<typename R1, typename R2>
inline std::pair<R1, R2> swap_ranges(R1 range1, R2 range2) {
    while (!range1.empty() && !range2.empty()) {
        using std::swap;
        swap(range1.front(), range2.front());
        range1.pop_front();
        range2.pop_front();
    }
    return std::make_pair(range1, range2);
}

template<typename R, typename T>
inline void iota(R range, T value) {
    for (; !range.empty(); range.pop_front()) {
        range.front() = value++;
    }
}

template<typename R, typename T>
inline T foldl(R range, T init) {
    for (; !range.empty(); range.pop_front()) {
        init = init + range.front();
    }
    return init;
}

template<typename R, typename T, typename F>
inline T foldl_f(R range, T init, F func) {
    for (; !range.empty(); range.pop_front()) {
        init = func(init, range.front());
    }
    return init;
}

template<typename T>
inline auto foldl(T &&init) {
    return [init = std::forward<T>(init)](auto &obj) mutable {
        return foldl(obj, std::forward<T>(init));
    };
}
template<typename T, typename F>
inline auto foldl_f(T &&init, F &&func) {
    return [
        init = std::forward<T>(init), func = std::forward<F>(func)
    ](auto &obj) mutable {
        return foldl_f(obj, std::forward<T>(init), std::forward<F>(func));
    };
}

template<typename R, typename T>
inline T foldr(R range, T init) {
    for (; !range.empty(); range.pop_back()) {
        init = init + range.back();
    }
    return init;
}

template<typename R, typename T, typename F>
inline T foldr_f(R range, T init, F func) {
    for (; !range.empty(); range.pop_back()) {
        init = func(init, range.back());
    }
    return init;
}

template<typename T>
inline auto foldr(T &&init) {
    return [init = std::forward<T>(init)](auto &obj) mutable {
        return foldr(obj, std::forward<T>(init));
    };
}
template<typename T, typename F>
inline auto foldr_f(T &&init, F &&func) {
    return [
        init = std::forward<T>(init), func = std::forward<F>(func)
    ](auto &obj) mutable {
        return foldr_f(obj, std::forward<T>(init), std::forward<F>(func));
    };
}

namespace detail {
    template<typename T, typename F, typename R>
    struct map_range: input_range<map_range<T, F, R>> {
        using range_category  = std::common_type_t<
            range_category_t<T>, finite_random_access_range_tag
        >;
        using value_type      = std::remove_reference_t<R>;
        using reference       = R;
        using size_type       = range_size_t<T>;
        using difference_type = range_difference_t<T>;

    private:
        T p_range;
        std::decay_t<F> p_func;

    public:
        map_range() = delete;
        template<typename FF>
        map_range(T const &range, FF &&func):
            p_range(range), p_func(std::forward<FF>(func)) {}

        bool empty() const { return p_range.empty(); }
        size_type size() const { return p_range.size(); }

        void pop_front() { p_range.pop_front(); }
        void pop_back() { p_range.pop_back(); }

        R front() const { return p_func(p_range.front()); }
        R back() const { return p_func(p_range.back()); }

        R operator[](size_type idx) const {
            return p_func(p_range[idx]);
        }

        map_range slice(size_type start, size_type end) const {
            return map_range(p_range.slice(start, end), p_func);
        }
        map_range slice(size_type start) const {
            return slice(start, size());
        }
    };

    template<typename R, typename F>
    using MapReturnType = decltype(
        std::declval<F>()(std::declval<range_reference_t<R>>())
    );
} /* namespace detail */

/** @brief Gets a wrapper range that maps each item by `func`.
 *
 * The resulting range is at most ostd::finite_random_access_range_tag.
 * There are no restrictions on the input range. The resulting range is
 * not mutable, it's purely input-type.
 *
 * The `reference` member type of the range is `R` where `R` is the return
 * value of `func`. The `value_type` is `std::remove_reference_t<R>`. The
 * size and difference types are preserved.
 *
 * On each access of a range item (front, back, indexing), the `func` is
 * called with the actual wrapped range's item and the result is returned.
 *
 * An example:
 *
 * ~~~{.cc}
 * auto r = ostd::map(ostd::range(5), [](auto v) { return v + 5; });
 * for (auto i: r) {
 *     ostd::writeln(i); // 5, 6, 7, 8, 9
 * }
 * ~~~
 *
 * Because the range is lazy, a new value is computed on each access, but
 * the wrapper range also needs no memory of its own.
 *
 * @see ostd::filter()
 */
template<typename R, typename F>
inline auto map(R range, F func) {
    return detail::map_range<R, F, detail::MapReturnType<R, F>>(
        range, std::move(func)
    );
}

/** @brief A pipeable version of ostd::map().
 *
 * The `func` is forwarded.
 */
template<typename F>
inline auto map(F &&func) {
    return [func = std::forward<F>(func)](auto &obj) mutable {
        return map(obj, std::forward<F>(func));
    };
}

namespace detail {
    template<typename T, typename F>
    struct filter_range: input_range<filter_range<T, F>> {
        using range_category  = std::common_type_t<
            range_category_t<T>, forward_range_tag
        >;
        using value_type      = range_value_t<T>;
        using reference       = range_reference_t<T>;
        using size_type       = range_size_t<T>;
        using difference_type = range_difference_t<T>;

    private:
        T p_range;
        std::decay_t<F> p_pred;

        void advance_valid() {
            while (!p_range.empty() && !p_pred(front())) {
                p_range.pop_front();
            }
        }

    public:
        filter_range() = delete;
        template<typename P>
        filter_range(T const &range, P &&pred):
            p_range(range), p_pred(std::forward<P>(pred))
        {
            advance_valid();
        }

        bool empty() const { return p_range.empty(); }

        void pop_front() {
            p_range.pop_front();
            advance_valid();
        }

        range_reference_t<T> front() const { return p_range.front(); }
    };

    template<typename R, typename P>
    using FilterPred = std::enable_if_t<std::is_same_v<
        decltype(std::declval<P>()(std::declval<range_reference_t<R>>())), bool
    >, P>;
} /* namespace detail */

/** @brief Gets a wrapper range that filters items by `pred`.
 *
 * The resulting range is ostd::forward_range_tag at most. The range will
 * only contains items for which `pred` returns true. What this means is
 * that upon creation, the given range is stored and all iterated until
 * an item matching `pred` is reached. On `pop_front()`, this item is
 * popped out and the same is done, i.e. again iterated until a new
 * item matching `pred` is reached.
 *
 * In other words, this is done:
 *
 * ~~~{.cc}
 * void advance(R &range, P &pred) {
 *     while (!range.empty() && !pred()) {
 *         range.pop_front();
 *     }
 * }
 *
 * constructor(R range, P pred) {
 *     store_range_and_pred(range, pred);
 *     advance(stored_range, stored_pred);
 * }
 *
 * void pop_front() {
 *     stored_range.pop_front();
 *     advance(stored_range, stored_pred);
 * }
 * ~~~
 *
 * The value, reference, size and difference types are preserved, as are
 * calls to `front()` and `empty()`.
 *
 * @see ostd::map()
 */
template<typename R, typename P>
inline auto filter(R range, P pred) {
    return detail::filter_range<R, P>(range, std::move(pred));
}

/** @brief A pipeable version of ostd::filter().
 *
 * The `pred` is forwarded.
 */
template<typename P>
inline auto filter(P &&pred) {
    return [pred = std::forward<P>(pred)](auto &obj) mutable {
        return filter(obj, std::forward<P>(pred));
    };
}

} /* namespace ostd */

#endif