not so clever maps

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 include(cmake/color.cmake)
-set(BLT_VERSION 1.1.8)
+set(BLT_VERSION 2.0.4)
 
 set(BLT_TARGET BLT)
 

commit.py

@@ -199,6 +199,8 @@ def make_release(env: EnvData, name):
 		'X-GitHub-Api-Version': '2022-11-28'
 	}
 	for url in urls:
+		if not "github" in url:
+			continue
 		response = requests.post(url, headers=headers, data=json.dumps(data))
 		if response.status_code == 201:
 			print('Release created successfully!')

include/blt/iterator/common.h

@@ -25,6 +25,8 @@
 #include <blt/iterator/fwddecl.h>
 #include <blt/meta/meta.h>
 #include <blt/meta/iterator.h>
+#include <functional>
+#include <optional>
 
 namespace blt::iterator
 {
@@ -110,7 +112,7 @@ namespace blt::iterator
             }
         
         protected:
-            Iter iter;
+            mutable Iter iter;
     };
     
     template<typename Iter, typename Derived>
@@ -122,28 +124,92 @@ namespace blt::iterator
         {
             return *this->iter;
         }
+    };
     
-//        zip_wrapper& operator++()
+    template<typename Iter, typename Derived>
-//        {
+    class deref_only_wrapper : public passthrough_wrapper<Iter, Derived, false>
-//            return *this;
+    {
-//        }
+        public:
-//
+            using passthrough_wrapper<Iter, Derived, false>::passthrough_wrapper;
-//        zip_wrapper& operator--()
+            
-//        {
+            deref_only_wrapper& operator++()
-//            return *this;
+            {
-//        }
+                ++this->iter;
-//
+                return *this;
-//        friend zip_wrapper operator+(const zip_wrapper& a, blt::ptrdiff_t n)
+            }
-//        {
+            
-//            static_assert(std::is_same_v<iterator_category, std::random_access_iterator_tag>,
+            deref_only_wrapper& operator--()
-//                          "Iterator must allow random access");
+            {
-//        }
+                --this->iter;
-//
+                return *this;
-//        friend zip_wrapper operator-(const zip_wrapper& a, blt::ptrdiff_t n)
+            }
-//        {
+            
-//            static_assert(std::is_same_v<iterator_category, std::random_access_iterator_tag>,
+            deref_only_wrapper& operator+(blt::ptrdiff_t n)
-//                          "Iterator must allow random access");
+            {
-//        }
+                static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
+                this->iter = this->iter + n;
+                return *this;
+            }
+            
+            deref_only_wrapper& operator-(blt::ptrdiff_t n)
+            {
+                static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
+                this->iter = this->iter - n;
+                return *this;
+            }
+    };
+    
+    template<typename Iter, typename Func>
+    class map_wrapper : public deref_only_wrapper<Iter, map_wrapper<Iter, Func>>
+    {
+        public:
+            using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
+            using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>;
+            using difference_type = blt::ptrdiff_t;
+            using pointer = value_type;
+            using reference = value_type;
+            
+            map_wrapper(Iter iter, Func func):
+                    deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
+            {}
+            
+            reference operator*() const
+            {
+                return func(*this->iter);
+            }
+        
+        private:
+            Func func;
+    };
+    
+    template<typename Iter, typename Pred>
+    class filter_wrapper : public deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>
+    {
+        public:
+            using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
+            using value_type = std::conditional_t<
+                    std::is_reference_v<meta::deref_return_t<Iter>>,
+                    std::optional<std::reference_wrapper<std::remove_reference_t<meta::deref_return_t<Iter>>>>,
+                    std::optional<meta::deref_return_t<Iter>>>;
+            using difference_type = blt::ptrdiff_t;
+            using pointer = value_type;
+            using reference = value_type;
+            
+            filter_wrapper(Iter iter, Pred func):
+                    deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
+            {}
+            
+            reference operator*() const
+            {
+                if (!func(*this->iter))
+                {
+                    return {};
+                }
+                return *this->iter;
+            }
+        
+        private:
+            Pred func;
     };
     
     namespace impl
@@ -291,6 +357,22 @@ namespace blt::iterator
                 return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
             }
             
