feat: add filterMap to iterator interface

README.md

@@ -129,12 +129,23 @@ All of the benchmarks measure the performance in release mode and run similar sc
 
 All of the measurements were taken on MacBook M3 Pro 18GB.
 
-#### Apply filter and map on 10 000 000 ints
+#### Filter and map
+
+Apply filter and map on 1'000'000 integers
+
+|          **Benchmark**         | **Time [ns]** | **CPU [ns]** |
+|:------------------------------:|:-------------:|:------------:|
+| benchmarkRustyIterFilterAndMap |     559108    |    559065    |
+|   benchmarkRustyIterFilterMap  |     556122    |    556120    |
+| benchmarkRangesFilterTransform |     539868    |    539786    |
+
+Apply filter and map on 10'000'000 integers
 
 |          **Benchmark**         | **Time [ns]** | **CPU [ns]** |
 |:------------------------------:|:-------------:|:------------:|
-|   benchmarkRustyIterFilterMap  |    5565001    |    5564975   |
-| benchmarkRangesFilterTransform |    5837398    |    5837397   |
+| benchmarkRustyIterFilterAndMap |    5644164    |    5643854   |
+|   benchmarkRustyIterFilterMap  |    5599177    |    5599185   |
+| benchmarkRangesFilterTransform |    5988982    |    5988701   |
 
 ## Authors
 

benchmarks/iterator.benchmark.cpp

@@ -17,7 +17,7 @@ auto initializeIncrementalVector() -> std::vector<int>
     return std::move(data);
 }
 
-auto benchmarkRustyIterFilterMap(benchmark::State& state) -> void
+auto benchmarkRustyIterFilterAndMap(benchmark::State& state) -> void
 {
     auto data = initializeIncrementalVector();
 
@@ -30,6 +30,21 @@ auto benchmarkRustyIterFilterMap(benchmark::State& state) -> void
     }
 }
 
+auto benchmarkRustyIterFilterMap(benchmark::State& state) -> void
+{
+    auto data = initializeIncrementalVector();
+
+    for (auto _ : state)
+    {
+        auto f = [](int x) -> std::optional<int> {
+            if (x % 2 == 0)
+                return std::make_optional(x * 2);
+            return std::nullopt;
+        };
+        auto result = LazyIterator{data}.filterMap(std::move(f)).collect();
+    }
+}
+
 auto benchmarkRangesFilterTransform(benchmark::State& state) -> void
 {
     auto data = initializeIncrementalVector();
@@ -64,6 +79,7 @@ auto benchmarkRustyIterCacheCycle(benchmark::State& state) -> void
     }
 }
 
+BENCHMARK(benchmarkRustyIterFilterAndMap);
 BENCHMARK(benchmarkRustyIterFilterMap);
 BENCHMARK(benchmarkRangesFilterTransform);
 BENCHMARK(benchmarkRustyIterCopyCycle);

include/rusty_iterators/concepts.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <optional>
 #include <tuple>
 
 namespace rusty_iterators::concepts
