From fc8b9d0a4b645d8af8c447b80f5a2bc8ee4ce3d0 Mon Sep 17 00:00:00 2001
From: "Argon.Sun" <argon.sun@gmail.com>
Date: Sat, 14 Jan 2023 14:39:16 +0800
Subject: [PATCH] first commit

---
 README.md   |   0
 main.cpp    |  21 +++
 rs_iter.hpp | 500 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 rusty.hpp   | 258 +++++++++++++++++++++++++++
 4 files changed, 779 insertions(+)
 create mode 100644 README.md
 create mode 100644 main.cpp
 create mode 100644 rs_iter.hpp
 create mode 100644 rusty.hpp

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..26557a3
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,21 @@
+#include <iostream>
+#include <memory>
+
+#include "rusty.hpp"
+
+int main() {
+    rs::vector<rs::vector<int>> v = {{10, 20, 25}, {30, 40, 55}, {60, 73, 80}};
+    auto res = v.into_iter_ptr<true>().flat_map([](const rs::vector<int>* v)->auto{return v->into_iter<true>();})
+        // .partition<rs::list<int>>([](int x) -> auto { return x % 2 == 0; });
+        // .skip_while([](int v)->bool { return v < 30; })
+        .inspect([](int x) { std::cout << "check " << x << std::endl;})
+        // .map([](int x)->float{ return x * 3.14159;})
+        // .take_while([](float v)->bool { return v < 100; })
+        // .enumerate()
+        // .collect<rs::vector<int>>();
+        .sum();
+    std::cout << res << std::endl;;
+    rs::map<int, float> mp = {{1, 4.0}, {2, 6.0}, {3, 6.6}};
+    std::cout << mp.into_iter().map([](int a, float b)->float{ return a + b * b; }).sum() << std::endl;
+    return 0;
+}
diff --git a/rs_iter.hpp b/rs_iter.hpp
new file mode 100644
index 0000000..7b3d7c8
--- /dev/null
+++ b/rs_iter.hpp
@@ -0,0 +1,500 @@
+#ifndef _RC_ITER_HPP_
+#define _RC_ITER_HPP_
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <type_traits>
+
+namespace rs {
+
+template<typename... ARGS>
+struct InvokeType {
+    template<typename F>
+    auto Call(F f, ARGS... args) { return f(std::forward<ARGS>(args)...); }
+    template<typename F>
+    void CallNoReturn(F f, ARGS... args) { f(std::forward<ARGS>(args)...); }
+    template<typename F, typename S>
+    auto CallFold(F f, S s, ARGS... args) { return f(std::forward<S>(s), std::forward<ARGS>(args)...); }
+};
+
+template<typename U, typename V>
+struct InvokeType<std::pair<U, V>> {
+    template<typename F>
+    auto Call(F f, std::pair<U, V> arg) { return f(arg.first, arg.second); }
+    template<typename F>
+    void CallNoReturn(F f, std::pair<U, V> arg) { f(arg.first, arg.second); }
+    template<typename F, typename S>
+    auto CallFold(F f, S s, std::pair<U, V> arg) { return f(std::forward<S>(s), arg.first, arg.second); }
+};
+
+template<typename... ARGS>
+struct InvokeType<std::tuple<ARGS...>> {
+    using sequence_type = std::index_sequence_for<ARGS...>;
+    template<typename F>
+    auto Call(F f, std::tuple<ARGS...> arg) { return UnpackCall(std::forward<F>(f), arg, sequence_type{}); }
+    template<typename F>
+    void CallNoReturn(F f, std::tuple<ARGS...> arg) { UnpackCallNoReturn(std::forward<F>(f), arg, sequence_type{}); }
+    template<typename F, typename S>
+    auto CallFold(F f, S s, std::tuple<ARGS...> arg) { return UnpackCallFold(std::forward<F>(f), std::forward<S>(s), arg, sequence_type{}); }
+
+    template<typename F, size_t... I>
+    auto UnpackCall(F f, std::tuple<ARGS...>& arg, std::index_sequence<I...>) { return f(std::get<I>(arg)...); }
+    template<typename F, size_t... I>
+    void UnpackCallNoReturn(F f, std::tuple<ARGS...>& arg, std::index_sequence<I...>) { f(std::get<I>(arg)...); }
+    template<typename F, typename S, size_t... I>
+    auto UnpackCallFold(F f, S s, std::tuple<ARGS...>& arg, std::index_sequence<I...>) { return f(s, std::get<I>(arg)...); }
+};
+
+template <typename T>
+struct StdFuncType {
+    using type = void;
+    using return_type = void;
+};
+template <typename RET, typename CLASS, typename... ARGS>
+struct StdFuncType<RET (CLASS::*)(ARGS...) const> {
+    using type = std::function<RET(ARGS...)>;
+    using return_type = RET;
+};
+template <typename RET, typename CLASS, typename... ARGS>
+struct StdFuncType<RET (CLASS::*)(ARGS...)> {
+    using type = std::function<RET(ARGS...)>;
+    using return_type = RET;
+};
+
+template <typename HANDLER>
+struct FunctionType {
+    using type = typename StdFuncType<decltype(&HANDLER::operator())>::type;
+    using return_type = typename StdFuncType<decltype(&HANDLER::operator())>::return_type;
+};
+template <typename RET, typename... ARGS>
+struct FunctionType<RET (*)(ARGS...)> {
+    using type = std::function<RET(ARGS...)>;
+    using return_type = RET;
+};
+template <typename RET, typename... ARGS>
+struct FunctionType<RET(ARGS...)> {
+    using type = std::function<RET(ARGS...)>;
+    using return_type = RET;
+};
+
+template <typename T, template<typename... TARGS> typename TP>
+struct TemplateChecker {
+    static constexpr bool value = false;
+};
+template <template<typename... TARGS> typename TP, typename... ARGS>
+struct TemplateChecker<TP<ARGS...>, TP> {
+    static constexpr bool value = true;
+};
+
+template <typename T>
+struct iterator {
+    using value_type = T;
+
+    std::optional<T> next() {
+        return iter();
+    }
+
+    size_t count() {
+        size_t result = 0;
+        for (auto n = next(); n.has_value(); n = next())
+            result++;
+        return result;
+    }
+
+    std::optional<T> nth(size_t n) {
+        while (true) {
+            std::optional<T> value = next();
+            if (n-- == 0 || !value.has_value())
+                return value;
+        }
+    }
+
+    std::optional<T> last() {
+        std::optional<T> value;
+        for (auto n = next(); n.has_value(); n = next())
+            value = n;
+        return value;
+    }
+
+    auto step_by(int32_t s) {
+        return iterator<T>{[s, c = s, it = std::move(iter)]() mutable -> auto {
+            for (; c < s; c++)
+                it();
+            c = 1;
+            return it();
+        }};
+    }
+
+    auto chain(iterator<T>&& i) {
+        return iterator<T>{[it1 = std::move(iter), it2 = std::move(i.iter), s = true]() mutable -> auto {
+            if (s) {
+                auto v = it1(true);
+                if (!v.has_value()) {
+                    s = false;
+                    return it2(true);
+                }
+            } else
+                return it2(true);
+        }};
+    }
+
+    template<typename U>
+    auto zip(iterator<U>&& i) {
+        return iterator<std::pair<T, U>>{[it1 = std::move(iter), it2 = std::move(i.iter)]() mutable -> auto {
+            if(auto v1 = it1(); v1.has_value()) {
+                if(auto v2 = it2(); v2.has_value())
+                    return std::optional<std::pair<T, U>>(std::make_pair(v1.value(), v2.value()));
+            }
+            return std::optional<std::pair<T, U>>();
+        }};
+    }
+
+    template <typename F>
+    void for_each(F f) {
+        for(auto v = next(); v.has_value(); v = next()) {
+            InvokeType<T>().CallNoReturn(std::ref(f), v.value());
+        }
+    }
+
+    template <typename F>
+    auto filter(F f) {
+        return iterator<T>{[f, it = std::move(iter)]() mutable -> auto {
+            auto value = it();
+            while(value.has_value() && !InvokeType<T>().Call(std::ref(f), value.value()))
+                value = it();
+            return value;
+        }};
+    }
+
+    template <typename M>
+    auto map(M m) {
+        using RET = typename FunctionType<M>::return_type;
+        return iterator<RET>{[m, it = std::move(iter)]() -> auto {
+            auto t = it();
+            if (t.has_value())
+                return std::optional<RET>(InvokeType<T>().Call(std::ref(m), t.value()));
+            return std::optional<RET>();
+        }};
+    }
+
+    template <typename FM>
+    auto filter_map(FM fm) {
+        using OPT = typename FunctionType<FM>::return_type;
+        static_assert(TemplateChecker<OPT, std::optional>::value, "filter_map: filter must return an optional value.");
+        using RET = typename OPT::value_type;
+        return iterator<RET>{[fm, it = std::move(iter)]() -> auto {
+            auto value = it();
+            while (value.has_value()) {
+                if(auto mvalue = InvokeType<T>().Call(std::ref(fm), value.value()); mvalue.has_value())
+                    return mvalue;
+                value = it();
+            }                
+            return std::optional<RET>();
+        }};
+    }
+
+    auto enumerate() {
+        return iterator<std::pair<size_t, T>>{[it = std::move(iter), i = 0]() mutable -> auto {
+            if(auto v = it(); v.has_value())
+                return std::optional<std::pair<size_t, T>>(std::make_pair(i++, v.value()));
+            return std::optional<std::pair<size_t, T>>();
+        }};
+    }
+
+    auto skip(size_t n) {
+        return iterator<T>{[n, it = std::move(iter)]() mutable -> auto {
+            while (n > 0) {
+                n--;
+                it();
+            }
+            return it();
+        }};
+    }
+
+    auto take(size_t n) {
+        return iterator<T>{[n, it = std::move(iter)]() mutable -> auto {
+            if (n > 0) {
+                n--;
+                return it();
+            }
+            return std::optional<T>();
+        }};
+    }
+
+    template<typename F>
+    auto skip_while(F f) {
+        return iterator<T>{[f, it = std::move(iter), res = false]() mutable -> auto {
+            auto v = it();
+            if(res)
+                return v;
+            while(v.has_value() && InvokeType<T>().Call(std::ref(f), v.value()))
+                v = it();
+            res = true;
+            return v;
+        }};
+    }
+
+    template <typename F>
+    auto take_while(F f) {
+        return iterator<T>{[f, it = std::move(iter), res = true]() mutable -> auto {
+            if (res) {
+                if(auto v = it(); v.has_value() && InvokeType<T>().Call(std::ref(f), v.value()))
+                    return v;
+                else
+                    res = false;
+            }
+            return std::optional<T>();
+        }};
+    }
+
+    template <typename S, typename M>
+    auto scan(S s, M m) {
+        using RET = typename FunctionType<M>::return_type;
+        return iterator<RET>{[s, m, it = std::move(iter)]() mutable -> auto {
+            auto t = it();
+            if(t.has_value())
+                return std::optional<RET>(InvokeType<T>().CallFold(std::ref(m), std::ref(s), t.value()));
+            return std::optional<RET>();
+        }};
+    }
+
+    template <typename M>
+    auto flat_map(M m) {
+        return map(m).flatten();
+    }
+
+    auto flatten() {
+        static_assert(TemplateChecker<T, rs::iterator>::value, "flatten: value type can only be iterator type.");
+        using NT = typename T::value_type;
+        return iterator<NT>{[inited = false, cur = std::optional<iterator<NT>>(), it = std::move(iter)]() mutable -> auto {
+            if(!inited) {
+                cur = it();
+                inited = true;
+            }
+            if(!cur.has_value())
+                return std::optional<NT>();
+            auto v = cur.value().next();
+            while(!v.has_value() && cur.has_value()) {
+                cur = it();
+                if(cur.has_value())
+                    v = cur.value().next();
+            }
+            return v;
+        }};
+    }
+
+    auto fuse() {
+        return iterator<T>{[end = false, it = std::move(iter)]() mutable -> auto {
+            if (end)
+                return std::optional<T>();
+            auto v = it();
+            if(!it.has_value())
+                end = true;
+            return v;
+        }};
+    }
+
+    template <typename F>
+    auto inspect(F f) {
+        return iterator<T>{[f, it = std::move(iter)]() -> auto {
+            auto v = it();
+            if(v.has_value())
+                InvokeType<T>().CallNoReturn(std::ref(f), v.value());
+            return v;
+        }};
+    }
+
+    template<typename C>
+    auto collect() {
+        C container;
+        for (auto v = next(); v.has_value(); v = next())
+            container.collect_item(v.value());
+        return container;
+    }
+
+    template<typename C>
+    C& collect(C& container) {
+        for (auto v = next(); v.has_value(); v = next())
+            container.collect_item(v.value());
+        return container;
+    }
+
+    template<typename C, typename F>
+    auto partition(F f) {
+        std::pair<C, C> result;
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(InvokeType<T>().CallNoReturn(std::ref(f), v.value()))
+                result.first.collect_item(v.value());
+            else
+                result.second.collect_item(v.value());
+        }
+        return result;
+    }
+
+    template <typename S, typename F>
+    auto fold(S s, F f) {
+        using RET = typename FunctionType<F>::return_type;
+        static_assert(std::is_same<S, RET>::value, "fold: function should return same type as value.");
+        for (auto v = next(); v.has_value(); v = next()) {
+            s = InvokeType<T>().CallFold(std::ref(f), s, v.value());
+        }
+        return s;
+    }
+
+    template <typename F>
+    bool all(F f) {
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(!InvokeType<T>().Call(std::ref(f), v.value()))
+                return false;
+        }
+        return true;
+    }
+
+    template <typename F>
+    bool any(F f) {
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(InvokeType<T>().Call(std::ref(f), v.value()))
+                return true;
+        }
+        return false;
+    }
+
+    template <typename F>
+    auto find(F f) {
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(InvokeType<T>().Call(std::ref(f), v.value()))
+                return v;
+        }
+        return std::optional<T>();
+    }
+
+    template <typename F>
+    auto find_map(F f) {
+        using OPT = typename FunctionType<F>::return_type;
+        static_assert(TemplateChecker<OPT, std::optional>::value, "find_map: filter must return an optional value.");
+        using RET = typename OPT::value_type;
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(auto mv = InvokeType<T>().Call(std::ref(f), v.value()); mv.has_value())
+                return mv;
+        }
+        return std::optional<RET>();
+    }
+
+    template <typename F>
+    auto position(F f) {
+        size_t i = 0;
+        for (auto v = next(); v.has_value(); v = next(), i++) {
+            if(InvokeType<T>().Call(std::ref(f), v.value()))
+                return std::optional<size_t>(i);
+        }
+        return std::optional<size_t>();
+    }
+
+    auto max() {
+        auto res = next();
+        if(!res.has_value())
+            return res;
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(v.value() >= res.value())
+                res = v;
+        }
+        return res;
+    }
+
+    auto min() {
+        auto res = next();
+        if(!res.has_value())
+            return res;
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(v.value() < res.value())
+                res = v;
+        }
+        return res;
+    }
+
+    template <typename F>
+    auto max_by_key(F f) {
+        auto res = next();
+        if(!res.has_value())
+            return res;
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(InvokeType<T>().Call(std::ref(f), v.value()) >= InvokeType<T>().Call(std::ref(f), res.value()))
+                res = v;
+        }
+        return res;
+    }
+
+    template <typename F>
+    auto min_by_key(F f) {
+        auto res = next();
+        if(!res.has_value())
+            return res;
+        for (auto v = next(); v.has_value(); v = next()) {
+            if(InvokeType<T>().Call(std::ref(f), v.value()) < InvokeType<T>().Call(std::ref(f), res.value()))
+                res = v;
+        }
+        return res;
+    }
+
+    auto unzip() {
+        static_assert(TemplateChecker<T, std::pair>::value, "unzip: iterator type must be pair");
+        using TP1 = typename T::first_type;
+        using TP2 = typename T::second_type;
+        std::pair<iterator<TP1>, iterator<TP2>> result;
+        result.first.iter = [it = iter]()-> auto {
+            auto v = it();
+            return v.has_value() ? std::optional<TP1>(v.value().first): std::optional<TP1>();
+        };
+        result.second.iter = [it = iter]()-> auto {
+            auto v = it();
+            return v.has_value() ? std::optional<TP2>(v.value().second): std::optional<TP2>();
+        };
+        return result;
+    }
+
+    auto cycle() {
+        return iterator<T>{[it = iter, it2 = iter]() mutable -> auto {
+            auto v = it(false);
+            if(v.has_value())
+                return v;
+            it = it2;
+            return it(false);
+        }};
+    }
+
+    auto sum() {
+        auto res = T(0);
+        for (auto v = next(); v.has_value(); v = next())
+            res += v.value();
+        return res;
+    }
+
+    auto product() {
+        auto res = T(1);
+        for (auto v = next(); v.has_value(); v = next())
+            res *= v.value();
+        return res;
+    }
+
+    std::function<std::optional<T>()> iter;
+};
+
+template<typename T>
+auto range(T start, T end) {
+    return iterator<T>{[start, end]() mutable -> auto {
+        if(start >= end)
+            return std::optional<T>();
+        return std::optional<T>(start++);
+    }};
+}
+
+template<typename T>
+auto repeat(T value) {
+    return iterator<T>{[value]() -> auto {
+        return std::optional<T>(value);
+    }};
+}
+
+}  // namespace rs
+#endif
diff --git a/rusty.hpp b/rusty.hpp
new file mode 100644
index 0000000..a34788b
--- /dev/null
+++ b/rusty.hpp
@@ -0,0 +1,258 @@
+#ifndef _RC_HPP_
+#define _RC_HPP_
+
+#include <array>
+#include <vector>
+#include <list>
+#include <forward_list>
+#include <deque>
+#include <set>
+#include <unordered_set>
+#include <map>
+#include <unordered_map>
+#include <string>
+
+#include "rs_iter.hpp"
+
+namespace rs {
+
+template<typename P, typename TP>
+class linear_container : public P {
+public:
+    using P::P;
+
+    template<bool REV = false>
+    rs::iterator<TP> into_iter() const {
+        if constexpr (!REV) {
+            return rs::iterator<TP>{[this, iter = this->begin()] () mutable -> auto {
+                if(iter == this->end())
+                    return std::optional<TP>();
+                return std::optional<TP>(*iter++);
+            }}; 
+        } else {
+            return rs::iterator<TP>{[this, riter = this->rbegin()] () mutable -> auto {
+                if(riter == this->rend())
+                    return std::optional<TP>();
+                return std::optional<TP>(*riter++);
+            }};
+        }
+    }
+
+    template<bool REV = false>
+    rs::iterator<const TP*> into_iter_ptr() const {
+        if constexpr (!REV) {
+            return rs::iterator<const TP*>{[this, iter = this->cbegin()] () mutable -> auto {
+                if(iter == this->cend())
+                    return std::optional<const TP*>();
+                return std::optional<const TP*>(&*iter++);
+            }}; 
+        } else {
+            return rs::iterator<const TP*>{[this, riter = this->crbegin()] () mutable -> auto {
+                if(riter == this->crend())
+                    return std::optional<const TP*>();
+                return std::optional<const TP*>(&*riter++);
+            }};
+        }
+    }
+
+    template<bool REV = false>
+    rs::iterator<TP*> into_iter_mptr() {
+        if constexpr (!REV) {
+            return rs::iterator<TP*>{[this, iter = this->begin()] () mutable -> auto {
+                if(iter == this->end())
+                    return std::optional<TP*>();
+                return std::optional<TP*>(&*iter++);
+            }}; 
+        } else {
+            return rs::iterator<TP*>{[this, riter = this->rbegin()] () mutable -> auto {
+                if(riter == this->rend())
+                    return std::optional<TP*>();
+                return std::optional<TP*>(&*riter++);
+            }};
+        }
+    }
+
+    void collect_item(const TP& v) {
+        this->push_back(v);
+    }
+};
+
+template <typename TP, typename ALLOC = std::allocator<TP>>
+using vector = linear_container<std::vector<TP, ALLOC>, TP>;
+template <typename TP, typename ALLOC = std::allocator<TP>>
+using list = linear_container<std::list<TP, ALLOC>, TP>;
+template <typename TP, typename ALLOC = std::allocator<TP>>
+using forward_list = linear_container<std::forward_list<TP, ALLOC>, TP>;
+template <typename TP, typename ALLOC = std::allocator<TP>>
+using deque = linear_container<std::deque<TP, ALLOC>, TP>;
+template <typename TP, size_t COUNT>
+using array = linear_container<std::array<TP, COUNT>, TP>;
+
+template<typename S, typename KEY, bool CanRev>
+class set_container : public S {
+public:
+    using S::S;
+
+    template<bool REV = false>
+    rs::iterator<KEY> into_iter() const {
+        if constexpr (!REV || !CanRev) {
+            return rs::iterator<KEY>{[this, iter = this->begin()] () mutable -> auto {
+                if(iter == this->end())
+                    return std::optional<KEY>();
+                return std::optional<KEY>(*iter++);
+            }}; 
+        } else {
+            return rs::iterator<KEY>{[this, riter = this->rbegin()] () mutable -> auto {
+                if(riter == this->rend())
+                    return std::optional<KEY>();
+                return std::optional<KEY>(*riter++);
+            }};
+        }
+    }
+
+    template<bool REV = false>
+    rs::iterator<const KEY*> into_iter_ptr() const {
+        if constexpr (!REV || !CanRev) {
+            return rs::iterator<const KEY*>{[this, iter = this->cbegin()] () mutable -> auto {
+                if(iter == this->cend())
+                    return std::optional<const KEY*>();
+                return std::optional<const KEY*>(&*iter++);
+            }}; 
+        } else {
+            return rs::iterator<const KEY*>{[this, riter = this->crbegin()] () mutable -> auto {
+                if(riter == this->crend())
+                    return std::optional<const KEY*>();
+                return std::optional<const KEY*>(&*riter++);
+            }};
+        }
+    }
+
+    void collect_item(const KEY& value) {
+        this->insert(value);
+    }
+
+};
+
+template<typename KEY,
+    typename COMPARE = std::less<KEY>,
+    typename ALLOC = std::allocator<KEY>>
+using set = set_container<std::set<KEY, COMPARE, ALLOC>, KEY, true>;
+template<typename KEY,
+    typename COMPARE = std::less<KEY>,
+    typename ALLOC = std::allocator<KEY>>
+using multiset = set_container<std::multiset<KEY, COMPARE, ALLOC>, KEY, true>;
+template<typename KEY,
+    typename HASH = std::hash<KEY>,
+	typename PRED = std::equal_to<KEY>,
+	typename ALLOC = std::allocator<KEY>>
+using unordered_set = set_container<std::unordered_set<KEY, HASH, PRED, ALLOC>, KEY, false>;
+template<typename KEY, typename TP,
+    typename HASH = std::hash<KEY>,
+	typename PRED = std::equal_to<KEY>,
+	typename ALLOC = std::allocator<KEY>>
+using unordered_multiset = set_container<std::unordered_multiset<KEY, HASH, PRED, ALLOC>, KEY, false>;
+
+template<typename M, typename KEY, typename TP, bool CanRev>
+class map_container : public M {
+public:
+    using M::M;
+
+    template<bool REV = false>
+    rs::iterator<std::pair<KEY, TP>> into_iter() const {
+        if constexpr (!REV || !CanRev) {
+            return rs::iterator<std::pair<KEY, TP>>{[this, iter = this->begin()] () mutable -> auto {
+                if(iter == this->end())
+                    return std::optional<std::pair<KEY, TP>>();
+                return std::optional<std::pair<KEY, TP>>(*iter++);
+            }};
+        } else {
+             return rs::iterator<std::pair<KEY, TP>>{[this, riter = this->rbegin()] () mutable -> auto {
+                if(riter == this->rend())
+                    return std::optional<std::pair<KEY, TP>>();
+                return std::optional<std::pair<KEY, TP>>(*riter++);
+            }};
+        }
+    }
+
+    template<bool REV = false>
+    rs::iterator<std::pair<const KEY*, const TP*>> into_iter_ptr() const {
+        if constexpr (!REV || !CanRev) {
+            return rs::iterator<std::pair<const KEY*, const TP*>>{[this, iter = this->cbegin()] (bool rev) mutable -> auto {
+                if(iter == this->cend())
+                    return std::optional<std::pair<const KEY*, const TP*>>();
+                auto ptr = &*iter++;
+                return std::optional<std::pair<const KEY*, const TP*>>(std::make_pair(&ptr->first, &ptr->second));
+            }};
+        } else {
+            return rs::iterator<std::pair<const KEY*, const TP*>>{[this, riter = this->crbegin()] (bool rev) mutable -> auto {
+                if(riter == this->crend())
+                    return std::optional<std::pair<const KEY*, const TP*>>();
+                auto ptr = &*riter++;
+                return std::optional<std::pair<const KEY*, const TP*>>(std::make_pair(&ptr->first, &ptr->second));
+            }};
+        }
+    }
+
+    template<bool REV = false>
+    rs::iterator<std::pair<const KEY*, TP*>> into_iter_mptr() {
+        if constexpr (!REV || !CanRev) {
+            return rs::iterator<std::pair<const KEY*, const TP*>>{[this, iter = this->begin()] (bool rev) mutable -> auto {
+                if(iter == this->end())
+                    return std::optional<std::pair<const KEY*, const TP*>>();
+                auto ptr = &*iter++;
+                return std::optional<std::pair<const KEY*, const TP*>>(std::make_pair(&ptr->first, &ptr->second));
+            }};
+        } else {
+            return rs::iterator<std::pair<const KEY*, const TP*>>{[this, riter = this->rbegin()] (bool rev) mutable -> auto {
+                if(riter == this->rend())
+                    return std::optional<std::pair<const KEY*, const TP*>>();
+                auto ptr = &*riter++;
+                return std::optional<std::pair<const KEY*, const TP*>>(std::make_pair(&ptr->first, &ptr->second));
+            }};
+        }
+    }
+
+    rs::iterator<KEY> keys() const {
+        return into_iter().unzip().first;
+    }
+
+    rs::iterator<const KEY*> keys_ptr() const {
+        return into_iter_ptr().unzip().first;
+    }
+
+    rs::iterator<TP> values() const {
+        return into_iter().unzip().second;
+    }
+
+    rs::iterator<const TP*> values_ptr() const {
+        return into_iter_ptr().unzip().second;
+    }
+    
+    void collect_item(const std::pair<KEY, TP>& value) {
+        this->insert(value);
+    }
+
+};
+
+template<typename KEY, typename TP,
+    typename COMPARE = std::less<KEY>,
+    typename ALLOC = std::allocator<std::pair<const KEY, TP>>>
+using map = map_container<std::map<KEY, TP, COMPARE, ALLOC>, KEY, TP, true>;
+template<typename KEY, typename TP,
+    typename COMPARE = std::less<KEY>,
+    typename ALLOC = std::allocator<std::pair<const KEY, TP>>>
+using multimap = map_container<std::multimap<KEY, TP, COMPARE, ALLOC>, KEY, TP, true>;
+template<typename KEY, typename TP,
+    typename HASH = std::hash<KEY>,
+	typename PRED = std::equal_to<KEY>,
+	typename ALLOC = std::allocator<std::pair<const KEY, TP>>>
+using unordered_map = map_container<std::unordered_map<KEY, TP, HASH, PRED, ALLOC>, KEY, TP, false>;
+template<typename KEY, typename TP,
+    typename HASH = std::hash<KEY>,
+	typename PRED = std::equal_to<KEY>,
+	typename ALLOC = std::allocator<std::pair<const KEY, TP>>>
+using unordered_multimap = map_container<std::unordered_multimap<KEY, TP, HASH, PRED, ALLOC>, KEY, TP, false>;
+
+}
+
+#endif