Functional reduce algorithm implemented

Author: Ioannis Kaliakatsos

include/set.h

@@ -289,7 +289,36 @@ class set
                             end(),
                             std::forward<Callable>(unary_predicate));
     }
-    
+
+    // Performs the functional `reduce` (fold/accumulate) algorithm, by returning the result of
+    // accumulating all the values in the vector to an initial value. (non-mutating)
+    //
+    // example:
+    //      const fcpp::set<std::string> tokens({ "the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "brown", "dog" });
+    //      const auto sentence = tokens.reduce<std::string>("", [](const std::string& partial, const std::string& token) {
+    //          return partial.length() != 0
+    //              ? partial + " " + token
+    //              : token;
+    //      });
+    //
+    // outcome: (a set does not allow multiple entries, and its elements are internally managed, order can vary)
+    //      
+    //      sentence -> std::string("brown dog fox jumps lazy over quick the");
+#ifdef CPP17_AVAILABLE
+    template <typename U, typename Reduce, typename = std::enable_if_t<std::is_invocable_r_v<U, Reduce, U, TKey>>>
+#else
+    template <typename U, typename Reduce>
+#endif
+    U reduce(const U& initial, Reduce&& reduction) const
+    {
+        auto result = initial;
+        for (const auto& x : m_set)
+        {
+            result = reduction(result, x);
+        }
+        return result;
+    }
+
     // Performs the functional `filter` algorithm, in which all keys of this instance
     // which match the given predicate are kept (mutating)
     //

include/vector.h

@@ -244,7 +244,35 @@ class vector
                             std::forward<Callable>(unary_predicate));
     }
 #endif
-    
+
+    // Performs the functional `reduce` (fold/accumulate) algorithm, by returning the result of
+    // accumulating all the values in the vector to an initial value. (non-mutating)
+    //
+    // example:
+    //      const fcpp::vector<std::string> tokens({ "the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "brown", "dog" });
+    //      const auto sentence = tokens.reduce<std::string>("", [](const std::string& partial, const std::string& token) {
+    //          return partial.length() != 0
+    //              ? partial + " " + token
+    //              : token;
+    //      });
+    //
+    // outcome:
+    //      sentence -> std::string("the quick brown fox jumps over the lazy brown dog");
+#ifdef CPP17_AVAILABLE
+    template <typename U, typename Reduce, typename = std::enable_if_t<std::is_invocable_r_v<U, Reduce, U, T>>>
+#else
+    template <typename U, typename Reduce>
+#endif
+    U reduce(const U& initial, Reduce&& reduction) const
+    {
+        auto result = initial;
+        for(const auto &x: m_vector)
+        {
+            result = reduction(result, x);
+        }
+        return result;
+    }
+
     // Performs the functional `filter` algorithm, in which all elements of this instance
     // which match the given predicate are kept (mutating)
     //

tests/set_test.cc

@@ -333,6 +333,17 @@ TEST(SetTest, NoneOf)
     EXPECT_FALSE(numbers.none_of([](const int &number) { return number < 6; }));
 }
 
+TEST(SetTest, Reduce)
+{
+    const set<std::string> tokens({ "the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "brown", "dog" });
+    const auto sentence = tokens.reduce(std::string(""), [](const std::string& partial, const std::string& token) {
+        return partial.length() != 0
+    		? partial + " " + token
+    		: token;
+    });
+    EXPECT_EQ("brown dog fox jumps lazy over quick the", sentence);
+}
+
 TEST(SetTest, Filter)
 {
     set<int> numbers({ 1, 3, -5, 2, -1, 9, -4 });

tests/vector_test.cc

@@ -258,6 +258,26 @@ TEST(VectorTest, FilteredParallel)
 }
 #endif
 
+TEST(VectorTest, Reduce)
+{
+	const vector<child> vector_under_test({ child(1), child(3), child(4) });
+	const auto age_sum = vector_under_test.reduce(0, [](const int& partial_sum, const child& child){
+    	return partial_sum + child.age;
+    });
+    EXPECT_EQ(8, age_sum);
+}
+
+TEST(VectorTest, ReduceString)
+{
+    const vector<std::string> tokens({ "the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "brown", "dog"});
+	const auto sentence = tokens.reduce(std::string(""), [](const std::string& partial, const std::string& token) {
+    	return partial.length() != 0
+			? partial + " " + token
+			: token;
+    });
+    EXPECT_EQ("the quick brown fox jumps over the lazy brown dog", sentence);
+}
+
 TEST(VectorTest, Reverse)
 {
     vector<child> vector_under_test({child(6), child(2), child(9)});