gen.h

Go to the documentation of this file.

 
/*
Copyright (c) 2026 MrXie1109
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#pragma once
#include <cmath>
#include <cstdlib>
#include <iterator>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "../core/csexc.h"
#include "../text/repr.h"
#include "./iter.h"
 
namespace console {
    template <class Derived, class T>
    class Generator {
    public:
        class iterator {
            Derived d;
 
        public:
            using value_type        = T;
            using reference         = T;
            using pointer           = void;
            using difference_type   = std::ptrdiff_t;
            using iterator_category = std::input_iterator_tag;

            iterator(const Derived &d) : d(d) {}

            reference operator*() {
                if (done()) throw StopIteration("StopIteration");
                return d.current();
            }

            iterator &operator++() {
                if (done()) return *this;
                d.advance();
                return *this;
            }

            const iterator operator++(int) {
                if (done()) return *this;
                auto old = *this;
                d.advance();
                return old;
            }

            bool operator==(const iterator &) { return d.done(); }

            bool operator!=(const iterator &) { return !d.done(); }

            T next() {
                if (done()) throw StopIteration("StopIteration");
                auto current = d.current();
                d.advance();
                return current;
            }

            bool done() { return d.done(); }
        };

        iterator iter() const {
            return iterator(static_cast<const Derived &>(*this));
        }

        iterator begin() const { return iter(); }

        iterator end() const { return iter(); }
 
        typedef T value_type; 

        bool done() { return static_cast<Derived &>(*this).done(); }

        T current() { return static_cast<Derived &>(*this).current(); }

        void advance() { static_cast<Derived &>(*this).advance(); }
    };

    template <class Derived, class T>
    typename Generator<Derived, T>::iterator iter(Generator<Derived, T> &g) {
        return g.iter();
    }

    template <class Derived, class T>
    T next(typename Generator<Derived, T>::iterator &it) {
        return it.next();
    }

    template <class Derived,
        class T,
        class CharT  = char,
        class Traits = std::char_traits<CharT>>
    std::basic_ostream<CharT, Traits> &
    print_generator(std::basic_ostream<CharT, Traits> &os,
        const Generator<Derived, T>                   &gen) {
        os << CharT('[');
        bool first = true;
        for (auto it = gen.begin(); it != gen.end(); ++it) {
            if (!first) {
                os << CharT(','), os << CharT(' ');
            }
            first = false;
            repr(*it, os);
        }
        os << CharT(']');
        return os;
    }

    template <class Derived,
        class T,
        class CharT  = char,
        class Traits = std::char_traits<CharT>>
    std::basic_ostream<CharT, Traits> &
    operator<<(std::basic_ostream<CharT, Traits> &os,
        const Generator<Derived, T>              &gen) {
        return print_generator(os, gen);
    }
 
    namespace gen {
        template <class Iter>
        class Views : public Generator<Views<Iter>,
                          typename std::iterator_traits<Iter>::value_type> {
            Iter curr;
            Iter end_;
 
        public:
            using value_type = typename std::iterator_traits<Iter>::value_type;

            Views(Iter begin, Iter end) : curr(begin), end_(end) {}

            template <class Container>
            Views(const Container &container) :
                curr(std::begin(container)), end_(std::end(container)) {}

            bool done() { return curr == end_; }

            value_type current() { return *curr; }

            void advance() {
                if (curr != end_) ++curr;
            }
        };

        template <class T>
        class List : public Generator<List<T>, T> {
            std::vector<T> data;
            size_t         idx = 0;
 
        public:
            List(std::initializer_list<T> list) : data(list) {}

            template <class Iterator>
            List(Iterator begin, Iterator end) : data(begin, end) {}

            template <class Container>
            List(const Container &container) :
                data(std::begin(container), std::end(container)) {}

            bool done() { return idx >= data.size(); }

            T current() { return data[idx]; }

            void advance() { idx++; }
        };

        template <class T>
        class Range : public Generator<Range<T>, T> {
            T start, curr, end_;
            T step;
 
        public:
            Range(T begin, T end, T step = 1) :
                start(begin), curr(begin), end_(end), step(step) {}

            Range(T end) : start(0), curr(0), end_(end), step(1) {}

            bool done() { return step > 0 ? curr >= end_ : curr <= end_; }

            T current() { return curr; }

            void advance() { curr += step; }
        };

        template <class T>
        class Repeat : public Generator<Repeat<T>, T> {
            T      value;
            size_t count;
            size_t index = 0;
 
        public:
            Repeat(T val, size_t n) : value(val), count(n) {}

            Repeat(T val) : value(val), count(size_t(-1)) {}

            bool done() { return count != size_t(-1) && index >= count; }

            T current() { return value; }

            void advance() { index++; }
        };

        template <class T>
        class Cycle : public Generator<Cycle<T>, T> {
            std::vector<T> data;
            size_t         index = 0;
 
        public:
            Cycle(std::initializer_list<T> list) : data(list) {}

            template <class Iterator>
            Cycle(Iterator begin, Iterator end) : data(begin, end) {}

            template <class Container>
            Cycle(const Container &container) :
                data(std::begin(container), std::end(container)) {}

            bool done() { return false; }

            T current() { return data[index % data.size()]; }

            void advance() { index++; }
        };

        template <class T>
        class Counter : public Generator<Counter<T>, T> {
            T      curr;
            T      step;
            size_t max_count;
            size_t count;
 
        public:
            Counter(T start = T{0}, T step = T{1}, size_t times = size_t(-1)) :
                curr(start), step(step), max_count(times), count(0) {}

            bool done() {
                return max_count != size_t(-1) && count >= max_count;
            }

            T current() { return curr; }

            void advance() {
                curr += step;
                count++;
            }
        };

        template <class Gen, class Func>
        class Map
            : public Generator<Map<Gen, Func>,
                  typename std::decay<decltype(std::declval<Func>()(
                      std::declval<typename Gen::iterator::value_type>()))>::
                      type> {
            Gen  gen;
            Func func;
            using ResultType =
                typename std::decay<decltype(func(gen.current()))>::type;
 
        public:
            Map(Gen g, Func f) : gen(g), func(f) {}

            bool done() { return gen.done(); }

            ResultType current() { return func(gen.current()); }

            void advance() { gen.advance(); }
        };

        template <class Gen, class Pred>
        class Filter : public Generator<Filter<Gen, Pred>,
                           typename Gen::iterator::value_type> {
            Gen  gen;
            Pred pred;
            bool valid;
            bool initialized;

            void find_next() {
                while (!gen.done()) {
                    if (pred(gen.current())) {
                        valid = true;
                        return;
                    }
                    gen.advance();
                }
                valid = false;
            }
 
        public:
            Filter(Gen g, Pred p) :
                gen(g), pred(p), valid(false), initialized(false) {}

            bool done() {
                if (!initialized) {
                    find_next();
                    initialized = true;
                }
                return !valid;
            }

            auto current() -> decltype(gen.current()) {
                if (!initialized) {
                    find_next();
                    initialized = true;
                }
                return gen.current();
            }

            void advance() {
                if (!valid) return;
                gen.advance();
                find_next();
            }
        };

        template <class Gen>
        class Take : public Generator<Take<Gen>, typename Gen::value_type> {
            Gen    gen;
            size_t count;
            size_t taken = 0;
 
        public:
            Take(Gen g, size_t n) : gen(g), count(n) {}

            bool done() { return taken >= count || gen.done(); }

            auto current() -> decltype(gen.current()) { return gen.current(); }

            void advance() {
                gen.advance();
                taken++;
            }
        };

        template <class Gen>
        class Drop
            : public Generator<Drop<Gen>, typename Gen::iterator::value_type> {
            Gen    gen;
            size_t count;
            bool   droped = false;

            void do_drop() {
                for (size_t i = 0; i < count && !gen.done(); i++) gen.advance();
                droped = true;
            }
 
        public:
            Drop(Gen g, size_t n) : gen(g), count(n) {}

            bool done() {
                if (!droped) do_drop();
                return gen.done();
            }

            auto current() -> decltype(gen.current()) {
                if (!droped) do_drop();
                return gen.current();
            }

            void advance() {
                if (!droped) do_drop();
                if (!gen.done()) gen.advance();
            }
        };

        template <class Gen>
        class Enumerate
            : public Generator<Enumerate<Gen>,
                  std::pair<size_t, typename Gen::iterator::value_type>> {
            Gen    gen;
            size_t index = 0;
 
        public:
            Enumerate(Gen g) : gen(g) {}

            bool done() { return gen.done(); }

            auto current() -> decltype(std::make_pair(index, gen.current())) {
                return std::make_pair(index, gen.current());
            }

            void advance() {
                gen.advance();
                index++;
            }
        };

        template <class Func>
        class Generate : public Generator<Generate<Func>,
                             decltype(std::declval<Func>()())> {
            Func             func;
            decltype(func()) curr;
 
        public:
            Generate(Func f) : func(f), curr(func()) {}

            bool done() { return false; }

            decltype(curr) current() { return curr; }

            void advance() { curr = func(); }
        };

        template <class Gen1, class Gen2>
        class Zip : public Generator<Zip<Gen1, Gen2>,
                        std::pair<typename Gen1::value_type,
                            typename Gen2::value_type>> {
            Gen1 gen1;
            Gen2 gen2;
 
        public:
            Zip(Gen1 g1, Gen2 g2) : gen1(g1), gen2(g2) {}

            bool done() { return gen1.done() || gen2.done(); }

            std::pair<typename Gen1::value_type, typename Gen2::value_type>
            current() {
                return std::make_pair(gen1.current(), gen2.current());
            }

            void advance() {
                gen1.advance();
                gen2.advance();
            }
        };

        template <class Gen, class Pred>
        class TakeWhile
            : public Generator<TakeWhile<Gen, Pred>, typename Gen::value_type> {
            Gen  gen;
            Pred pred;
            bool stopped = false;
 
            void try_advance() {
                if (stopped || gen.done()) return;
                if (!pred(gen.current())) {
                    stopped = true;
                }
            }
 
        public:
            TakeWhile(Gen g, Pred p) : gen(g), pred(p) {}

            bool done() { return gen.done() || stopped; }

            auto current() -> decltype(gen.current()) { return gen.current(); }

            void advance() {
                gen.advance();
                try_advance();
            }
        };

        template <class Gen, class Pred>
        class DropWhile
            : public Generator<DropWhile<Gen, Pred>, typename Gen::value_type> {
            Gen  gen;
            Pred pred;
            bool droped = false;

            void do_drop() {
                while (!gen.done() && pred(gen.current())) gen.advance();
                droped = true;
            }
 
        public:
            DropWhile(Gen g, Pred p) : gen(g), pred(p) {}

            bool done() {
                if (!droped) do_drop();
                return gen.done();
            }

            auto current() -> decltype(gen.current()) { return gen.current(); }

            void advance() { gen.advance(); }
        };

        template <class Iter>
        Views<Iter> views(Iter begin, Iter end) {
            return Views<Iter>(begin, end);
        }

        template <class Container>
        Views<typename Container::iterator> views(Container &container) {
            return {std::begin(container), std::end(container)};
        }

        template <class T>
        List<T> list(std::initializer_list<T> list) {
            return List<T>(list);
        }

        template <class Iterator>
        List<typename std::decay<typename Iterator::value_type>::type>
        list(Iterator begin, Iterator end) {
            return List<
                typename std::decay<typename Iterator::value_type>::type>(
                begin, end);
        }

        template <class Container>
        List<typename Container::value_type> list(Container &container) {
            return List<typename Container::value_type>(
                std::begin(container), std::end(container));
        }

        template <class T>
        Range<T> range(T begin, T end, T step = 1) {
            return Range<T>(begin, end, step);
        }

        template <class T>
        Range<T> range(T end) {
            return Range<T>(end);
        }

        template <class T>
        Repeat<T> repeat(T val, size_t n) {
            return Repeat<T>(val, n);
        }

        template <class T>
        Repeat<T> repeat(T val) {
            return Repeat<T>(val);
        }

        template <class T>
        Cycle<T> cycle(std::initializer_list<T> list) {
            return Cycle<T>(list);
        }

        template <class Iterator>
        Cycle<typename std::decay<typename Iterator::value_type>::type>
        cycle(Iterator begin, Iterator end) {
            return Cycle<
                typename std::decay<typename Iterator::value_type>::type>(
                begin, end);
        }

        template <class Container>
        Cycle<typename Container::value_type>
        cycle(const Container &container) {
            return Cycle<
                typename std::decay<typename Container::value_type>::type>(
                container.begin(), container.end());
        }

        template <class T>
        inline Counter<T>
        counter(T start = T{0}, T step = T{1}, size_t times = size_t(-1)) {
            return Counter<T>(start, step, times);
        }

        template <class Func>
        class map_t {
            Func func;
 
        public:
            explicit map_t(Func f) : func(f) {}
 
            template <class Gen>
            friend Map<Gen, Func> operator|(Gen g, map_t m) {
                return Map<Gen, Func>(g, m.func);
            }
        };

        template <class Func>
        map_t<Func> map(Func f) {
            return map_t<Func>(f);
        }

        template <class Pred>
        class filter_t {
            Pred pred;
 
        public:
            explicit filter_t(Pred p) : pred(p) {}
 
            template <class Gen>
            friend Filter<Gen, Pred> operator|(Gen g, filter_t f) {
                return Filter<Gen, Pred>(g, f.pred);
            }
        };

        template <class Pred>
        filter_t<Pred> filter(Pred pred) {
            return filter_t<Pred>(pred);
        }

        class take_t {
            size_t count;
 
        public:
            explicit take_t(size_t n) : count(n) {}
 
            template <class Gen>
            friend Take<Gen> operator|(Gen g, take_t t) {
                return Take<Gen>(g, t.count);
            }
        };

        inline take_t take(size_t n) {
            return take_t(n);
        }

        class drop_t {
            size_t count;
 
        public:
            explicit drop_t(size_t n) : count(n) {}
 
            template <class Gen>
            friend Drop<Gen> operator|(Gen g, drop_t s) {
                return Drop<Gen>(g, s.count);
            }
        };

        inline drop_t drop(size_t n) {
            return drop_t(n);
        }

        class enumerate_t {
        public:
            explicit enumerate_t() = default;
 
            template <class Gen>
            friend Enumerate<Gen> operator|(Gen g, enumerate_t) {
                return Enumerate<Gen>(g);
            }
 
            template <class Gen>
            Enumerate<Gen> operator()(Gen g) {
                return Enumerate<Gen>(g);
            }
        };
 
        static constexpr enumerate_t enumerate;

        template <class Func>
        Generate<Func> generate(Func func) {
            return Generate<Func>(func);
        }

        template <class Gen1, class Gen2>
        Zip<typename std::decay<Gen1>::type, typename std::decay<Gen2>::type>
        zip(Gen1 &&g1, Gen2 &&g2) {
            return Zip<typename std::decay<Gen1>::type,
                typename std::decay<Gen2>::type>(
                std::forward<Gen1>(g1), std::forward<Gen2>(g2));
        }

        template <class Pred>
        class take_while_t {
            Pred pred;
 
        public:
            explicit take_while_t(Pred p) : pred(p) {}
 
            template <class Gen>
            friend TakeWhile<Gen, Pred> operator|(Gen g, take_while_t tw) {
                return TakeWhile<Gen, Pred>(g, tw.pred);
            }
        };

        template <class Pred>
        inline take_while_t<Pred> take_while(Pred pred) {
            return take_while_t<Pred>(pred);
        }

        template <class Pred>
        class drop_while_t {
            Pred pred;
 
        public:
            explicit drop_while_t(Pred p) : pred(p) {}
 
            template <class Gen>
            friend DropWhile<Gen, Pred> operator|(Gen g, drop_while_t dw) {
                return DropWhile<Gen, Pred>(g, dw.pred);
            }
        };

        template <class Pred>
        inline drop_while_t<Pred> drop_while(Pred pred) {
            return drop_while_t<Pred>(pred);
        }

        template <class Container = void>
        class collect {
        private:
            template <class Range, class C>
            static C impl(Range r, std::false_type) {
                return C(r.begin(), r.end());
            }

            template <class Range, class>
            static std::vector<
                typename std::decay<typename Range::value_type>::type>
            impl(Range r, std::true_type) {
                return {r.begin(), r.end()};
            }
 
        public:
            template <class Range>
            friend auto operator|(Range r, collect<Container>)
                -> decltype(collect<Container>::template impl<Range, Container>(
                    r, std::is_same<Container, void>{})) {
                return collect<Container>::template impl<Range, Container>(
                    r, std::is_same<Container, void>{});
            }
        };

        template <class Iterator>
        class to_t {
            Iterator it;
 
        public:
            explicit to_t(Iterator i) : it(i) {}
 
            template <class Range>
            friend void operator|(Range r, to_t m) {
                std::copy(r.begin(), r.end(), m.it);
            }
        };

        template <class Iterator>
        to_t<Iterator> to(Iterator it) {
            return to_t<Iterator>(it);
        }

        template <class Gen1, class Gen2>
        auto operator&(Gen1 &&g1, Gen2 &&g2) -> decltype(gen::zip(
            std::forward<Gen1>(g1), std::forward<Gen2>(g2))) {
            return gen::zip(std::forward<Gen1>(g1), std::forward<Gen2>(g2));
        }
    }
 
    namespace ops {
        template <class T>
        struct Add {
            T value;

            template <class U>
            auto operator()(U x) const -> decltype(x + value) {
                return x + value;
            }
        };

        template <class T>
        struct Sub {
            T value;

            template <class U>
            auto operator()(U x) const -> decltype(x - value) {
                return x - value;
            }
        };

        template <class T>
        struct Mul {
            T value;

            template <class U>
            auto operator()(U x) const -> decltype(x * value) {
                return x * value;
            }
        };

        template <class T>
        struct Div {
            T value;

            template <class U>
            auto operator()(U x) const -> decltype(x / value) {
                return x / value;
            }
        };

        template <class T>
        struct Mod {
            T value;

            template <class U>
            auto operator()(U x) const -> decltype(x % value) {
                return x % value;
            }
        };

        struct inc_t {
            template <class T>
            auto
            operator()(T x) const -> typename std::decay<decltype(++x)>::type {
                return ++x;
            }
        };
 
        static constexpr inc_t inc;

        struct dec_t {
            template <class T>
            auto
            operator()(T x) const -> typename std::decay<decltype(--x)>::type {
                return --x;
            }
        };
 
        static constexpr dec_t dec;

        struct negate_t {
            template <class T>
            auto operator()(T x) const -> decltype(-x) {
                return -x;
            }
        };
 
        static constexpr negate_t negate;

        struct square_t {
            template <class T>
            auto operator()(T x) const -> decltype(x * x) {
                return x * x;
            }
        };
 
        static constexpr square_t square;

        struct cube_t {
            template <class T>
            auto operator()(T x) const -> decltype(x * x * x) {
                return x * x * x;
            }
        };
 
        static constexpr cube_t cube;

        struct sqrt_t {
            template <class T>
            auto operator()(T x) const -> decltype(std::sqrt(x)) {
                return std::sqrt(x);
            }
        };
 
        static constexpr sqrt_t sqrt;

        struct reciprocal_t {
            template <class T>
            auto operator()(T x) const -> decltype(1 / x) {
                return 1 / x;
            }
        };
 
        static constexpr reciprocal_t reciprocal;

        struct abs_t {
            template <class T>
            auto operator()(T x) const -> decltype(std::abs(x)) {
                return std::abs(x);
            }
        };
 
        static constexpr abs_t abs;

        struct to_string_t {
            template <class T>
            std::string operator()(const T &x) const {
                return std::to_string(x);
            }
        };
 
        static constexpr to_string_t to_string;

        template <class T>
        struct Gt {
            T threshold;

            template <class U>
            bool operator()(const U &x) const {
                return x > threshold;
            }
        };

        template <class T>
        struct Ge {
            T threshold;

            template <class U>
            bool operator()(const U &x) const {
                return x >= threshold;
            }
        };

        template <class T>
        struct Lt {
            T threshold;

            template <class U>
            bool operator()(const U &x) const {
                return x < threshold;
            }
        };

        template <class T>
        struct Le {
            T threshold;

            template <class U>
            bool operator()(const U &x) const {
                return x <= threshold;
            }
        };

        template <class T>
        struct Eq {
            T value;

            template <class U>
            bool operator()(const U &x) const {
                return x == value;
            }
        };

        template <class T>
        struct Ne {
            T value;

            template <class U>
            bool operator()(const U &x) const {
                return x != value;
            }
        };

        struct even_t {
            template <class T>
            bool operator()(T x) const {
                return x % 2 == 0;
            }
        };
 
        static constexpr even_t even;

        struct odd_t {
            template <class T>
            bool operator()(T x) const {
                return x % 2 != 0;
            }
        };
 
        static constexpr odd_t odd;

        struct positive_t {
            template <class T>
            bool operator()(T x) const {
                return x > 0;
            }
        };
 
        static constexpr positive_t positive;

        struct negative_t {
            template <class T>
            bool operator()(T x) const {
                return x < 0;
            }
        };
 
        static constexpr negative_t negative;

        struct zero_t {
            template <class T>
            bool operator()(T x) const {
                return x == 0;
            }
        };
 
        static constexpr zero_t zero;

        struct prime_t {
            template <class Int>
            bool operator()(Int n) const {
                if (n <= 1) return false;
                for (size_t i = 2; i * i <= n; ++i)
                    if (n % i == 0) return false;
                return true;
            }
        };
 
        static constexpr prime_t prime;

        template <class P, typename Q>
        struct And {
            P p;
            Q q;

            template <class T>
            bool operator()(const T &x) const {
                return p(x) && q(x);
            }
        };

        template <class P, typename Q>
        struct Or {
            P p;
            Q q;

            template <class T>
            bool operator()(const T &x) const {
                return p(x) || q(x);
            }
        };

        template <class P>
        struct Not {
            P p;

            template <class T>
            bool operator()(const T &x) const {
                return !p(x);
            }
        };

        template <class Class, class Mem>
        struct Member {
            Mem Class::*ptr; 

            template <class T>
            Mem operator()(T &&obj) const {
                return obj.*ptr;
            }

            template <class T>
            Mem operator()(T *obj) const {
                return obj->*ptr;
            }
        };

        struct first_t {
            template <class Pair>
            typename Pair::first_type operator()(const Pair &p) const {
                return p.first;
            }
        };
 
        static constexpr first_t first;

        struct second_t {
            template <class Pair>
            typename Pair::second_type operator()(const Pair &p) const {
                return p.second;
            }
        };
 
        static constexpr second_t second;

        template <class T>
        struct unique {
            bool first = true;
            T    last;

            bool operator()(const T &x) {
                if (first) {
                    first = false;
                    last  = x;
                    return true;
                }
                if (last == x) return false;
                last = x;
                return true;
            }
        };

        struct identity_t {
            template <class T>
            T operator()(T x) const {
                return x;
            }
        };
 
        static constexpr identity_t identity;

        template <class T>
        struct as {
            template <class U>
            T operator()(U &&x) {
                return static_cast<T>(std::forward<U>(x));
            }
        };

        template <class T>
        Add<T> add(T v) {
            return {v};
        }

        template <class T>
        Sub<T> sub(T v) {
            return {v};
        }

        template <class T>
        Mul<T> mul(T v) {
            return {v};
        }

        template <class T>
        Div<T> div(T v) {
            return {v};
        }

        template <class T>
        Mod<T> mod(T v) {
            return {v};
        }

        template <class T>
        Gt<T> gt(T t) {
            return {t};
        }

        template <class T>
        Ge<T> ge(T t) {
            return {t};
        }

        template <class T>
        Lt<T> lt(T t) {
            return {t};
        }

        template <class T>
        Le<T> le(T t) {
            return {t};
        }

        template <class T>
        Eq<T> eq(T v) {
            return {v};
        }

        template <class T>
        Ne<T> ne(T v) {
            return {v};
        }

        template <class P, typename Q>
        And<P, Q> and_(P p, Q q) {
            return {p, q};
        }

        template <class P, typename Q>
        Or<P, Q> or_(P p, Q q) {
            return {p, q};
        }

        template <class P>
        Not<P> not_(P p) {
            return {p};
        }

        template <class Class, typename Mem>
        Member<Class, Mem> member(Mem Class::*p) {
            return {p};
        }

        template <class P, class Q>
        And<P, Q> operator&&(P p, Q q) {
            return {p, q};
        }

        template <class P, class Q>
        Or<P, Q> operator||(P p, Q q) {
            return {p, q};
        }

        template <class P>
        Not<P> operator!(P p) {
            return {p};
        }

        template <class F, class G>
        struct Compose {
            F f;
            G g;

            template <class T>
            auto operator()(T x) const -> decltype(g(f(x))) {
                return g(f(x));
            }
        };

        template <class F, class G>
        Compose<F, G> compose(F f, G g) {
            return {f, g};
        }

        template <class F, class... Rest>
        auto
        compose(F f, Rest... rest) -> Compose<F, decltype(compose(rest...))> {
            return {f, compose(rest...)};
        }

        template <class F, class G>
        Compose<F, G> operator>>(F f, G g) {
            return {f, g};
        }
    }
}