feat: add enumerate to iterator interface

include/rusty_iterators/enumerate.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "interface.fwd.hpp"
+
+#include <optional>
+#include <tuple>
+
+namespace rusty_iterators::iterator
+{
+using interface::IterInterface;
+
+template <class T, class Other>
+class Enumerate : public IterInterface<std::tuple<size_t, T>, Enumerate<T, Other>>
+{
+  public:
+    explicit Enumerate(Other&& it) : it(std::forward<Other>(it)) {}
+
+    [[nodiscard]] auto count() -> size_t;
+    auto next() -> std::optional<std::tuple<size_t, T>>;
+    [[nodiscard]] auto sizeHint() const -> std::optional<size_t>;
+
+  private:
+    Other it;
+    size_t idx = 0;
+};
+} // namespace rusty_iterators::iterator
+
+template <class T, class Other>
+auto rusty_iterators::iterator::Enumerate<T, Other>::count() -> size_t
+{
+    return it.count();
+}
+
+template <class T, class Other>
+auto rusty_iterators::iterator::Enumerate<T, Other>::next() -> std::optional<std::tuple<size_t, T>>
+{
+    auto nextItem = it.next();
+
+    if (!nextItem.has_value())
+    {
+        return std::nullopt;
+    }
+    return std::tuple{idx++, std::move(nextItem.value())};
+}
+
+template <class T, class Other>
+auto rusty_iterators::iterator::Enumerate<T, Other>::sizeHint() const -> std::optional<size_t>
+{
+    return it.sizeHint();
+}

include/rusty_iterators/interface.hpp

@@ -3,6 +3,7 @@
 #include "chain.hpp"
 #include "concepts.hpp"
 #include "cycle.hpp"
+#include "enumerate.hpp"
 #include "filter.hpp"
 #include "filter_map.hpp"
 #include "inspect.hpp"
@@ -37,6 +38,7 @@ using iterator::CacheCycle;
 using iterator::Chain;
 using iterator::CopyCycle;
 using iterator::CycleType;
+using iterator::Enumerate;
 using iterator::Filter;
 using iterator::FilterMap;
 using iterator::Inspect;
@@ -83,6 +85,8 @@ class IterInterface
     template <class Second>
     [[nodiscard]] auto chain(Second&& it) -> Chain<T, Derived, Second>;
 
+    [[nodiscard]] auto enumerate() -> Enumerate<T, Derived>;
+
     template <class Other>
     [[nodiscard]] auto eq(Other&& it) -> bool;
 
@@ -251,6 +255,12 @@ auto rusty_iterators::interface::IterInterface<T, Derived>::chain(Second&& it)
     return Chain<T, Derived, Second>{std::forward<Derived>(self()), std::forward<Second>(it)};
 }
 
+template <class T, class Derived>
+auto rusty_iterators::interface::IterInterface<T, Derived>::enumerate() -> Enumerate<T, Derived>
+{
+    return Enumerate<T, Derived>{std::forward<Derived>(self())};
+}
+
 template <class T, class Derived>
 template <class Other>
 auto rusty_iterators::interface::IterInterface<T, Derived>::eq(Other&& it) -> bool

tests/enumerate.test.cpp

@@ -0,0 +1,47 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <rusty_iterators/iterator.hpp>
+
+using ::rusty_iterators::iterator::LazyIterator;
+using ::testing::FieldsAre;
+
+TEST(TestEnumerateIterator, TestNextReturnsIndexedValue)
+{
+    auto vec = std::vector{1, 2, 3};
+    auto it  = LazyIterator{vec}.enumerate();
+
+    EXPECT_THAT(it.next().value(), FieldsAre(0, 1));
+    EXPECT_THAT(it.next().value(), FieldsAre(1, 2));
+    EXPECT_THAT(it.next().value(), FieldsAre(2, 3));
+    ASSERT_EQ(it.next(), std::nullopt);
+}
+
+TEST(TestEnumerateIterator, TestCollectedTuples)
+{
+    auto vec    = std::vector{1, 2, 3};
+    auto result = LazyIterator{vec}.enumerate().collect();
+
+    ASSERT_EQ(result.size(), 3);
+    EXPECT_THAT(result[0], FieldsAre(0, 1));
+    EXPECT_THAT(result[1], FieldsAre(1, 2));
+    EXPECT_THAT(result[2], FieldsAre(2, 3));
+}
+
+TEST(TestEnumerateIterator, TestSizeHintReturnsUnderlyingSize)
+{
+    auto vec = std::vector{1, 2, 3};
+    auto it  = LazyIterator{vec}.enumerate();
+
+    ASSERT_EQ(it.sizeHint(), 3);
+}
+
+TEST(TestEnumerateIterator, TestCountReturnsRealCount)
+{
+    auto vec = std::vector{1, 2, 3};
+    auto it  = LazyIterator{vec}.enumerate();
+
+    it.next();
+
+    ASSERT_EQ(it.count(), 2);
+}