+            template<typename Func>
+            auto map(Func func) const
+            {
+                return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{
+                        blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
+                        blt::iterator::map_wrapper<IterBase, Func>{m_end, func}};
+            }
+            
+            template<typename Pred>
+            auto filter(Pred pred) const
+            {
+                return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{
+                        blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred},
+                        blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}};
+            }
+            
             auto begin() const
             {
                 return m_begin;

include/blt/iterator/enumerate.h

@@ -108,20 +108,6 @@ namespace blt
     template<typename Iter>
     enumerate_iterator_container(Iter, Iter, blt::size_t) -> enumerate_iterator_container<Iter>;
     
-    namespace iterator::impl
-    {
-        template<typename Derived>
-        class enumerate_t
-        {
-            public:
-                auto enumerate()
-                {
-                    auto* d = static_cast<Derived*>(this);
-                    return enumerate_iterator_container{d->begin(), d->end(), static_cast<blt::size_t>(std::distance(d->begin(), d->end()))};
-                }
-        };
-    }
-    
     template<typename T>
     static inline auto enumerate(T& container)
     {

include/blt/iterator/fwddecl.h

@@ -41,6 +41,12 @@ namespace blt
         template<typename... Iter>
         struct zip_wrapper;
         
+        template<typename Iter, typename Func>
+        class map_wrapper;
+        
+        template<typename Iter, typename Pred>
+        class filter_wrapper;
+        
         namespace impl
         {
             template<typename Derived>
@@ -48,12 +54,6 @@ namespace blt
             
             template<typename Derived>
             class take_t;
-            
-            template<typename Derived>
-            class zip_t;
-            
-            template<typename Derived>
-            class enumerate_t;
         }
     }
 }

include/blt/iterator/zip.h

@@ -121,21 +121,6 @@ namespace blt
         
     };
     
-    namespace iterator::impl
-    {
-        template<typename Derived>
-        class zip_t
-        {
-            public:
-                template<typename... Iter>
-                auto zip(iterator::iterator_pair<Iter>... iterator_pairs)
-                {
-                    auto* d = static_cast<Derived*>(this);
-                    return zip_iterator_container(iterator::iterator_pair<decltype(d->begin())>{d->begin(), d->end()}, iterator_pairs...);
-                }
-        };
-    }
-    
     /*
      * CTAD for the zip containers
      */

include/blt/meta/meta.h

@@ -95,104 +95,10 @@ namespace blt::meta
     template<class T>
     inline constexpr bool is_streamable_v = is_streamable<T>::value;
     
-    namespace detail
-    {
-        template<typename Or>
-        struct value_type_helper
-        {
-            template<typename Subs>
-            inline static constexpr auto get(int) -> typename Subs::value_type
-            {
-                return std::declval<Subs::value_type>();
-            }
-            
-            template<typename>
-            inline static constexpr Or get(...)
-            {
-                return std::declval<Or>();
-            }
-        };
-        
-        template<typename Or>
-        struct reference_type_helper
-        {
-            template<typename Subs>
-            inline static constexpr auto get(int) -> typename Subs::reference
-            {
-                return std::declval<typename Subs::reference>();
-            }
-            
-            template<typename>
-            inline static constexpr Or get(...)
-            {
-                return std::declval<Or>();
-            }
-        };
-        
-        template<typename Or>
-        struct const_reference_type_helper
-        {
-            template<typename Subs>
-            inline static constexpr auto get(int) -> typename Subs::const_reference
-            {
-                return std::declval<typename Subs::const_reference>();
-            }
-            
-            template<typename>
-            inline static constexpr Or get(...)
-            {
-                return std::declval<Or>();
-            }
-        };
-        
-        template<typename Or>
-        struct pointer_type_helper
-        {
-            template<typename Subs>
-            inline static constexpr auto get(int) -> typename Subs::pointer
-            {
-                return std::declval<typename Subs::pointer>();
-            }
-            
-            template<typename>
-            inline static constexpr Or get(...)
-            {
-                return std::declval<Or>();
-            }
-        };
-        
-        template<typename Or>
-        struct difference_type_helper
-        {
-            template<typename Subs>
-            inline static constexpr auto get(int) -> typename Subs::difference_type
-            {
-                return std::declval<typename Subs::difference_type>();
-            }
-            
-            template<typename>
-            inline static constexpr Or get(...)
-            {
-                return std::declval<Or>();
-            }
-        };
-    }
-    
-    template<typename T, typename Or>
-    using value_type_t = decltype(detail::value_type_helper<Or>::template get<T>(0));
-    template<typename T, typename Or>
-    using difference_t = decltype(detail::difference_type_helper<Or>::template get<T>(0));
-    template<typename T, typename Or>
-    using pointer_t = decltype(detail::pointer_type_helper<Or>::template get<T>(0));
-    template<typename T, typename Or>
-    using reference_t = decltype(detail::reference_type_helper<Or>::template get<T>(0));
-    template<typename T, typename Or>
-    using const_reference_t = decltype(detail::const_reference_type_helper<Or>::template get<T>(0));
-    
     template<typename T>
     struct arrow_return
     {
-        using type = typename std::result_of<decltype(&T::operator->)(T*)>::type;
+        using type = typename std::invoke_result_t<decltype(&T::operator->), T*>;
     };
     
     template<typename T>
