gextra.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 <chrono>
#include <cmath>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
 
#include "../core/sfinae.h"
#include "../util/params.h"
#include "./gen.h"
 
namespace console {
    namespace gen {
        template <class T>
        class Random : public Generator<Random<T>, T> {
            std::mt19937              gen_;
            uniform_distribution_t<T> dist_;
            T                         curr_;
 
        public:
            Random(T                      min,
                T                         max,
                std::mt19937::result_type seed = std::random_device{}()) :
                gen_(seed), dist_(min, max), curr_(dist_(gen_)) {}

            bool done() { return false; }

            T current() { return curr_; }

            void advance() { curr_ = dist_(gen_); }
        };

        class FileLines : public Generator<FileLines, std::string> {
            std::shared_ptr<std::ifstream> file_;
            std::string                    current_line_;
 
        public:
            explicit FileLines(const std::string &filename) :
                file_(std::make_shared<std::ifstream>(filename)) {
                if (!file_->is_open())
                    throw FileError("Cannot Open File \"" + filename + '"');
                advance();
            }

            bool done() { return current_line_.empty() && file_->eof(); }

            std::string current() { return current_line_; }

            void advance() {
                if (!std::getline(*file_, current_line_)) current_line_.clear();
            }
        };

        class FileChunks : public Generator<FileChunks, std::string> {
            std::shared_ptr<std::ifstream> file_;
            std::string                    current_chunk_;
            size_t                         chunk_size_;
 
        public:
            explicit FileChunks(const std::string &filename,
                size_t                             chunk_size = 1024,
                std::ios_base::openmode            mode       = std::ios::in) :
                file_(std::make_shared<std::ifstream>(filename, mode)),
                chunk_size_(chunk_size) {
                if (!file_->is_open())
                    throw FileError("Cannot Open File \"" + filename + '"');
                advance();
            }

            bool done() { return file_->eof() && current_chunk_.empty(); }

            std::string current() { return current_chunk_; }

            void advance() {
                current_chunk_.resize(chunk_size_);
                file_->read(&current_chunk_[0], chunk_size_);
                current_chunk_.resize(file_->gcount());
            }
        };

        template <class Gen>
        class Window : public Generator<Window<Gen>,
                           std::vector<typename Gen::value_type>> {
            Gen                                   gen_;
            size_t                                window_size_;
            std::vector<typename Gen::value_type> window_;
            bool                                  started = false;
 
            void init() {
                if (!started) {
                    for (size_t i = 0; i < window_size_ && !gen_.done(); ++i) {
                        window_.push_back(gen_.current());
                        gen_.advance();
                    }
                    started = true;
                }
            }
 
        public:
            explicit Window(Gen gen, size_t window_size = 16) :
                gen_(gen), window_size_(window_size) {
                if (window_size_ == 0)
                    throw ValueError("Window size must be greater than 0");
            }

            bool done() {
                init();
                return window_.size() < window_size_;
            }

            std::vector<typename Gen::value_type> current() {
                init();
                return window_;
            }

            void advance() {
                init();
                if (!gen_.done()) {
                    window_.erase(window_.begin());
                    window_.push_back(gen_.current());
                    gen_.advance();
                } else
                    window_.erase(window_.begin());
            }
        };

        template <class Gen>
        class Chunk : public Generator<Chunk<Gen>,
                          std::vector<typename Gen::value_type>> {
            Gen                                   gen_;
            size_t                                chunk_size_;
            std::vector<typename Gen::value_type> chunk_;
            bool                                  started = false;
 
            void init() {
                if (!started) {
                    for (size_t i = 0; i < chunk_size_ && !gen_.done(); ++i) {
                        chunk_.push_back(gen_.current());
                        gen_.advance();
                    }
                    started = true;
                }
            }
 
        public:
            explicit Chunk(Gen gen, size_t chunk_size = 16) :
                gen_(gen), chunk_size_(chunk_size) {
                if (chunk_size_ == 0)
                    throw ValueError("Chunk size must be greater than 0");
            }

            bool done() {
                init();
                return chunk_.empty();
            }

            std::vector<typename Gen::value_type> current() {
                init();
                return chunk_;
            }

            void advance() {
                init();
                if (!gen_.done()) {
                    chunk_.clear();
                    for (size_t i = 0; i < chunk_size_ && !gen_.done(); ++i) {
                        chunk_.push_back(gen_.current());
                        gen_.advance();
                    }
                } else
                    chunk_.clear();
            }
        };

