Fixed lazy_set and lazy_map ownership

Author: jkalias

include/map.h

@@ -73,15 +73,6 @@ class lazy_map
         };
     }
 
-    // Creates a lazy map by referring to an existing std::map source.
-    // The referenced map must outlive this lazy map.
-    explicit lazy_map(const std::map<TKey, TValue, TCompare>* map)
-    {
-        m_operation = [map](const std::function<void(const value_type&)>& consumer) {
-            std::for_each(map->begin(), map->end(), consumer);
-        };
-    }
-
     // Creates a lazy map by directly providing the deferred operation.
     // This constructor is mostly useful for composing lazy_map instances.
     explicit lazy_map(std::function<void(const std::function<void(const value_type&)>&)> operation)
@@ -617,7 +608,7 @@ class map
     // until a terminal operation, such as get() or reduce(), is called.
     [[nodiscard]] lazy_map<TKey, TValue, TCompare> lazy() const
     {
-        return lazy_map<TKey, TValue, TCompare>(&m_map);
+        return lazy_map<TKey, TValue, TCompare>(m_map);
     }
 
     // Returns the begin iterator, useful for other standard library algorithms

include/set.h

@@ -78,15 +78,6 @@ namespace fcpp {
             };
         }
 
-        // Creates a lazy set by referring to an existing std::set source.
-        // The referenced set must outlive this lazy set.
-        explicit lazy_set(const std::set<TKey, TCompare>* set)
-        {
-            m_operation = [set](const std::function<void(const TKey&)>& consumer) {
-                std::for_each(set->begin(), set->end(), consumer);
-            };
-        }
-
         // Creates a lazy set by directly providing the deferred operation.
         // This constructor is mostly useful for composing lazy_set instances.
         explicit lazy_set(std::function<void(const std::function<void(const TKey&)>&)> operation)
