tp_names for STL converters

Author: parcollet

src/c2py/converters/stl/any.hpp

@@ -7,6 +7,8 @@ namespace c2py {
 
   template <> struct py_converter<std::any> {
 
+    static constexpr const char *tp_name = "capsule";
+
     static void capsule_destructor(PyObject *capsule) {
       void *p = PyCapsule_GetPointer(capsule, "std::any");
       assert(p);

src/c2py/converters/stl/array.hpp

@@ -24,6 +24,12 @@ namespace c2py {
 
   template <typename T, size_t R> struct py_converter<std::array<T, R>> {
 
+    static std::string tp_name() {
+      std::ostringstream out;
+      out << "[" << python_typename<T>() << ", len = " << R << "]";
+      return out.str();
+    }
+
     static PyObject *c2py(std::array<T, R> const &v) {
       PyObject *list = PyList_New(0);
       for (auto const &x : v) {

src/c2py/converters/stl/function.hpp

@@ -17,7 +17,9 @@ namespace c2py {
 
     // a dispatcher for this std::function
     template <typename R, typename... T>
-    static const auto std_function_call = dispatcher_f_kw_t{cfun(&std::function<R(T...)>::operator(), empty_string<T>...)};
+    static const auto std_function_call = dispatcher_f_kw_t {
+      cfun(&std::function<R(T...)>::operator(), empty_string<T>...)
+    };
 
   } // namespace detail
 
@@ -35,6 +37,15 @@ namespace c2py {
     static_assert(concepts::IsConvertibleC2Py<R>, "Return type not convertible");
     static_assert((concepts::IsConvertiblePy2C<T> and ... and true), "Parameter not convertible");
 
+    static std::string tp_name() {
+      std::ostringstream out;
+      std::string sep;
+      out << "(";
+      ((out << sep << python_typename<T>(), sep = ", "), ...);
+      out << ") -> " << python_typename<R>();
+      return out.str();
+    }
+
     using c_t  = std::function<R(T...)>;
     using py_t = wrap<c_t>;
 

src/c2py/converters/stl/map.hpp

@@ -27,6 +27,13 @@ namespace c2py {
 
   template <typename K, typename V> struct py_converter<std::map<K, V>> {
 
+    static std::string tp_name() {
+      std::ostringstream out;
+      std::string sep;
+      out << "dict[" << python_typename<K>() << " -> " << python_typename<V>() << "]";
+      return out.str();
+    }
+
     template <typename M>
     static PyObject *c2py(M &&m)
       requires(concepts::IsConvertibleC2Py<V>)

src/c2py/converters/stl/optional.hpp

@@ -24,6 +24,12 @@ namespace c2py {
 
   template <typename T> struct py_converter<std::optional<T>> {
 
+    static std::string tp_name() {
+      std::ostringstream out;
+      out << python_typename<T>() << " | None";
+      return out.str();
+    }
+
     using conv = py_converter<std::decay_t<T>>;
 
     template <typename O> static PyObject *c2py(O &&op) {

src/c2py/converters/stl/set.hpp

@@ -24,6 +24,13 @@ namespace c2py {
 
   template <typename K> struct py_converter<std::set<K>> {
 
+    static std::string tp_name() {
+      std::ostringstream out;
+      std::string sep;
+      out << "set[" << python_typename<K>() << "]";
+      return out.str();
+    }
+
     template <typename S> static PyObject *c2py(S &&s) {
       static_assert(is_instantiation_of_v<std::set, std::decay_t<S>>, "Logic error");
       PyObject *set = PySet_New(nullptr);

src/c2py/converters/stl/span.hpp

@@ -23,6 +23,9 @@
 namespace c2py {
 
   template <> struct py_converter<std::span<std::byte>> {
+
+    static constexpr const char *tp_name = "[bytes]";
+
     // --------------------------------------
 
     static bool is_convertible(PyObject *ob, bool raise_exception) {

src/c2py/converters/stl/variant.hpp

@@ -27,6 +27,13 @@ namespace c2py {
   // converts in the first possible type
   template <typename... T> struct py_converter<std::variant<T...>> {
 
+    static std::string tp_name() {
+      std::ostringstream out;
+      std::string sep;
+      ((out << sep << python_typename<T>(), sep = " | "), ...);
+      return out.str();
+    }
+
     private:
     template <int N> using types_t = std::tuple_element_t<N, std::tuple<T...>>;
 

src/c2py/converters/stl/vector.hpp

@@ -68,6 +68,8 @@ namespace c2py {
 
   template <> struct py_converter<std::vector<std::byte>> {
 
+    static constexpr const char *tp_name = "[bytes]";
+
     static PyObject *c2py(std::vector<std::byte> const &v) {
       auto *char_ptr = reinterpret_cast<const char *>(v.data()); // NOLINT
       return PyBytes_FromStringAndSize(char_ptr, Py_ssize_t(v.size()));