        template <class Gen1, class Gen2>
        class Chain
            : public Generator<Chain<Gen1, Gen2>,
                  typename std::decay<
                      decltype(true ? std::declval<typename Gen1::value_type>()
                                    : std::declval<typename Gen2::
                                              value_type>())>::type> {
            using T = typename std::decay<
                decltype(true ? std::declval<typename Gen1::value_type>()
                              : std::declval<typename Gen2::value_type>())>::
                type;
 
            Gen1 gen1;
            Gen2 gen2;
 
        public:
            Chain(Gen1 g1, Gen2 g2) : gen1(g1), gen2(g2) {}

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

            T current() {
                if (!gen1.done())
                    return gen1.current();
                else
                    return gen2.current();
            }

            void advance() {
                if (!gen1.done())
                    gen1.advance();
                else
                    gen2.advance();
            }
        };

        template <class Gen>
        class StepBy : public Generator<StepBy<Gen>, typename Gen::value_type> {
            Gen    gen;
            size_t step;
 
        public:
            explicit StepBy(Gen g, size_t s = 1) : gen(g), step(s) {
                if (step == 0)
                    throw ValueError("Step size must be greater than 0");
            }

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

            typename Gen::value_type current() { return gen.current(); }

            void advance() {
                for (size_t i = 0; i < step && !gen.done(); ++i) gen.advance();
            }
        };

        template <class Gen>
        class Debug : public Generator<Debug<Gen>, typename Gen::value_type> {
            Gen           gen;
            std::string   message;
            std::ostream &out;
 
        public:
            explicit Debug(Gen g,
                std::string    msg = "Current Value: ",
                std::ostream &os = std::cout) : gen(g), message(msg), out(os) {}

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

            typename Gen::value_type current() {
#ifndef NDEBUG
                out << message << gen.current() << std::endl;
#endif
                return gen.current();
            }

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

        template <class Gen, class Pred>
        class TakeUntil
            : public Generator<TakeUntil<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;
                    gen.advance();
                }
            }
 
        public:
            TakeUntil(Gen g, Pred p) : gen(g), pred(p) {}

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

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

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

