refactor(python/containers): refactor containers

feat(concepts): add TransformFunction concept
test(concepts): add related tests

Author: hakula139

binding/containers_binding.cpp

@@ -21,6 +21,7 @@
 namespace py = pybind11;
 using namespace cpp_features::containers;
 using cpp_features::concepts::CopyableType;
+using cpp_features::concepts::TransformFunction;
 
 namespace {
 
@@ -32,6 +33,12 @@ auto GetItem(const Container<T> &self, typename Container<T>::size_type index) -
   throw py::index_error("Index out of bounds");
 }
 
+template <typename Input, typename Output>
+auto GetTransformWrapper(const Container<Input> &self,
+                         const std::function<Output(Input)> &transform) {
+  return self.template GetTransformedView<Output>(transform);
+}
+
 template <CopyableType T>
 auto GetIter(const Container<T> &self) {
   return py::make_iterator(self.begin(), self.end());
@@ -69,7 +76,9 @@ void BindContainers(py::module &m) {
       .def("at", &GetItem<int>)
       .def("view", &IntContainer::GetView)
       .def("filter", &IntContainer::GetFilteredView<std::function<bool(int)>>)
-      .def("transform", &IntContainer::GetTransformedView<std::function<int(int)>>)
+      .def("transform", &GetTransformWrapper<int, int>)
+      .def("transform", &GetTransformWrapper<int, double>)
+      .def("transform", &GetTransformWrapper<int, std::string>)
       .def("__len__", &IntContainer::GetSize)
       .def("__bool__", [](const IntContainer &self) { return !self.IsEmpty(); })
       .def("__getitem__", &GetItem<int>)
@@ -90,7 +99,9 @@ void BindContainers(py::module &m) {
       .def("at", &GetItem<double>)
       .def("view", &FloatContainer::GetView)
       .def("filter", &FloatContainer::GetFilteredView<std::function<bool(double)>>)
-      .def("transform", &FloatContainer::GetTransformedView<std::function<double(double)>>)
+      .def("transform", &GetTransformWrapper<double, int>)
+      .def("transform", &GetTransformWrapper<double, double>)
+      .def("transform", &GetTransformWrapper<double, std::string>)
       .def("__len__", &FloatContainer::GetSize)
       .def("__bool__", [](const FloatContainer &self) { return !self.IsEmpty(); })
       .def("__getitem__", &GetItem<double>)
@@ -111,8 +122,9 @@ void BindContainers(py::module &m) {
       .def("at", &GetItem<std::string>)
       .def("view", &StringContainer::GetView)
       .def("filter", &StringContainer::GetFilteredView<std::function<bool(const std::string &)>>)
-      .def("transform",
-           &StringContainer::GetTransformedView<std::function<std::string(const std::string &)>>)
+      .def("transform", &GetTransformWrapper<std::string, int>)
+      .def("transform", &GetTransformWrapper<std::string, double>)
+      .def("transform", &GetTransformWrapper<std::string, std::string>)
       .def("__len__", &StringContainer::GetSize)
       .def("__bool__", [](const StringContainer &self) { return !self.IsEmpty(); })
       .def("__getitem__", &GetItem<std::string>)

include/concepts/callable_concepts.hpp

@@ -93,6 +93,30 @@ template <typename Func>
 concept TimerCallback = std::invocable<Func, std::int64_t> &&
                         std::same_as<std::invoke_result_t<Func, std::int64_t>, void>;
 
+/**
+ * @brief Concept for transformation functions that can be used with container transformations
+ *
+ * @tparam Func The type of the transformation function
+ * @tparam Input The type of the input elements
+ * @tparam Output The type of the output elements
+ *
+ * This concept ensures that a type can be used as a transformation function for container
+ * operations. The function must be invocable with an Input type and return an Output type.
+ *
+ * @code
+ * template <TransformFunction<int, int> Func>
+ * auto transform_elements(const std::vector<int> &vec, Func func) {
+ *   return vec | std::views::transform(func);
+ * }
+ *
+ * auto square = [](int n) { return n * n; };
+ * auto squared_numbers = transform_elements(numbers, square);
+ * @endcode
+ */
+template <typename Func, typename Input, typename Output = Input>
+concept TransformFunction =
+    std::invocable<Func, Input> && std::convertible_to<std::invoke_result_t<Func, Input>, Output>;
+
 /**
  * @brief Concept for predicate functions that can be used with container filtering
  *
@@ -101,13 +125,11 @@ concept TimerCallback = std::invocable<Func, std::int64_t> &&
  *
  * This concept ensures that a type can be used as a predicate for filtering operations.
  * The predicate must be invocable with a const reference to T and return a type that
- * is convertible to bool. This allows for flexible usage with lambdas, function pointers,
- * functors, and other callable objects.
+ * is convertible to bool.
  *
  * @code
  * template <typename T, PredicateFor<T> Predicate>
  * auto filter_elements(const std::vector<T> &vec, Predicate predicate) {
- *   // Use predicate to filter elements
  *   return vec | std::views::filter(predicate);
  * }
  *
@@ -116,7 +138,6 @@ concept TimerCallback = std::invocable<Func, std::int64_t> &&
  * @endcode
  */
 template <typename Predicate, typename T>
-concept PredicateFor = std::invocable<Predicate, const T &> &&
-                       std::convertible_to<std::invoke_result_t<Predicate, const T &>, bool>;
+concept PredicateFor = TransformFunction<Predicate, const T &, bool>;
 
 }  // namespace cpp_features::concepts

include/containers/container.hpp

@@ -276,8 +276,9 @@ class Container {
   /**
    * @brief Get a transformed view of elements
    *
-   * @tparam Func Type of the transformation function
-   * @param transform_func Function to apply to each element
+   * @tparam U The type of the output elements
+   * @tparam Func The type of the transformation function. Must satisfy TransformFunction<T, U>
+   * @param transform_func The function to apply to each element
    * @return A ranges view containing transformed elements
    *
    * Returns a lazy-evaluated view where each element is transformed by the provided function.
@@ -286,7 +287,7 @@ class Container {
    * auto doubled = container.GetTransformedView([](int n) { return n * 2; });
    * @endcode
    */
-  template <typename Func>
+  template <typename U = T, cpp_features::concepts::TransformFunction<T, U> Func>
   [[nodiscard]] auto GetTransformedView(Func transform_func) const {
     return data_ | std::views::transform(transform_func);
   }