@@ -26,6 +27,11 @@ concept EqFunctor = requires(Functor f, std::tuple<T, T> t) {
 template <class T, class Functor>
 concept FilterFunctor = AllFunctor<T, Functor>;
 
+template <class Tin, class Tout, class Functor>
+concept FilterMapFunctor = requires(Functor f, Tin t) {
+    { f(t) } -> std::same_as<std::optional<Tout>>;
+};
+
 template <class B, class T, class Functor>
 concept FoldFunctor = requires(Functor f, B first, T second) {
     { f(first, second) } -> std::same_as<B>;

include/rusty_iterators/filter_map.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "concepts.hpp"
+#include "interface.fwd.hpp"
+
+#include <optional>
+
+namespace rusty_iterators::iterator
+{
+using concepts::FilterMapFunctor;
+using interface::IterInterface;
+
+template <class Tin, class Tout, class Functor, class Other>
+    requires FilterMapFunctor<Tin, Tout, Functor>
+class FilterMap : public IterInterface<Tout, FilterMap<Tin, Tout, Functor, Other>>
+{
+  public:
+    explicit FilterMap(Other&& it, Functor&& f)
+        : it(std::forward<Other>(it)), func(std::forward<Functor>(f))
+    {}
+
+    auto next() -> std::optional<Tout>;
+    [[nodiscard]] auto sizeHint() const -> std::optional<size_t>;
+
+  private:
+    Other it;
+    Functor func;
+};
+} // namespace rusty_iterators::iterator
+
+template <class Tin, class Tout, class Functor, class Other>
+    requires rusty_iterators::concepts::FilterMapFunctor<Tin, Tout, Functor>
+auto rusty_iterators::iterator::FilterMap<Tin, Tout, Functor, Other>::next() -> std::optional<Tout>
+{
+    auto nextItem = it.next();
+
+    while (nextItem.has_value())
+    {
+        auto result = func(nextItem.value());
+
+        if (result.has_value())
+        {
+            return std::make_optional(std::move(result.value()));
+        }
+        nextItem = it.next();
+    }
+    return std::nullopt;
+}
+
+template <class Tin, class Tout, class Functor, class Other>
+    requires rusty_iterators::concepts::FilterMapFunctor<Tin, Tout, Functor>
+auto rusty_iterators::iterator::FilterMap<Tin, Tout, Functor, Other>::sizeHint() const
+    -> std::optional<size_t>
+{
+    return it.sizeHint();
+}

include/rusty_iterators/interface.hpp

@@ -4,13 +4,15 @@
 #include "concepts.hpp"
 #include "cycle.hpp"
 #include "filter.hpp"
+#include "filter_map.hpp"
 #include "inspect.hpp"
 #include "map.hpp"
 #include "moving_window.hpp"
 #include "take.hpp"
 #include "zip.hpp"
 
 #include <stdexcept>
+#include <type_traits>
 #include <vector>
 
 namespace rusty_iterators::interface
@@ -20,6 +22,7 @@ using concepts::AnyFunctor;
 using concepts::Comparable;
 using concepts::EqFunctor;
 using concepts::FilterFunctor;
+using concepts::FilterMapFunctor;
 using concepts::FoldFunctor;
 using concepts::ForEachFunctor;
 using concepts::Indexable;
@@ -33,6 +36,7 @@ using iterator::Chain;
 using iterator::CopyCycle;
 using iterator::CycleType;
 using iterator::Filter;
+using iterator::FilterMap;
 using iterator::Inspect;
 using iterator::Map;
 using iterator::MovingWindow;
@@ -88,6 +92,11 @@ class IterInterface
         requires FilterFunctor<T, Functor>
     [[nodiscard]] auto filter(Functor&& f) -> Filter<T, Functor, Derived>;
 
+    template <class Functor>
+        requires FilterMapFunctor<T, typename std::invoke_result_t<Functor, T>::value_type, Functor>
+    [[nodiscard]] auto filterMap(Functor&& f)
+        -> FilterMap<T, typename std::invoke_result_t<Functor, T>::value_type, Functor, Derived>;
+
     template <class B, class Functor>
         requires FoldFunctor<B, T, Functor>
     [[nodiscard]] auto fold(B&& init, Functor&& f) -> B;
@@ -277,6 +286,17 @@ auto rusty_iterators::interface::IterInterface<T, Derived>::filter(Functor&& f)
     return Filter<T, Functor, Derived>{std::forward<Derived>(self()), std::forward<Functor>(f)};
 }
 
+template <class T, class Derived>
+template <class Functor>
+    requires rusty_iterators::concepts::FilterMapFunctor<
+        T, typename std::invoke_result_t<Functor, T>::value_type, Functor>
+auto rusty_iterators::interface::IterInterface<T, Derived>::filterMap(Functor&& f)
+    -> FilterMap<T, typename std::invoke_result_t<Functor, T>::value_type, Functor, Derived>
+{
+    return FilterMap<T, typename std::invoke_result_t<Functor, T>::value_type, Functor, Derived>{
+        std::forward<Derived>(self()), std::forward<Functor>(f)};
+}
+
 template <class T, class Derived>
 template <class B, class Functor>
     requires rusty_iterators::concepts::FoldFunctor<B, T, Functor>

tests/filter_map.test.cpp

@@ -0,0 +1,33 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <rusty_iterators/iterator.hpp>
+
+using ::rusty_iterators::iterator::LazyIterator;
+
+TEST(TestFilterMapIterator, NextChecksIfValid)
+{
+    auto vec = std::vector{1, 2, 3};
+    auto f   = [](auto x) -> std::optional<float> {
+        if (x % 2 == 0)
+            return std::make_optional(static_cast<float>(x));
+        return std::nullopt;
+    };
+    auto it = LazyIterator{vec}.filterMap(std::move(f));
+
+    ASSERT_EQ(it.next(), 2.0);
+    ASSERT_EQ(it.next(), std::nullopt);
+}
+
+TEST(TestFilterMapIterator, SizeHintReturnsValueOfUnderlyingIterator)
+{
+    auto vec = std::vector{1, 2, 3};
+    auto f   = [](auto x) -> std::optional<float> {
+        if (x % 2 == 0)
+            return std::make_optional(static_cast<float>(x));
+        return std::nullopt;
+    };
+    auto it = LazyIterator{vec}.filterMap(std::move(f));
+
+    ASSERT_EQ(it.sizeHint(), 3.0);
+}