        template <class Gen, class Pred>
        class DropUntil
            : public Generator<DropUntil<Gen, Pred>, typename Gen::value_type> {
            Gen  gen;
            Pred pred;
            bool dropped = false;
 
            void do_drop() {
                while (!gen.done() && !pred(gen.current())) gen.advance();
                dropped = true;
            }
 
        public:
            DropUntil(Gen g, Pred p) : gen(g), pred(p) {}

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

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

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

        template <class... Ops>
        class Pipeline;

        template <class Op>
        class Pipeline<Op> {
            Op op; 
 
        public:
            Pipeline(Op o) : op(o) {}

            template <class Gen>
            auto operator()(Gen gen) const -> decltype(gen | op) {
                return gen | op;
            }
        };

        template <class Op, class... Rest>
        class Pipeline<Op, Rest...> {
            Op                op;   
            Pipeline<Rest...> rest; 
 
        public:
            Pipeline(Op o, Rest... r) : op(o), rest(r...) {}

            template <class Gen>
            auto operator()(Gen gen) const -> decltype(rest(gen | op)) {
                return rest(gen | op);
            }
        };

        template <class... Ops>
        struct pipeline_t {
            Pipeline<Ops...> pipeline; 

            pipeline_t(Ops... ops) : pipeline(ops...) {}
        };

        template <class Gen, class... Ops>
        auto operator|(Gen gen, pipeline_t<Ops...> pl)
            -> decltype(pl.pipeline(gen)) {
            return pl.pipeline(gen);
        }

        template <class... Ops>
        pipeline_t<Ops...> pipeline(Ops... ops) {
            return pipeline_t<Ops...>(ops...);
        }

        template <class Op1, class Op2>
        pipeline_t<Op1, Op2> operator%(Op1 op1, Op2 op2) {
            return pipeline(op1, op2);
        }
 
        template <class Gen, class T, class BinaryOp>
        class Scan : public Generator<Scan<Gen, T, BinaryOp>, T> {
            Gen      gen;
            T        state;
            BinaryOp op;
            bool     started = false;
 
            void lazy_init() {
                if (!started) {
                    state   = op(state, gen.current());
                    started = true;
                }
            }
 
        public:
            Scan(Gen g, T init, BinaryOp o) : gen(g), state(init), op(o) {}
 
            bool done() {
                lazy_init();
                return gen.done();
            }
 
            T current() {
                lazy_init();
                return state;
            }
 
            void advance() {
                lazy_init();
                gen.advance();
                if (!gen.done()) state = op(state, gen.current());
            }
        };
 
        // =====================================================================

        template <class T>
        Random<T> random(T            min,
            T                         max,
            std::mt19937::result_type seed = std::random_device{}()) {
            return Random<T>(min, max, seed);
        }

        inline FileLines file_lines(const std::string &filename) {
            return FileLines(filename);
        }

        inline FileChunks file_chunks(const std::string &filename,
            size_t                                       chunk_size = 1024,
            std::ios_base::openmode                      mode = std::ios::in) {
            return FileChunks(filename, chunk_size, mode);
        }

        class window_t {
            size_t s;
 
        public:
            explicit window_t(size_t size = 16) : s(size) {}

            template <class Gen>
            friend Window<Gen> operator|(Gen g, window_t w) {
                return Window<Gen>(g, w.s);
            }
        };

        inline window_t window(size_t size = 16) {
            return window_t(size);
        }

        class chunk_t {
            size_t s;
 
        public:
            explicit chunk_t(size_t size = 16) : s(size) {}

            template <class Gen>
            friend Chunk<Gen> operator|(Gen g, chunk_t t) {
                return Chunk<Gen>(g, t.s);
            }
        };

        inline chunk_t chunk(size_t size = 16) {
            return chunk_t(size);
        }

        template <class Gen1, class Gen2>
        Chain<Gen1, Gen2> chain(Gen1 g1, Gen2 g2) {
            return Chain<Gen1, Gen2>(g1, g2);
        }

        template <class Gen, class... Rest>
        auto
        chain(Gen g, Rest... rest) -> Chain<Gen, decltype(chain(rest...))> {
            return {g, chain(rest...)};
        }

        template <class Gen1, class Gen2>
        Chain<Gen1, Gen2> operator+(Gen1 g1, Gen2 g2) {
            return Chain<Gen1, Gen2>(g1, g2);
        }

        class step_by_t {
            size_t s;
 
        public:
            explicit step_by_t(size_t size = 1) : s(size) {}

            template <class Gen>
            friend StepBy<Gen> operator|(Gen g, step_by_t s) {
                return StepBy<Gen>(g, s.s);
            }
        };

        inline step_by_t step_by(size_t size = 1) {
            return step_by_t(size);
        }

        class debug_t {
            std::string   message;
            std::ostream &out;
 
        public:
            explicit debug_t(std::string msg = "DEBUG: ",
                std::ostream &os = std::cout) : message(msg), out(os) {}

            template <class Gen>
            friend Debug<Gen> operator|(Gen g, debug_t d) {
                return Debug<Gen>(g, d.message, d.out);
            }
        };

        inline debug_t
        debug(std::string msg = "DEBUG: ", std::ostream &os = std::cout) {
            return debug_t{msg, os};
        }

        template <class Pred>
        class take_until_t {
            Pred pred;
 
        public:
            explicit take_until_t(Pred p) : pred(p) {}

            template <class Gen>
            friend TakeUntil<Gen, Pred> operator|(Gen g, take_until_t tu) {
                return TakeUntil<Gen, Pred>(g, tu.pred);
            }
        };

        template <class Pred>
        take_until_t<Pred> take_until(Pred p) {
            return take_until_t<Pred>(p);
        }

        template <class Pred>
        class drop_until_t {
            Pred pred;
 
        public:
            explicit drop_until_t(Pred p) : pred(p) {}

            template <class Gen>
            friend DropUntil<Gen, Pred> operator|(Gen g, drop_until_t du) {
                return DropUntil<Gen, Pred>(g, du.pred);
            }
        };

        template <class Pred>
        drop_until_t<Pred> drop_until(Pred p) {
            return drop_until_t<Pred>(p);
        }

        template <class T, class BinaryOp>
        class reduce_t {
            T        init_;
            BinaryOp op_;
 
        public:
            reduce_t(T init, BinaryOp op) : init_(init), op_(op) {}

            template <class Gen>
            friend T operator|(Gen gen, reduce_t r) {
                T result = r.init_;
                for (auto &&item : gen) result = r.op_(result, item);
                return result;
            }
        };

        template <class T, class BinaryOp>
        reduce_t<T, BinaryOp> reduce(const T &init, BinaryOp bo) {
            return reduce_t<T, BinaryOp>(init, bo);
        }
 
        template <class T, class BinaryOp>
        class scan_t {
            T        state;
            BinaryOp op;
 
        public:
            scan_t(const T &init, BinaryOp op) : state(init), op(op) {}

            template <class Gen>
            friend Scan<Gen, T, BinaryOp>
            operator|(Gen gen, scan_t<T, BinaryOp> scan) {
                return Scan<Gen, T, BinaryOp>(gen, scan.state, scan.op);
            }
        };

        template <class T, class BinaryOp>
        scan_t<T, BinaryOp> scan(T init, BinaryOp op) {
            return scan_t<T, BinaryOp>(init, op);
        }

        template <class F, class... Args>
        class algorithm_t {
            F               func;
            Params<Args...> params;
 
        public:
            algorithm_t(F func, const Args &...args) :
                func(func), params(args...) {}

            template <class Gen>
            friend auto
            operator|(Gen gen, algorithm_t alg) -> decltype(std::declval<F>()(
                gen.begin(), gen.end(), std::declval<Args>()...)) {
                return alg.params.apply([&](const Args &...args) {
                    return alg.func(gen.begin(), gen.end(), args...);
                });
            }
        };

        template <class T, class... Args>
        algorithm_t<T, Args...> algorithm(T func, const Args &...args) {
            return algorithm_t<T, Args...>(func, args...);
        }
    }
 
