add zip for single iterator pairs

CMakeLists.txt

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

include/blt/iterator/common.h

@@ -99,7 +99,8 @@ namespace blt::iterator
     {
     public:
         explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
-            {}
+        {
+        }
 
         auto base() const
         {
@@ -171,7 +172,8 @@ namespace blt::iterator
 
         map_wrapper(Iter iter, Func func):
             deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
-            {}
+        {
+        }
 
         reference operator*() const
         {
@@ -197,7 +199,8 @@ namespace blt::iterator
 
         filter_wrapper(Iter iter, Pred func):
             deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
-            {}
+        {
+        }
 
         reference operator*() const
         {
@@ -231,11 +234,13 @@ namespace blt::iterator
                     if constexpr (check)
                     {
                         return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
-                        } else
+                    }
+                    else
                     {
                         return Derived{begin + n, end};
                     }
-                    } else
+                }
+                else
                 {
                     for (blt::size_t i = 0; i < n; i++)
                     {
@@ -252,10 +257,14 @@ namespace blt::iterator
 
         public:
             auto skip(blt::size_t n)
-                { return skip_base<false>(n); }
+            {
+                return skip_base<false>(n);
+            }
 
             auto skip_or(blt::size_t n)
-                { return skip_base<true>(n); }
+            {
+                return skip_base<true>(n);
+            }
         };
 
         template <typename Derived>
@@ -287,13 +296,15 @@ namespace blt::iterator
                         ++new_end;
                     }
                     return Derived{std::move(begin), std::move(new_end)};
-                    } else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
+                }
+                else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
                 {
                     // random access iterators can have math directly applied to them.
                     if constexpr (check)
                     {
                         return Derived{begin, begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end))};
-                        } else
+                    }
+                    else
                     {
                         return Derived{begin, begin + n};
                     }
@@ -302,10 +313,14 @@ namespace blt::iterator
 
         public:
             auto take(blt::size_t n)
-                { return take_base<false>(n); }
+            {
+                return take_base<false>(n);
+            }
 
             auto take_or(blt::size_t n)
-                { return take_base<true>(n); }
+            {
+                return take_base<true>(n);
+            }
         };
     }
 
@@ -318,18 +333,22 @@ namespace blt::iterator
         using iterator = IterBase;
 
         iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end))
-            {}
+        {
+        }
 
         template <typename Iter>
         iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end))
-            {}
+        {
+        }
 
         auto rev() const
         {
             static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
                           ".rev() must be used with bidirectional (or better) iterators!");
-                return iterator_container<std::reverse_iterator<IterBase>>{std::reverse_iterator<IterBase>{end()},
+            return iterator_container<std::reverse_iterator<IterBase>>{
-                                                                           std::reverse_iterator<IterBase>{begin()}};
+                std::reverse_iterator<IterBase>{end()},
+                std::reverse_iterator<IterBase>{begin()}
+            };
         }
 
         template <typename... Iter>
@@ -352,6 +371,12 @@ namespace blt::iterator
                                           iterator_pair{containers.begin(), containers.end()}...);
         }
 
+        template <typename Iter>
+        auto zip(Iter begin, Iter end)
+        {
+            return zip(iterator_pair<Iter>{begin, end});
+        }
+
         auto enumerate() const
         {
             return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
@@ -362,7 +387,8 @@ namespace blt::iterator
         {
             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}};
+                blt::iterator::map_wrapper<IterBase, Func>{m_end, func}
+            };
         }
 
         template <typename Pred>
@@ -370,7 +396,8 @@ namespace blt::iterator
         {
             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}};
+                blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}
+            };
         }
 
         auto begin() const
@@ -387,7 +414,6 @@ namespace blt::iterator
         IterBase m_begin;
         IterBase m_end;
     };
-    
 }
 
 #endif //BLT_ITERATOR_ITER_COMMON