@@ -208,7 +114,7 @@ namespace blt::meta
     template<typename T>
     struct deref_return
     {
-        using type = typename std::result_of<decltype(&T::operator*)(T*)>::type;
+        using type = typename std::invoke_result_t<decltype(&T::operator*), T&>;
     };
     
     template<typename T>

libraries/parallel-hashmap

@@ -1 +1 @@
-Subproject commit 7ef2e733416953b222851f9a360d7fc72d068ee5
+Subproject commit 93201da2ba5a6aba0a6e57ada64973555629b3e3

tests/iterator_tests.cpp

@@ -191,11 +191,63 @@ void test_iterate()
         BLT_TRACE_STREAM << "Zip: " << a << " " << b << "\n";
     }
     BLT_TRACE("================================");
-    for (auto [i, data] : blt::iterate(array_1).zip(list_1).skip(3).take(4).enumerate())
+    for (auto [i, data] : blt::iterate(array_1).map([](const blt::vec2& in) { return in.normalize(); }).zip(list_1).skip(3).take(4).enumerate())
     {
         auto [a, b] = data;
-        BLT_TRACE_STREAM << "Zip (" << i << "): " << a << " " << b << "\n";
+        BLT_TRACE_STREAM << "Map + Zip + Skip + Take + Enumerate (Index: " << i << ")> " << a << " " << b << "\n";
     }
+    BLT_TRACE("================================");
+    for (auto [i, data] : blt::iterate(array_1).map(
+            [](const blt::vec2& in) {
+                return in.normalize();
+            }).zip(list_1).skip(3).take(4).enumerate())
+    {
+        auto [a, b] = data;
+        BLT_TRACE_STREAM << "Map + Zip + Skip + Take + Enumerate (Index: " << i << ")> " << a << " " << b << "\n";
+    }
+    BLT_TRACE("================================");
+    for (auto a : blt::iterate(array_1).map([](const blt::vec2& in) { return in.normalize(); })
+                                       .filter([](const blt::vec2& f) { return f.x() > 0.5; }))
+    {
+        if (!a)
+            continue;
+        auto v = *a;
+        BLT_TRACE_STREAM << " So this one works? " << v << "\n";
+    }
+    BLT_TRACE("================================");
+    for (auto a : blt::iterate(array_1).map([](const blt::vec2& in) { return in.normalize(); })
+                                       .enumerate().filter([](const auto& f) { return f.value.x() > 0.5; }))
+    {
+        if (!a)
+            continue;
+        auto [index, v] = *a;
+        BLT_TRACE_STREAM << " So this one works? (" << index << ")" << v << "\n";
+    }
+    BLT_TRACE("================================");
+//    for (auto a : blt::iterate(array_1).filter([](const auto& f) { return f.x() > 3 && f.y() < 6; }).take(2))
+//    {
+//        if (!a)
+//            continue;
+//        auto v = *a;
+//        BLT_TRACE_STREAM << " How about this one?? " << v.get() << "\n";
+//    }
+    for (auto a : blt::iterate(array_1).map([](const auto& f) { return f.x() > 3 && f.y() < 6; }))
+    {
+        BLT_TRACE_STREAM << " How about this one?? " << a << "\n";
+    }
+
+//    for (auto [value, a] : blt::iterate(array_1).map(
+//            [](const blt::vec2& in) {
+//                return in.normalize();
+//            }).enumerate().filter([](const auto& v) {
+//                return v.index % 2 == 0;
+//            }).zip(array_2).skip(3))
+//    {
+//        if (!value)
+//            continue;
+//        auto [i, v] = *value;
+//        BLT_TRACE_STREAM << "Enumerate Filter (Index: " << i << ")> " << v << "\n";
+//    }
 }
 
 int main()