    namespace ops {
        template <class T>
        struct Pow {
            T exponent;

            template <class U>
            auto operator()(U x) const -> decltype(std::pow(x, exponent)) {
                return std::pow(x, exponent);
            }
        };

        template <class T>
        Pow<T> pow(T exp) {
            return {exp};
        }

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

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

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

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

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

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

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

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

        struct sign_t {
            template <class T>
            int operator()(T x) const {
                return (x > 0) - (x < 0);
            }
        };
 
        static constexpr sign_t sign;

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

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

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

        struct strlen_t {
            size_t operator()(const std::string &s) const { return s.size(); }
        };
 
        static constexpr strlen_t strlen;

        struct to_upper_t {
            std::string operator()(std::string s) const {
                for (auto &c : s) c = std::toupper(c);
                return s;
            }
        };
 
        static constexpr to_upper_t to_upper;

        struct to_lower_t {
            std::string operator()(std::string s) const {
                for (auto &c : s) c = std::tolower(c);
                return s;
            }
        };
 
        static constexpr to_lower_t to_lower;

        struct trim_t {
            std::string operator()(std::string s) const {
                auto start = s.find_first_not_of(" \t\n\r\f\v");
                if (start == std::string::npos) return "";
                auto end = s.find_last_not_of(" \t\n\r\f\v");
                return s.substr(start, end - start + 1);
            }
        };
 
        static constexpr trim_t trim;

        struct reverse_string_t {
            std::string operator()(std::string s) const {
                std::reverse(s.begin(), s.end());
                return s;
            }
        };
 
        static constexpr reverse_string_t reverse_string;

        struct size_t_ {
            template <class Container>
            auto operator()(const Container &c) const -> decltype(c.size()) {
                return c.size();
            }
        };
 
        static constexpr size_t_ size;

        struct empty_t {
            template <class Container>
            bool operator()(const Container &c) const {
                return c.empty();
            }
        };
 
        static constexpr empty_t empty;

        struct max_element_t {
            template <class Container>
            auto operator()(const Container &c) const ->
                typename std::decay<decltype(*std::max_element(
                    c.begin(), c.end()))>::type {
                return *std::max_element(c.begin(), c.end());
            }
        };
 
        static constexpr max_element_t max_element;

        struct min_element_t {
            template <class Container>
            auto operator()(const Container &c) const ->
                typename std::decay<decltype(*std::min_element(
                    c.begin(), c.end()))>::type {
                return *std::min_element(c.begin(), c.end());
            }
        };
 
        static constexpr min_element_t min_element;

        struct sum_t {
            template <class Range>
            auto operator()(Range r) const -> decltype(std::accumulate(
                r.begin(), r.end(), typename Range::value_type{})) {
                using T = typename Range::value_type;
                return std::accumulate(r.begin(), r.end(), T{});
            }
        };
 
        static constexpr sum_t sum;

        struct average_t {
            template <class Range>
            auto operator()(Range r) const
                -> decltype(std::accumulate(r.begin(),
                                r.end(),
                                typename Range::value_type{})
                            / r.size()) {
                using T = typename Range::value_type;
                return std::accumulate(r.begin(), r.end(), T{}) / r.size();
            }
        };
 
        static constexpr average_t average;

        template <class T>
        struct Between {
            T low, high;

            bool operator()(const T &x) const { return low <= x && x <= high; }
        };

        template <class T>
        Between<T> between(T low, T high) {
            return {low, high};
        }

        template <class T>
        struct BetweenExclusive {
            T low, high;

            bool operator()(const T &x) const { return low < x && x < high; }
        };