@@ -187,22 +178,7 @@ namespace fcpp {
         //      diff -> fcpp::set<int>({1, 3, 8})
         [[nodiscard]] lazy_set difference_with(const set<TKey, TCompare>& other) const
         {
-            const auto previous = m_operation;
-            return lazy_set(
-                [previous, &other](const std::function<void(const TKey&)>& consumer) {
-                    std::set<TKey, TCompare> current;
-                    previous([&current](const TKey& key) {
-                        current.insert(key);
-                    });
-
-                    std::set<TKey, TCompare> diff;
-                    std::set_difference(current.begin(),
-                                        current.end(),
-                                        other.begin(),
-                                        other.end(),
-                                        std::inserter(diff, diff.begin()));
-                    std::for_each(diff.begin(), diff.end(), consumer);
-                });
+            return difference_with(lazy_set(std::set<TKey, TCompare>(other.begin(), other.end())));
         }
 
         // Returns the lazy set of elements which belong to this lazy set but not in the std::set.
@@ -250,22 +226,7 @@ namespace fcpp {
         //      combined -> fcpp::set<int>({1, 2, 3, 5, 7, 8, 10, 15, 17})
         [[nodiscard]] lazy_set union_with(const set<TKey, TCompare>& other) const
         {
-            const auto previous = m_operation;
-            return lazy_set(
-                [previous, &other](const std::function<void(const TKey&)>& consumer) {
-                    std::set<TKey, TCompare> current;
-                    previous([&current](const TKey& key) {
-                        current.insert(key);
-                    });
-
-                    std::set<TKey, TCompare> combined;
-                    std::set_union(current.begin(),
-                                   current.end(),
-                                   other.begin(),
-                                   other.end(),
-                                   std::inserter(combined, combined.begin()));
-                    std::for_each(combined.begin(), combined.end(), consumer);
-                });
+            return union_with(lazy_set(std::set<TKey, TCompare>(other.begin(), other.end())));
         }
 
         // Returns the lazy set of elements which belong either to this lazy set or the std::set.
@@ -313,22 +274,7 @@ namespace fcpp {
         //      combined -> fcpp::set<int>({2, 5, 7, 10})
         [[nodiscard]] lazy_set intersect_with(const set<TKey, TCompare>& other) const
         {
-            const auto previous = m_operation;
-            return lazy_set(
-                [previous, &other](const std::function<void(const TKey&)>& consumer) {
-                    std::set<TKey, TCompare> current;
-                    previous([&current](const TKey& key) {
-                        current.insert(key);
-                    });
-
-                    std::set<TKey, TCompare> intersection;
-                    std::set_intersection(current.begin(),
-                                          current.end(),
-                                          other.begin(),
-                                          other.end(),
-                                          std::inserter(intersection, intersection.begin()));
-                    std::for_each(intersection.begin(), intersection.end(), consumer);
-                });
+            return intersect_with(lazy_set(std::set<TKey, TCompare>(other.begin(), other.end())));
         }
 
         // Returns the lazy set of elements which belong to both this lazy set and the std::set.
@@ -367,35 +313,15 @@ namespace fcpp {
         template <typename UKey, typename UCompare>
         [[nodiscard]] lazy_set<std::pair<TKey, UKey>> zip(const set<UKey, UCompare>& set) const
         {
-            const auto previous = m_operation;
-            return lazy_set<std::pair<TKey, UKey>>(
-                [previous, &set](const std::function<void(const std::pair<TKey, UKey>&)>& consumer) {
-                    size_t index = 0;
-                    previous([&set, &consumer, &index](const TKey& key) {
-                        assert(index < set.size());
-                        consumer({key, set[index]});
-                        ++index;
-                    });
-                    assert(index == set.size());
-                });
+            return zip(lazy_set<UKey, UCompare>(std::set<UKey, UCompare>(set.begin(), set.end())));
         }
 
         // Performs the functional `zip` algorithm lazily.
         // The sizes of the two sets must be equal.
         template <typename UKey, typename UCompare>
         [[nodiscard]] lazy_set<std::pair<TKey, UKey>> zip(const std::set<UKey, UCompare>& set) const
         {
-            const auto previous = m_operation;
-            return lazy_set<std::pair<TKey, UKey>>(
-                [previous, &set](const std::function<void(const std::pair<TKey, UKey>&)>& consumer) {
-                    auto it = set.begin();
-                    previous([&set, &it, &consumer](const TKey& key) {
-                        assert(it != set.end());
-                        consumer({key, *it});
-                        ++it;
-                    });
-                    assert(it == set.end());
-                });
+            return zip(lazy_set<UKey, UCompare>(set));
         }
 
         // Performs the functional `zip` algorithm lazily where duplicates are removed before zipping.
@@ -1082,7 +1008,7 @@ namespace fcpp {
         // transformations until a terminal operation, such as get() or reduce(), is called.
         [[nodiscard]] lazy_set<TKey, TCompare> lazy() const
         {
-            return lazy_set<TKey, TCompare>(&m_set);
+            return lazy_set<TKey, TCompare>(m_set);
         }
 
         // Returns the begin iterator, useful for other standard library algorithms

tests/map_test.cc

@@ -314,6 +314,32 @@ TEST(MapTest, LazyReduce)
     EXPECT_EQ(3, filter_call_count);
 }
 
+TEST(MapTest, LazySourceCanOutliveFunctionalMap)
+{
+    lazy_map<std::string, int> lazy_persons;
+    {
+        const map<std::string, int> persons({{"jake", 32}, {"mary", 26}, {"david", 40}});
+        lazy_persons = persons
+            .lazy()
+            .filter([](const std::pair<const std::string, int>& element) {
+                return element.second >= 32;
+            });
+    }
+
+    EXPECT_EQ((map<std::string, int>({{"david", 40}, {"jake", 32}})), lazy_persons.get());
+}
+
+TEST(MapTest, LazySourceCanStartFromTemporaryFunctionalMap)
+{
+    const auto lazy_persons = map<std::string, int>({{"jake", 32}, {"mary", 26}})
+        .lazy()
+        .map_to<char, int>([](const std::pair<const std::string, int>& element) {
+            return std::make_pair(element.first[0], element.second);
+        });
+
+    EXPECT_EQ((map<char, int>({{'j', 32}, {'m', 26}})), lazy_persons.get());
+}
+
 TEST(MapTest, LazyMapToDuplicateKeysKeepsFirst)
 {
     const map<std::string, int> persons({{"anna", 28}, {"alex", 30}, {"david", 40}});

tests/set_test.cc

@@ -719,6 +719,66 @@ TEST(SetTest, LazyZipWithStdVector)
     EXPECT_EQ(expected, zipped);
 }
 
+TEST(SetTest, LazySourceCanOutliveFunctionalSet)
+{
+    lazy_set<int> lazy_numbers;
+    {
+        const set<int> numbers({1, 2, 3, 4});
+        lazy_numbers = numbers
+            .lazy()
+            .filter([](const int& value) {
+                return value > 2;
+            });
+    }
+
+    EXPECT_EQ(set<int>({3, 4}), lazy_numbers.get());
+}
+
+TEST(SetTest, LazySourceCanStartFromTemporaryFunctionalSet)
+{
+    const auto lazy_numbers = set<int>({1, 2, 3, 4})
+        .lazy()
+        .map<int>([](const int& value) {
+            return value * 2;
+        });
+
+    EXPECT_EQ(set<int>({2, 4, 6, 8}), lazy_numbers.get());
+}
+
+TEST(SetTest, LazyZipWithTemporaryFunctionalSet)
+{
+    const set<int> ages({25, 45, 30, 63});
+
+    const auto lazy_zipped = ages
+        .lazy()
+        .zip(set<std::string>({"Jake", "Bob", "Michael", "Philipp"}));
+
+    const auto expected = set<std::pair<int, std::string>>({
+        std::pair<int, std::string>(25, "Bob"),
+        std::pair<int, std::string>(30, "Jake"),
+        std::pair<int, std::string>(45, "Michael"),
+        std::pair<int, std::string>(63, "Philipp"),
+    });
+    EXPECT_EQ(expected, lazy_zipped.get());
+}
+
+TEST(SetTest, LazyZipWithTemporaryStdSet)
+{
+    const set<int> ages({25, 45, 30, 63});
+
+    const auto lazy_zipped = ages
+        .lazy()
+        .zip(std::set<std::string>({"Jake", "Bob", "Michael", "Philipp"}));
+
+    const auto expected = set<std::pair<int, std::string>>({
+        std::pair<int, std::string>(25, "Bob"),
+        std::pair<int, std::string>(30, "Jake"),
+        std::pair<int, std::string>(45, "Michael"),
+        std::pair<int, std::string>(63, "Philipp"),
+    });
+    EXPECT_EQ(expected, lazy_zipped.get());
+}
+
 TEST(SetTest, LazyZipWithLazyVector)
 {
     const set<int> ages({25, 45, 30, 63});
@@ -849,6 +909,17 @@ TEST(SetTest, LazyDifferenceWithLazySet)
     EXPECT_EQ(6, map_call_count);
 }
 
+TEST(SetTest, LazyDifferenceWithTemporaryFunctionalSet)
+{
+    const set<int> set1({1, 2, 3, 5, 7, 8, 10});
+
+    const auto lazy_diff = set1
+        .lazy()
+        .difference_with(set<int>({2, 5, 7, 10, 15, 17}));
+
+    EXPECT_EQ(set<int>({1, 3, 8}), lazy_diff.get());
+}
+
 TEST(SetTest, LazyUnionWithFunctionalSet)
 {
     const set<int> set1({1, 2, 3, 5, 7, 8, 10});
@@ -909,6 +980,17 @@ TEST(SetTest, LazyUnionWithLazySet)
     EXPECT_EQ(6, map_call_count);
 }
 
+TEST(SetTest, LazyUnionWithTemporaryFunctionalSet)
+{
+    const set<int> set1({1, 2, 3, 5, 7, 8, 10});
+
+    const auto lazy_combined = set1
+        .lazy()
+        .union_with(set<int>({2, 5, 7, 10, 15, 17}));
+
+    EXPECT_EQ(set<int>({1, 2, 3, 5, 7, 8, 10, 15, 17}), lazy_combined.get());
+}
+
 TEST(SetTest, LazyIntersectionWithFunctionalSet)
 {
     const set<int> set1({1, 2, 3, 5, 7, 8, 10});
@@ -968,3 +1050,14 @@ TEST(SetTest, LazyIntersectionWithLazySet)
     EXPECT_EQ(set<int>({3, 5, 7, 10}), intersection);
     EXPECT_EQ(6, map_call_count);
 }
+
+TEST(SetTest, LazyIntersectionWithTemporaryFunctionalSet)
+{
+    const set<int> set1({1, 2, 3, 5, 7, 8, 10});
+
+    const auto lazy_intersection = set1
+        .lazy()
+        .intersect_with(set<int>({2, 5, 7, 10, 15, 17}));
+
+    EXPECT_EQ(set<int>({2, 5, 7, 10}), lazy_intersection.get());
+}