feat: add eq and eqBy to iterator interface

include/rusty_iterators/concepts.hpp

@@ -17,6 +17,12 @@ concept Comparable = requires(T first, T second) {
     { first > second } -> std::same_as<bool>;
     { first < second } -> std::same_as<bool>;
 };
+
+template <class T, class Functor>
+concept EqFunctor = requires(Functor f, std::tuple<T, T> t) {
+    { f(t) } -> std::same_as<bool>;
+};
+
 template <class T, class Functor>
 concept FilterFunctor = AllFunctor<T, Functor>;
 
@@ -37,10 +43,10 @@ concept Indexable = requires(T t) {
 };
 
 template <class T, class Functor>
-concept PositionFunctor = AllFunctor<T, Functor>;
+concept InspectFunctor = ForEachFunctor<T, Functor>;
 
 template <class T, class Functor>
-concept InspectFunctor = ForEachFunctor<T, Functor>;
+concept PositionFunctor = AllFunctor<T, Functor>;
 
 template <class T>
 concept Summable = requires(T first, T second) {

include/rusty_iterators/interface.hpp

@@ -18,6 +18,7 @@ namespace rusty_iterators::interface
 using concepts::AllFunctor;
 using concepts::AnyFunctor;
 using concepts::Comparable;
+using concepts::EqFunctor;
 using concepts::FilterFunctor;
 using concepts::FoldFunctor;
 using concepts::ForEachFunctor;
@@ -76,6 +77,13 @@ class IterInterface
     template <class Second>
     [[nodiscard]] auto chain(Second&& it) -> Chain<T, Derived, Second>;
 
+    template <class Other>
+    [[nodiscard]] auto eq(Other&& it) -> bool;
+
+    template <class Other, class Functor>
+        requires EqFunctor<T, Functor>
+    [[nodiscard]] auto eqBy(Other&& it, Functor&& f) -> bool;
+
     template <class Functor>
         requires FilterFunctor<T, Functor>
     [[nodiscard]] auto filter(Functor&& f) -> Filter<T, Functor, Derived>;
@@ -244,6 +252,22 @@ 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>
+template <class Other>
+auto rusty_iterators::interface::IterInterface<T, Derived>::eq(Other&& it) -> bool
+{
+    return self().eqBy(std::forward<Other>(it),
+                       [](auto x) { return std::get<0>(x) == std::get<1>(x); });
+}
+
+template <class T, class Derived>
+template <class Other, class Functor>
+    requires rusty_iterators::concepts::EqFunctor<T, Functor>
+auto rusty_iterators::interface::IterInterface<T, Derived>::eqBy(Other&& it, Functor&& f) -> bool
+{
+    return self().zip(std::forward<Other>(it)).all(std::forward<Functor>(f));
+}
+
 template <class T, class Derived>
 template <class Functor>
     requires rusty_iterators::iterator::FilterFunctor<T, Functor>
@@ -312,15 +336,15 @@ template <class R>
     requires rusty_iterators::concepts::Comparable<R>
 auto rusty_iterators::interface::IterInterface<T, Derived>::max() -> std::optional<R>
 {
-    return reduce([](auto x, auto y) { return std::max(x, y); });
+    return self().reduce([](auto x, auto y) { return std::max(x, y); });
 }
 
 template <class T, class Derived>
 template <class R>
     requires rusty_iterators::concepts::Comparable<R>
 auto rusty_iterators::interface::IterInterface<T, Derived>::min() -> std::optional<R>
 {
-    return reduce([](auto x, auto y) { return std::min(x, y); });
+    return self().reduce([](auto x, auto y) { return std::min(x, y); });
 }
 
 template <class T, class Derived>
@@ -333,7 +357,7 @@ auto rusty_iterators::interface::IterInterface<T, Derived>::movingWindow(size_t
 template <class T, class Derived>
 auto rusty_iterators::interface::IterInterface<T, Derived>::nth(size_t element) -> std::optional<T>
 {
-    return advanceBy(element).next();
+    return self().advanceBy(element).next();
 }
 
 template <class T, class Derived>
@@ -379,7 +403,7 @@ template <class R>
     requires rusty_iterators::concepts::Summable<R>
 auto rusty_iterators::interface::IterInterface<T, Derived>::sum() -> R
 {
-    return fold(R{}, [](auto acc, auto x) { return acc + x; });
+    return self().fold(R{}, [](auto acc, auto x) { return acc + x; });
 }
 
 template <class T, class Derived>

tests/iterator.test.cpp

@@ -289,3 +289,32 @@ TEST(TestIterator, TestPositionNoValueMatched)
 
     ASSERT_EQ(result, std::nullopt);
 }
+
+TEST(TestIterator, TestEqWhenSame)
+{
+    auto v1 = std::vector{1, 2, 3};
+    auto v2 = std::vector{1, 2, 3};
+
+    ASSERT_TRUE(LazyIterator{v1}.eq(LazyIterator{v2}));
+}
+
+TEST(TestIterator, TestEqWhenDifferent)
+{
+    auto v1 = std::vector{1, 2, 3};
+    auto v2 = std::vector{1, 2, 4};
+
+    ASSERT_FALSE(LazyIterator{v1}.eq(LazyIterator{v2}));
+}
+
+TEST(TestIterator, TestEqBy)
+{
+    auto v1 = std::vector<std::string>{"a", "bc", "dea"};
+    auto v2 = std::vector<std::string>{"j", "hg", "dfg"};
+
+    // Compare the vectors not by exact content, but by length of strings.
+    auto result = LazyIterator{v1}.eqBy(LazyIterator{v2}, [](auto x) {
+        return std::get<0>(x).get().size() == std::get<1>(x).get().size();
+    });
+
+    ASSERT_TRUE(result);
+}