Converted '*' into the Cartesian product operator.

Author: Mandrenkov

src/h/list.h

@@ -47,21 +47,29 @@ namespace ctgl {
         template <typename... Ts>
         constexpr bool operator==(List<Ts...>, List<Ts...>) noexcept;
 
-        // Adds an element to the front of a List.
+        // Prepends the given element to the provided List.
         template <typename T, typename... Ts>
         constexpr auto operator+(T, List<Ts...>) noexcept;
 
-        // Adds an element to the back of a List.
+        // Appends the given element to the provided List.
         template <typename... Ts, typename T>
         constexpr auto operator+(List<Ts...>, T) noexcept;
 
         // Concatenates two Lists together.
         template <typename... Ts, typename... Us>
         constexpr auto operator+(List<Ts...>, List<Us...>) noexcept;
 
-        // Adds the given element to each List in the provided List of Lists.
+        // Prepends the given element to each List in the provided List of Lists.
         template <typename T, typename... Ts>
         constexpr auto operator*(T, List<Ts...>) noexcept;
+
+        // Appends the given element to each List in the provided List of Lists.
+        template <typename... Ts, typename T>
+        constexpr auto operator*(List<Ts...>, T) noexcept;
+
+        // Takes the Cartesian product of the given Lists of Lists.
+        template <typename... Ts, typename... Us>
+        constexpr auto operator*(List<Ts...>, List<Us...>) noexcept;
     }
 
     // -------------------------------------------------------------------------
@@ -173,15 +181,37 @@ namespace ctgl {
             return List<Ts..., Us...>{};
         }
 
-        template <typename T>
-        constexpr auto operator*(T, List<>) noexcept {
+        template <typename T, typename... Ts>
+        constexpr auto operator*(T, List<Ts...>) noexcept {
+            return List<List<T>>{} * List<Ts...>{};
+        }
+
+        template <typename... Ts, typename T>
+        constexpr auto operator*(List<Ts...>, T) noexcept {
+            return List<Ts...>{} * List<List<T>>{};
+        }
+
+        template <typename... T>
+        constexpr auto distribute(List<T...>, List<>) noexcept {
             return List<>{};
         }
 
-        template <typename T, typename... Us, typename... Ts>
-        constexpr auto operator*(T, List<List<Us...>, Ts...>) noexcept {
-            constexpr auto head = List<List<T, Us...>>{};
-            constexpr auto tail = T{} * List<Ts...>{};
+        template <typename... T, typename... U, typename... Us>
+        constexpr auto distribute(List<T...>, List<List<U...>, Us...>) noexcept {
+            constexpr auto head = List<List<T..., U...>>{};
+            constexpr auto tail = distribute(List<T...>{}, List<Us...>{});
+            return head + tail;
+        }
+
+        template <typename... Us>
+        constexpr auto operator*(List<>, List<Us...>) noexcept {
+            return List<>{};
+        }
+        
+        template <typename... T, typename... Ts, typename... Us>
+        constexpr auto operator*(List<List<T...>, Ts...>, List<Us...>) noexcept {
+            constexpr auto head = distribute(List<T...>{}, List<Us...>{});
+            constexpr auto tail = List<Ts...>{} * List<Us...>{};
             return head + tail;
         }
 

src/test/list_test.cpp

@@ -135,14 +135,23 @@ TEST(ListTest, Plus) {
 TEST(ListTest, Star) {
     // Empty
     EXPECT_EQ(int{} * List<>{}, List<>{});
+    EXPECT_EQ(List<>{} * int{}, List<>{});
+    EXPECT_EQ(List<>{} * List<>{}, List<>{});
 
     // Single
-    EXPECT_EQ(int{} * List<List<int>>{}, (List<List<int, int>>{}));
     EXPECT_EQ(int{} * List<List<bool>>{}, (List<List<int, bool>>{}));
+    EXPECT_EQ(List<List<bool>>{} * int{}, (List<List<bool, int>>{}));
+    EXPECT_EQ(List<List<int>>{} * List<List<bool>>{}, (List<List<int, bool>>{}));
 
     // Multiple
     EXPECT_EQ(int{} * (List<List<float, double>>{}), (List<List<int, float, double>>{}));
     EXPECT_EQ(int{} * (List<List<bool>, List<long>>{}), (List<List<int, bool>, List<int, long>>{}));
+    EXPECT_EQ((List<List<float, double>>{}) * int{}, (List<List<float, double, int>>{}));
+    EXPECT_EQ((List<List<bool>, List<long>>{}) * int{}, (List<List<bool, int>, List<long, int>>{}));
+    EXPECT_EQ((List<List<bool>, List<long>>{}) * (List<List<int>, List<char>>{}), (List<List<bool, int>,
+                                                                                        List<bool, char>,
+                                                                                        List<long, int>,
+                                                                                        List<long, char>>{}));
 }
 
 // Unit tests for the ctgl::list::<< operator.