feat: add product to iterator interface

include/rusty_iterators/concepts.hpp

@@ -60,6 +60,11 @@ concept InspectFunctor = requires(Functor f, T& t) {
 template <class T, class Functor>
 concept PositionFunctor = AllFunctor<T, Functor>;
 
+template <class T>
+concept Multiplyable = requires(T first, T second) {
+    { first* second } -> std::same_as<T>;
+};
+
 template <class T, class Functor>
 concept ReduceFunctor = FoldFunctor<T, T, Functor>;
 

include/rusty_iterators/interface.hpp

@@ -30,6 +30,7 @@ using concepts::FoldFunctor;
 using concepts::ForEachFunctor;
 using concepts::Indexable;
 using concepts::InspectFunctor;
+using concepts::Multiplyable;
 using concepts::NeFunctor;
 using concepts::PositionFunctor;
 using concepts::ReduceFunctor;
@@ -149,6 +150,10 @@ class IterInterface
         requires PositionFunctor<T, Functor>
     [[nodiscard]] auto position(Functor&& f) -> std::optional<size_t>;
 
+    template <class R = T>
+        requires Multiplyable<R>
+    [[nodiscard]] auto product() -> std::optional<R>;
+
     template <class Functor>
         requires ReduceFunctor<T, Functor>
     [[nodiscard]] auto reduce(Functor&& f) -> std::optional<T>;
@@ -434,6 +439,14 @@ auto rusty_iterators::interface::IterInterface<T, Derived>::position(Functor&& f
     return std::nullopt;
 }
 
+template <class T, class Derived>
+template <class R>
+    requires rusty_iterators::concepts::Multiplyable<R>
+auto rusty_iterators::interface::IterInterface<T, Derived>::product() -> std::optional<R>
+{
+    return self().reduce([](auto acc, auto x) { return acc * x; });
+}
+
 template <class T, class Derived>
 template <class Functor>
     requires rusty_iterators::concepts::ReduceFunctor<T, Functor>

include/rusty_iterators/iterator.hpp

@@ -16,6 +16,7 @@ using Item = std::reference_wrapper<const typename Container::value_type>;
 namespace rusty_iterators::iterator
 {
 using concepts::FoldFunctor;
+using concepts::Multiplyable;
 using concepts::Summable;
 
 template <class Container>
@@ -32,6 +33,10 @@ class LazyIterator : public interface::IterInterface<Item<Container>, LazyIterat
     auto next() -> std::optional<T>;
     [[nodiscard]] auto sizeHint() const -> std::optional<size_t>;
 
+    template <class R = RawT>
+        requires Multiplyable<R>
+    [[nodiscard]] auto product() -> std::optional<R>;
+
     template <class R = RawT>
         requires Summable<R>
     [[nodiscard]] auto sum() -> R;
@@ -62,11 +67,20 @@ auto rusty_iterators::iterator::LazyIterator<Container>::sizeHint() const -> std
     return end - ptr;
 }
 
+template <class Container>
+    requires std::ranges::range<Container>
+template <class R>
+    requires rusty_iterators::concepts::Multiplyable<R>
+auto rusty_iterators::iterator::LazyIterator<Container>::product() -> std::optional<R>
+{
+    return this->map([](auto x) { return x.get(); }).product();
+}
+
 template <class Container>
     requires std::ranges::range<Container>
 template <class R>
     requires rusty_iterators::concepts::Summable<R>
 auto rusty_iterators::iterator::LazyIterator<Container>::sum() -> R
 {
-    return this->fold(RawT{}, [](auto acc, auto x) { return acc + x; });
+    return this->map([](auto x) { return x.get(); }).sum();
 }

tests/iterator.test.cpp

@@ -379,3 +379,19 @@ TEST(TestIterator, TestLast)
 
     ASSERT_EQ(it.last(), 3);
 }
+
+TEST(TestIterator, TestLazyIteratorProduct)
+{
+    auto vec = std::vector{1, 2, 3, 4};
+    auto it  = LazyIterator{vec};
+
+    ASSERT_EQ(it.product(), 1 * 2 * 3 * 4);
+}
+
+TEST(TestIterator, TestProductOnMapIterator)
+{
+    auto vec = std::vector{1, 2, 3, 4};
+    auto it  = LazyIterator{vec}.map([](auto x) { return x * 2; });
+
+    ASSERT_EQ(it.product(), 2 * 4 * 6 * 8);
+}