        template <class T>
        BetweenExclusive<T> between_exclusive(T low, T high) {
            return {low, high};
        }

        template <class T>
        struct DivisibleBy {
            T n;

            bool operator()(const T &x) const { return x % n == 0; }
        };

        template <class T>
        DivisibleBy<T> divisible_by(T n) {
            return {n};
        }

        struct power_of_two_t {
            template <class Int>
            bool operator()(Int n) const {
                return n > 0 && (n & (n - 1)) == 0;
            }
        };
 
        static constexpr power_of_two_t power_of_two;

        struct palindrome_t {
            template <class T>
            bool operator()(T n) const {
                std::string s = std::to_string(n);
                std::string r = s;
                std::reverse(r.begin(), r.end());
                return s == r;
            }
        };
 
        static constexpr palindrome_t palindrome;

        struct always_true_t {
            template <class... Args>
            bool operator()(Args &&...) const {
                return true;
            }
        };
 
        static constexpr always_true_t always_true;

        struct always_false_t {
            template <class... Args>
            bool operator()(Args &&...) const {
                return false;
            }
        };
 
        static constexpr always_false_t always_false;

        template <class T>
        struct Clamp {
            T low, high;

            T operator()(T x) const { return std::max(low, std::min(high, x)); }
        };

        template <class T>
        Clamp<T> clamp(T low, T high) {
            return {low, high};
        }

        struct timestamp_t {
            long long operator()() const {
                return std::chrono::duration_cast<std::chrono::seconds>(
                    std::chrono::system_clock::now().time_since_epoch())
                    .count();
            }
        };
 
        static constexpr timestamp_t timestamp;

        struct plus_t {
            template <class T, class U>
            auto operator()(T a, U b) const -> decltype(a + b) {
                return a + b;
            }
        };
 
        static constexpr plus_t plus;

        struct minus_t {
            template <class T, class U>
            auto operator()(T a, U b) const -> decltype(a - b) {
                return a - b;
            }
        };
 
        static constexpr minus_t minus;

        struct multiplies_t {
            template <class T, class U>
            auto operator()(T a, U b) const -> decltype(a * b) {
                return a * b;
            }
        };
 
        static constexpr multiplies_t multiplies;

        struct divides_t {
            template <class T, class U>
            auto operator()(T a, U b) const -> decltype(a / b) {
                return a / b;
            }
        };
 
        static constexpr divides_t divides;

        struct modulus_t {
            template <class T, class U>
            auto operator()(T a, U b) const -> decltype(a % b) {
                return a % b;
            }
        };
 
        static constexpr modulus_t modulus;
 
        struct is_null_t {
            template <class T>
            bool operator()(const T &p) const {
                return p == nullptr;
            }
        };
 
        static constexpr is_null_t is_null;
 
        struct not_null_t {
            template <class T>
            bool operator()(const T &p) const {
                return p != nullptr;
            }
        };
 
        static constexpr not_null_t not_null;
 
        template <size_t N>
        struct nth_t {
            template <class T>
            auto operator()(T &&t) const //
                -> typename std::decay<decltype(std::get<N>(
                    std::forward<T>(t)))>::type {
                return std::get<N>(std::forward<T>(t));
            }
        };

        template <size_t N>
        nth_t<N> nth() {
            return {};
        }

        template <class Class, class Ret, class... Args>
        struct Method {
            Ret (Class::*ptr)(Args...); 
            Params<Args...> param;      

            Method(Ret (Class::*ptr)(Args...), const Args &...args) :
                ptr(ptr), param(args...) {}

            template <class T>
            Ret operator()(T &&obj) const {
                return param.apply(
                    [&](const Args &...args) { return (obj.*ptr)(args...); });
            }

            template <class T>
            Ret operator()(T *obj) const {
                return param.apply(
                    [&](const Args &...args) { return (obj->*ptr)(args...); });
            }
        };

        template <class Class, class Ret, class... Args>
        Method<Class, Ret, Args...>
        method(Ret (Class::*ptr)(Args...), const Args &...args) {
            return Method<Class, Ret, Args...>{ptr, args...};
        }

        template <class... Args>
        struct Call {
            Params<Args...> param; 

            Call(const Args &...args) : param(args...) {}

            template <class F>
            auto operator()(F &&f) const -> //
                typename std::decay<decltype(param.apply(
                    std::forward<F>(f)))>::type {
                return param.apply(std::forward<F>(f));
            }
        };

        template <class... Args>
        Call<Args...> call(const Args &...args) {
            return Call<Args...>{args...};
        }
    }
}