diff --git a/src/binding/julia/Attributable.cpp b/src/binding/julia/Attributable.cpp
index 5ae68f764d..3762f20880 100644
--- a/src/binding/julia/Attributable.cpp
+++ b/src/binding/julia/Attributable.cpp
@@ -6,15 +6,26 @@
 
 #include "defs.hpp"
 
+namespace
+{
+struct UseType
+{
+    template <typename T>
+    static void call(jlcxx::TypeWrapper<Attributable> type)
+    {
+        type.method(
+            "cxx_set_attribute_" + datatypeToString(determineDatatype<T>()) +
+                "!",
+            &Attributable::setAttribute<T>);
+    }
+};
+} // namespace
+
 void define_julia_Attributable(jlcxx::Module &mod)
 {
     auto type = mod.add_type<Attributable>("CXX_Attributable");
 
-#define USE_TYPE(NAME, ENUM, TYPE)                                             \
-    type.method(                                                               \
-        "cxx_set_attribute_" NAME "!", &Attributable::setAttribute<TYPE>);
-    {FORALL_OPENPMD_TYPES(USE_TYPE)}
-#undef USE_TYPE
+    forallJuliaTypes<UseType>(type);
 
     type.method("cxx_get_attribute", &Attributable::getAttribute);
     type.method("cxx_delete_attribute!", &Attributable::deleteAttribute);
diff --git a/src/binding/julia/Attribute.cpp b/src/binding/julia/Attribute.cpp
index cacda12faf..6e13b6efe2 100644
--- a/src/binding/julia/Attribute.cpp
+++ b/src/binding/julia/Attribute.cpp
@@ -6,16 +6,25 @@
 
 #include "defs.hpp"
 
+namespace
+{
+struct UseType
+{
+    template <typename T>
+    static void call(jlcxx::TypeWrapper<Attribute> type)
+    {
+        type.method(
+            "cxx_get_" + datatypeToString(determineDatatype<T>()),
+            &Attribute::get<T>);
+    }
+};
+} // namespace
+
 void define_julia_Attribute(jlcxx::Module &mod)
 {
     auto type = mod.add_type<Attribute>("CXX_Attribute");
 
     type.method("cxx_dtype", [](const Attribute &attr) { return attr.dtype; });
 
-#define USE_TYPE(NAME, ENUM, TYPE)                                             \
-    type.method("cxx_get_" NAME, &Attribute::get<TYPE>);
-    {
-        FORALL_OPENPMD_TYPES(USE_TYPE)
-    }
-#undef USE_TYPE
+    forallJuliaTypes<UseType>(type);
 }
diff --git a/src/binding/julia/BaseRecordComponent.cpp b/src/binding/julia/BaseRecordComponent.cpp
index e2ddda708e..4ffd41a277 100644
--- a/src/binding/julia/BaseRecordComponent.cpp
+++ b/src/binding/julia/BaseRecordComponent.cpp
@@ -12,7 +12,7 @@ namespace jlcxx
 template <>
 struct SuperType<BaseRecordComponent>
 {
-    typedef Attributable type;
+    using type = Attributable;
 };
 } // namespace jlcxx
 
diff --git a/src/binding/julia/ChunkInfo.cpp b/src/binding/julia/ChunkInfo.cpp
index 322fb996b0..2b396652c7 100644
--- a/src/binding/julia/ChunkInfo.cpp
+++ b/src/binding/julia/ChunkInfo.cpp
@@ -12,7 +12,7 @@ namespace jlcxx
 template <>
 struct SuperType<WrittenChunkInfo>
 {
-    typedef ChunkInfo type;
+    using type = ChunkInfo;
 };
 } // namespace jlcxx
 
diff --git a/src/binding/julia/Container.hpp b/src/binding/julia/Container.hpp
index ba973bafc0..70db8749b4 100644
--- a/src/binding/julia/Container.hpp
+++ b/src/binding/julia/Container.hpp
@@ -20,14 +20,13 @@ namespace jlcxx
 template <typename T, typename K>
 struct SuperType<Container<T, K>>
 {
-    typedef Attributable type;
+    using type = Attributable;
 };
 } // namespace jlcxx
 
+using julia_Container_type_t =
+    jlcxx::TypeWrapper<jlcxx::Parametric<jlcxx::TypeVar<1>, jlcxx::TypeVar<2>>>;
 // TODO: use std::optional instead of std::unique_ptr
-typedef jlcxx::TypeWrapper<
-    jlcxx::Parametric<jlcxx::TypeVar<1>, jlcxx::TypeVar<2>>>
-    julia_Container_type_t;
 extern std::unique_ptr<julia_Container_type_t> julia_Container_type;
 
 template <typename Eltype, typename Keytype>
@@ -43,7 +42,6 @@ void define_julia_Container(jlcxx::Module &mod)
         using ContainerT = typename decltype(type)::type;
         using key_type = typename ContainerT::key_type;
         using mapped_type = typename ContainerT::mapped_type;
-        using size_type = typename ContainerT::size_type;
         static_assert(std::is_same_v<Eltype, mapped_type>);
         static_assert(std::is_same_v<Keytype, key_type>);
 
@@ -69,9 +67,7 @@ void define_julia_Container(jlcxx::Module &mod)
         type.method("cxx_count", &ContainerT::count);
         type.method("cxx_contains", &ContainerT::contains);
         type.method(
-            "cxx_delete!",
-            static_cast<size_type (ContainerT::*)(const key_type &)>(
-                &ContainerT::erase));
+            "cxx_delete!", overload_cast<const key_type &>(&ContainerT::erase));
         type.method("cxx_keys", [](const ContainerT &cont) {
             std::vector<key_type> res;
             res.reserve(cont.size());
diff --git a/src/binding/julia/Datatype.cpp b/src/binding/julia/Datatype.cpp
index ce3fe6212f..47dcc21442 100644
--- a/src/binding/julia/Datatype.cpp
+++ b/src/binding/julia/Datatype.cpp
@@ -6,14 +6,26 @@
 
 #include "defs.hpp"
 
+namespace
+{
+struct UseType
+{
+    template <typename T>
+    static void call(jlcxx::Module &mod)
+    {
+        Datatype const dt = determineDatatype<T>();
+        mod.set_const(datatypeToString(dt), dt);
+    }
+};
+} // namespace
+
 void define_julia_Datatype(jlcxx::Module &mod)
 {
     mod.add_bits<Datatype>("Datatype", jlcxx::julia_type("CppEnum"));
     jlcxx::stl::apply_stl<Datatype>(mod);
 
-#define USE_TYPE(NAME, ENUM, TYPE) mod.set_const(NAME, ENUM);
-    {FORALL_OPENPMD_TYPES(USE_TYPE)}
-#undef USE_TYPE
+    forallJuliaTypes<UseType>(mod);
+
     mod.set_const("UNDEFINED", Datatype::UNDEFINED);
 
     mod.set_const("openPMD_datatypes", openPMD_Datatypes);
diff --git a/src/binding/julia/Iteration.cpp b/src/binding/julia/Iteration.cpp
index 952931d41d..28a8d858c3 100644
--- a/src/binding/julia/Iteration.cpp
+++ b/src/binding/julia/Iteration.cpp
@@ -14,7 +14,7 @@ namespace jlcxx
 template <>
 struct SuperType<Iteration>
 {
-    typedef Attributable type;
+    using type = Attributable;
 };
 } // namespace jlcxx
 
@@ -29,9 +29,7 @@ void define_julia_Iteration(jlcxx::Module &mod)
     type.method("cxx_set_dt!", &Iteration::setDt<double>);
     type.method("cxx_time_unit_SI", &Iteration::timeUnitSI);
     type.method("cxx_set_time_unit_SI!", &Iteration::setTimeUnitSI);
-    type.method(
-        "cxx_close",
-        static_cast<Iteration &(Iteration::*)(bool)>(&Iteration::close));
+    type.method("cxx_close", overload_cast<bool>(&Iteration::close));
     type.method("cxx_open", &Iteration::open);
     type.method("cxx_closed", &Iteration::closed);
     type.method("cxx_meshes", [](Iteration &iter) -> Container<Mesh> & {
diff --git a/src/binding/julia/Mesh.cpp b/src/binding/julia/Mesh.cpp
index f196b761e4..7fac56776b 100644
--- a/src/binding/julia/Mesh.cpp
+++ b/src/binding/julia/Mesh.cpp
@@ -12,7 +12,7 @@ namespace jlcxx
 template <>
 struct SuperType<Mesh>
 {
-    typedef Container<MeshRecordComponent> type;
+    using type = Container<MeshRecordComponent>;
 };
 } // namespace jlcxx
 
@@ -50,8 +50,7 @@ void define_julia_Mesh(jlcxx::Module &mod)
 
     type.method("cxx_geometry", &Mesh::geometry);
     type.method(
-        "cxx_set_geometry!",
-        static_cast<Mesh &(Mesh::*)(Mesh::Geometry g)>(&Mesh::setGeometry));
+        "cxx_set_geometry!", overload_cast<Mesh::Geometry>(&Mesh::setGeometry));
     type.method("cxx_geometry_parameters", &Mesh::geometryParameters);
     type.method("cxx_set_geometry_parameters!", &Mesh::setGeometryParameters);
     type.method("cxx_data_order", &Mesh::dataOrder);
diff --git a/src/binding/julia/MeshRecordComponent.cpp b/src/binding/julia/MeshRecordComponent.cpp
index 5b000760d6..965af8e269 100644
--- a/src/binding/julia/MeshRecordComponent.cpp
+++ b/src/binding/julia/MeshRecordComponent.cpp
@@ -12,10 +12,24 @@ namespace jlcxx
 template <>
 struct SuperType<MeshRecordComponent>
 {
-    typedef RecordComponent type;
+    using type = RecordComponent;
 };
 } // namespace jlcxx
 
+namespace
+{
+struct UseType
+{
+    template <typename T>
+    static void call(jlcxx::TypeWrapper<MeshRecordComponent> type)
+    {
+        type.method(
+            "cxx_make_constant_" + datatypeToString(determineDatatype<T>()),
+            &MeshRecordComponent::makeConstant<T>);
+    }
+};
+} // namespace
+
 void define_julia_MeshRecordComponent(jlcxx::Module &mod)
 {
     auto type = mod.add_type<MeshRecordComponent>(
@@ -23,11 +37,5 @@ void define_julia_MeshRecordComponent(jlcxx::Module &mod)
 
     type.method("cxx_position", &MeshRecordComponent::position<double>);
     type.method("cxx_set_position!", &MeshRecordComponent::setPosition<double>);
-#define USE_TYPE(NAME, ENUM, TYPE)                                             \
-    type.method(                                                               \
-        "cxx_make_constant_" NAME, &MeshRecordComponent::makeConstant<TYPE>);
-    {
-        FORALL_OPENPMD_TYPES(USE_TYPE)
-    }
-#undef USE_TYPE
+    forallJuliaTypes<UseType>(type);
 }
diff --git a/src/binding/julia/RecordComponent.cpp b/src/binding/julia/RecordComponent.cpp
index a938e1515f..f67fcd5bf0 100644
--- a/src/binding/julia/RecordComponent.cpp
+++ b/src/binding/julia/RecordComponent.cpp
@@ -17,7 +17,7 @@ namespace jlcxx
 template <>
 struct SuperType<RecordComponent>
 {
-    typedef BaseRecordComponent type;
+    using type = BaseRecordComponent;
 };
 } // namespace jlcxx
 
diff --git a/src/binding/julia/RecordComponent_load_chunk.cpp b/src/binding/julia/RecordComponent_load_chunk.cpp
index 12d0c8876e..2c057740c6 100644
--- a/src/binding/julia/RecordComponent_load_chunk.cpp
+++ b/src/binding/julia/RecordComponent_load_chunk.cpp
@@ -6,17 +6,23 @@
 
 #include "defs.hpp"
 
-void define_julia_RecordComponent_load_chunk(
-    jlcxx::Module & /*mod*/, jlcxx::TypeWrapper<RecordComponent> &type)
+namespace
 {
-#define USE_TYPE(NAME, ENUM, TYPE)                                             \
-    type.method(                                                               \
-        "cxx_load_chunk_" NAME,                                                \
-        static_cast<void (RecordComponent::*)(                                 \
-            std::shared_ptr<TYPE>, Offset, Extent)>(                           \
-            &RecordComponent::loadChunk<TYPE>));
+struct UseType
+{
+    template <typename T>
+    static void call(jlcxx::TypeWrapper<RecordComponent> &type)
     {
-        FORALL_SCALAR_OPENPMD_TYPES(USE_TYPE)
+        type.method(
+            "cxx_load_" + datatypeToString(determineDatatype<T>()),
+            overload_cast<std::shared_ptr<T>, Offset, Extent>(
+                &RecordComponent::loadChunk<T>));
     }
-#undef USE_TYPE
+};
+} // namespace
+
+void define_julia_RecordComponent_load_chunk(
+    jlcxx::Module & /*mod*/, jlcxx::TypeWrapper<RecordComponent> &type)
+{
+    forallScalarJuliaTypes<UseType>(type);
 }
diff --git a/src/binding/julia/RecordComponent_make_constant.cpp b/src/binding/julia/RecordComponent_make_constant.cpp
index 68f5384cef..89b9f7f371 100644
--- a/src/binding/julia/RecordComponent_make_constant.cpp
+++ b/src/binding/julia/RecordComponent_make_constant.cpp
@@ -6,14 +6,22 @@
 
 #include "defs.hpp"
 
-void define_julia_RecordComponent_make_constant(
-    jlcxx::Module & /*mod*/, jlcxx::TypeWrapper<RecordComponent> &type)
+namespace
 {
-#define USE_TYPE(NAME, ENUM, TYPE)                                             \
-    type.method(                                                               \
-        "cxx_make_constant_" NAME, &RecordComponent::makeConstant<TYPE>);
+struct UseType
+{
+    template <typename T>
+    static void call(jlcxx::TypeWrapper<RecordComponent> &type)
     {
-        FORALL_SCALAR_OPENPMD_TYPES(USE_TYPE)
+        type.method(
+            "cxx_make_constant_" + datatypeToString(determineDatatype<T>()),
+            &RecordComponent::makeConstant<T>);
     }
-#undef USE_TYPE
+};
+} // namespace
+
+void define_julia_RecordComponent_make_constant(
+    jlcxx::Module & /*mod*/, jlcxx::TypeWrapper<RecordComponent> &type)
+{
+    forallScalarJuliaTypes<UseType>(type);
 }
diff --git a/src/binding/julia/RecordComponent_store_chunk.cpp b/src/binding/julia/RecordComponent_store_chunk.cpp
index 2fc3ecf544..3f46b71499 100644
--- a/src/binding/julia/RecordComponent_store_chunk.cpp
+++ b/src/binding/julia/RecordComponent_store_chunk.cpp
@@ -6,17 +6,23 @@
 
 #include "defs.hpp"
 
-void define_julia_RecordComponent_store_chunk(
-    jlcxx::Module & /*mod*/, jlcxx::TypeWrapper<RecordComponent> &type)
+namespace
 {
-#define USE_TYPE(NAME, ENUM, TYPE)                                             \
-    type.method(                                                               \
-        "cxx_store_chunk_" NAME,                                               \
-        static_cast<void (RecordComponent::*)(                                 \
-            std::shared_ptr<TYPE>, Offset, Extent)>(                           \
-            &RecordComponent::storeChunk<TYPE>));
+struct UseType
+{
+    template <typename T>
+    static void call(jlcxx::TypeWrapper<RecordComponent> &type)
     {
-        FORALL_SCALAR_OPENPMD_TYPES(USE_TYPE)
+        type.method(
+            "cxx_store_chunk_" + datatypeToString(determineDatatype<T>()),
+            overload_cast<std::shared_ptr<T>, Offset, Extent>(
+                &RecordComponent::storeChunk<T>));
     }
-#undef USE_TYPE
+};
+} // namespace
+
+void define_julia_RecordComponent_store_chunk(
+    jlcxx::Module & /*mod*/, jlcxx::TypeWrapper<RecordComponent> &type)
+{
+    forallScalarJuliaTypes<UseType>(type);
 }
diff --git a/src/binding/julia/Series.cpp b/src/binding/julia/Series.cpp
index b6fe058523..6d0524f447 100644
--- a/src/binding/julia/Series.cpp
+++ b/src/binding/julia/Series.cpp
@@ -25,7 +25,7 @@ namespace jlcxx
 template <>
 struct SuperType<Series>
 {
-    typedef Attributable type;
+    using type = Attributable;
 };
 } // namespace jlcxx
 
@@ -45,7 +45,7 @@ void define_julia_Series(jlcxx::Module &mod)
            sized_uint_t<sizeof(MPI_Comm)> ucomm,
            const std::string &options) {
             MPI_Comm comm;
-            static_assert(sizeof ucomm == sizeof comm, "");
+            static_assert(sizeof ucomm == sizeof comm);
             memcpy(&comm, &ucomm, sizeof comm);
             return Series(filepath, at, comm, options);
         });
@@ -55,7 +55,7 @@ void define_julia_Series(jlcxx::Module &mod)
            Access at,
            sized_uint_t<sizeof(MPI_Comm)> ucomm) {
             MPI_Comm comm;
-            static_assert(sizeof ucomm == sizeof comm, "");
+            static_assert(sizeof ucomm == sizeof comm);
             memcpy(&comm, &ucomm, sizeof comm);
             return Series(filepath, at, comm);
         });
@@ -81,8 +81,7 @@ void define_julia_Series(jlcxx::Module &mod)
     type.method("cxx_software", &Series::software);
     type.method(
         "cxx_set_software!",
-        static_cast<Series &(Series::*)(const std::string &,
-                                        const std::string &)>(
+        overload_cast<const std::string &, const std::string &>(
             &Series::setSoftware));
     type.method(
         "cxx_set_software!",
diff --git a/src/binding/julia/WriteIterations.cpp b/src/binding/julia/WriteIterations.cpp
index d4f31c51a2..03da048198 100644
--- a/src/binding/julia/WriteIterations.cpp
+++ b/src/binding/julia/WriteIterations.cpp
@@ -10,8 +10,7 @@
 
 void define_julia_WriteIterations(jlcxx::Module &mod)
 {
-    using iterations_t = Container<Iteration, uint64_t>;
-    using key_type = typename iterations_t::key_type;
+    using key_type = Series::IterationIndex_t;
     // using mapped_type = typename iterations_t::mapped_type;
 
     auto type = mod.add_type<WriteIterations>("WriteIterations");
diff --git a/src/binding/julia/defs.hpp b/src/binding/julia/defs.hpp
index 97bac41ec2..f4d7d0a3c0 100644
--- a/src/binding/julia/defs.hpp
+++ b/src/binding/julia/defs.hpp
@@ -22,6 +22,7 @@
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <sstream>
 #include <string>
 #include <tuple>
 #include <type_traits>
@@ -57,213 +58,141 @@ using sized_uint_t = typename sized_uint<I>::type;
 
 using array_double_7 = std::array<double, 7>;
 
-/*
- * Generate code fo all openPMD types. Use is e.g. as follows:
- *   #define USE_TYPE(NAME, ENUM, TYPE)                    \
- *     type.method("get_" NAME, &Attribute::get<TYPE>);
- *   FORALL_OPENPMD_TYPES(USE_TYPE)
- *   #undef USE_TYPE
- */
+// From pybind11, see
+// share/openPMD/thirdParty/pybind11/include/pybind11/detail/common.h
+// in the source tree
+struct non_const_tag
+{};
+struct const_tag
+{};
 
-// We disable `long double` since Julia does not support this type
-#define FORALL_OPENPMD_TYPES(MACRO)                                            \
-    MACRO("CHAR", Datatype::CHAR, char)                                        \
-    MACRO("UCHAR", Datatype::UCHAR, unsigned char)                             \
-    MACRO("SHORT", Datatype::SHORT, short)                                     \
-    MACRO("INT", Datatype::INT, int)                                           \
-    MACRO("LONG", Datatype::LONG, long)                                        \
-    MACRO("LONGLONG", Datatype::LONGLONG, long long)                           \
-    MACRO("USHORT", Datatype::USHORT, unsigned short)                          \
-    MACRO("UINT", Datatype::UINT, unsigned int)                                \
-    MACRO("ULONG", Datatype::ULONG, unsigned long)                             \
-    MACRO("ULONGLONG", Datatype::ULONGLONG, unsigned long long)                \
-    MACRO("FLOAT", Datatype::FLOAT, float)                                     \
-    MACRO("DOUBLE", Datatype::DOUBLE, double)                                  \
-    /* MACRO("LONG_DOUBLE", Datatype::LONG_DOUBLE, long double) */             \
-    MACRO("CFLOAT", Datatype::CFLOAT, std::complex<float>)                     \
-    MACRO("CDOUBLE", Datatype::CDOUBLE, std::complex<double>)                  \
-    /* MACRO("CLONG_DOUBLE", Datatype::CLONG_DOUBLE, std::complex<long         \
-     * double>) */                                                             \
-    MACRO("STRING", Datatype::STRING, std::string)                             \
-    MACRO("VEC_CHAR", Datatype::VEC_CHAR, std::vector<char>)                   \
-    MACRO("VEC_UCHAR", Datatype::VEC_UCHAR, std::vector<unsigned char>)        \
-    MACRO("VEC_SHORT", Datatype::VEC_SHORT, std::vector<short>)                \
-    MACRO("VEC_INT", Datatype::VEC_INT, std::vector<int>)                      \
-    MACRO("VEC_LONG", Datatype::VEC_LONG, std::vector<long>)                   \
-    MACRO("VEC_LONGLONG", Datatype::VEC_LONGLONG, std::vector<long long>)      \
-    MACRO("VEC_USHORT", Datatype::VEC_USHORT, std::vector<unsigned short>)     \
-    MACRO("VEC_UINT", Datatype::VEC_UINT, std::vector<unsigned int>)           \
-    MACRO("VEC_ULONG", Datatype::VEC_ULONG, std::vector<unsigned long>)        \
-    MACRO(                                                                     \
-        "VEC_ULONGLONG",                                                       \
-        Datatype::VEC_ULONGLONG,                                               \
-        std::vector<unsigned long long>)                                       \
-    MACRO("VEC_FLOAT", Datatype::VEC_FLOAT, std::vector<float>)                \
-    MACRO("VEC_DOUBLE", Datatype::VEC_DOUBLE, std::vector<double>)             \
-    /* MACRO("VEC_LONG_DOUBLE", Datatype::VEC_LONG_DOUBLE, std::vector<long    \
-     * double>) */                                                             \
-    MACRO(                                                                     \
-        "VEC_CFLOAT", Datatype::VEC_CFLOAT, std::vector<std::complex<float>>)  \
-    MACRO(                                                                     \
-        "VEC_CDOUBLE",                                                         \
-        Datatype::VEC_CDOUBLE,                                                 \
-        std::vector<std::complex<double>>)                                     \
-    /* MACRO("VEC_CLONG_DOUBLE", Datatype::VEC_CLONG_DOUBLE,                   \
-     * std::vector<std::complex<long double>>) */                              \
-    MACRO("VEC_STRING", Datatype::VEC_STRING, std::vector<std::string>)        \
-    MACRO("ARR_DBL_7", Datatype::ARR_DBL_7, array_double_7)                    \
-    MACRO("BOOL", Datatype::BOOL, bool)
+namespace detail
+{
+template <typename... Args>
+struct overload_cast_impl
+{
+    template <typename Return>
+    constexpr auto operator()(Return (*pf)(Args...)) const noexcept
+        -> decltype(pf)
+    {
+        return pf;
+    }
 
-#define FORALL_SCALAR_OPENPMD_TYPES(MACRO)                                     \
-    MACRO("CHAR", Datatype::CHAR, char)                                        \
-    MACRO("UCHAR", Datatype::UCHAR, unsigned char)                             \
-    MACRO("SHORT", Datatype::SHORT, short)                                     \
-    MACRO("INT", Datatype::INT, int)                                           \
-    MACRO("LONG", Datatype::LONG, long)                                        \
-    MACRO("LONGLONG", Datatype::LONGLONG, long long)                           \
-    MACRO("USHORT", Datatype::USHORT, unsigned short)                          \
-    MACRO("UINT", Datatype::UINT, unsigned int)                                \
-    MACRO("ULONG", Datatype::ULONG, unsigned long)                             \
-    MACRO("ULONGLONG", Datatype::ULONGLONG, unsigned long long)                \
-    MACRO("FLOAT", Datatype::FLOAT, float)                                     \
-    MACRO("DOUBLE", Datatype::DOUBLE, double)                                  \
-    /* MACRO("LONG_DOUBLE", Datatype::LONG_DOUBLE, long double) */             \
-    MACRO("CFLOAT", Datatype::CFLOAT, std::complex<float>)                     \
-    MACRO("CDOUBLE", Datatype::CDOUBLE, std::complex<double>)                  \
-    /* MACRO("CLONG_DOUBLE", Datatype::CLONG_DOUBLE, std::complex<long         \
-     * double>) */                                                             \
-    MACRO("STRING", Datatype::STRING, std::string)                             \
-    MACRO("ARR_DBL_7", Datatype::ARR_DBL_7, array_double_7)                    \
-    MACRO("BOOL", Datatype::BOOL, bool)
+    template <typename Return, typename Class>
+    constexpr auto
+    operator()(Return (Class::*pmf)(Args...), non_const_tag = {}) const noexcept
+        -> decltype(pmf)
+    {
+        return pmf;
+    }
 
-// This C++ version is a bit more tedious to use than the macro version above
-template <typename T>
-T typeval()
+    template <typename Return, typename Class>
+    constexpr auto
+    operator()(Return (Class::*pmf)(Args...) const, const_tag) const noexcept
+        -> decltype(pmf)
+    {
+        return pmf;
+    }
+};
+} // namespace detail
+
+template <typename... Args>
+static constexpr ::detail::overload_cast_impl<Args...> overload_cast{};
+constexpr const_tag const const_;
+
+/**
+ * Generalizes the repeated application of a function template for all
+ * scalar openPMD datatypes.
+ *
+ * Will call the function template found at Action::template call<T>(),
+ * instantiating T with every scalar openPMD datatype as found
+ * in the Datatype enum.
+ *
+ * @tparam Action The struct containing the function template.
+ * @tparam Args The function template's argument types.
+ * @param args The function template's arguments.
+ */
+template <typename Action, typename... Args>
+void forallScalarJuliaTypes(Args &&...args)
 {
-    return T{};
+    // Do NOT call std::forward<Args>(args)... here
+    // Move semantics must be avoided due to repeated application
+    Action::template call<char>(args...);
+    Action::template call<unsigned char>(args...);
+    Action::template call<signed char>(args...);
+    Action::template call<short>(args...);
+    Action::template call<int>(args...);
+    Action::template call<long>(args...);
+    Action::template call<long long>(args...);
+    Action::template call<unsigned short>(args...);
+    Action::template call<unsigned int>(args...);
+    Action::template call<unsigned long>(args...);
+    Action::template call<unsigned long long>(args...);
+    Action::template call<float>(args...);
+    Action::template call<double>(args...);
+    // We disable `long double` since Julia does not support this type
+    // Action::template call<long double>(args...);
+    Action::template call<std::complex<float>>(args...);
+    Action::template call<std::complex<double>>(args...);
+    // Action::template call<std::complex<long double>>(args...);
+    Action::template call<std::string>(args...);
+    Action::template call<bool>(args...);
 }
-template <typename F, typename... Args>
-void forall_openPMD_types(const F &f, Args &&...args)
+/**
+ * Generalizes the repeated application of a function template for all
+ * openPMD datatypes.
+ *
+ * Will call the function template found at Action::template call<T>(),
+ * instantiating T with every scalar datatype as found in the Datatype enum.
+ *
+ * @tparam Action The struct containing the function template.
+ * @tparam Args The function template's argument types.
+ * @param args The function template's arguments.
+ */
+template <typename Action, typename... Args>
+void forallJuliaTypes(Args &&...args)
 {
-    f("CHAR", Datatype::CHAR, typeval<char>(), std::forward<Args>(args)...);
-    f("UCHAR",
-      Datatype::UCHAR,
-      typeval<unsigned char>(),
-      std::forward<Args>(args)...);
-    f("SHORT", Datatype::SHORT, typeval<short>(), std::forward<Args>(args)...);
-    f("INT", Datatype::INT, typeval<int>(), std::forward<Args>(args)...);
-    f("LONG", Datatype::LONG, typeval<long>(), std::forward<Args>(args)...);
-    f("LONGLONG",
-      Datatype::LONGLONG,
-      typeval<long long>(),
-      std::forward<Args>(args)...);
-    f("USHORT",
-      Datatype::USHORT,
-      typeval<unsigned short>(),
-      std::forward<Args>(args)...);
-    f("UINT",
-      Datatype::UINT,
-      typeval<unsigned int>(),
-      std::forward<Args>(args)...);
-    f("ULONG",
-      Datatype::ULONG,
-      typeval<unsigned long>(),
-      std::forward<Args>(args)...);
-    f("ULONGLONG",
-      Datatype::ULONGLONG,
-      typeval<unsigned long long>(),
-      std::forward<Args>(args)...);
-    f("FLOAT", Datatype::FLOAT, typeval<float>(), std::forward<Args>(args)...);
-    f("DOUBLE",
-      Datatype::DOUBLE,
-      typeval<double>(),
-      std::forward<Args>(args)...);
-    // f("LONG_DOUBLE", Datatype::LONG_DOUBLE, typeval<long double>(),
-    // std::forward<Args>(args)...);
-    f("CFLOAT",
-      Datatype::CFLOAT,
-      typeval<std::complex<float>>(),
-      std::forward<Args>(args)...);
-    f("CDOUBLE",
-      Datatype::CDOUBLE,
-      typeval<std::complex<double>>(),
-      std::forward<Args>(args)...);
-    // f("CLONG_DOUBLE", Datatype::CLONG_DOUBLE, typeval<std::complex<long
-    // double>>(), std::forward<Args>(args)...);
-    f("STRING",
-      Datatype::STRING,
-      typeval<std::string>(),
-      std::forward<Args>(args)...);
-    f("VEC_CHAR",
-      Datatype::VEC_CHAR,
-      typeval<std::vector<char>>(),
-      std::forward<Args>(args)...);
-    f("VEC_UCHAR",
-      Datatype::VEC_UCHAR,
-      typeval<std::vector<unsigned char>>(),
-      std::forward<Args>(args)...);
-    f("VEC_SHORT",
-      Datatype::VEC_SHORT,
-      typeval<std::vector<short>>(),
-      std::forward<Args>(args)...);
-    f("VEC_INT",
-      Datatype::VEC_INT,
-      typeval<std::vector<int>>(),
-      std::forward<Args>(args)...);
-    f("VEC_LONG",
-      Datatype::VEC_LONG,
-      typeval<std::vector<long>>(),
-      std::forward<Args>(args)...);
-    f("VEC_LONGLONG",
-      Datatype::VEC_LONGLONG,
-      typeval<std::vector<long long>>(),
-      std::forward<Args>(args)...);
-    f("VEC_USHORT",
-      Datatype::VEC_USHORT,
-      typeval<std::vector<unsigned short>>(),
-      std::forward<Args>(args)...);
-    f("VEC_UINT",
-      Datatype::VEC_UINT,
-      typeval<std::vector<unsigned int>>(),
-      std::forward<Args>(args)...);
-    f("VEC_ULONG",
-      Datatype::VEC_ULONG,
-      typeval<std::vector<unsigned long>>(),
-      std::forward<Args>(args)...);
-    f("VEC_ULONGLONG",
-      Datatype::VEC_ULONGLONG,
-      typeval<std::vector<unsigned long long>>(),
-      std::forward<Args>(args)...);
-    f("VEC_FLOAT",
-      Datatype::VEC_FLOAT,
-      typeval<std::vector<float>>(),
-      std::forward<Args>(args)...);
-    f("VEC_DOUBLE",
-      Datatype::VEC_DOUBLE,
-      typeval<std::vector<double>>(),
-      std::forward<Args>(args)...);
-    // f("VEC_LONG_DOUBLE", Datatype::VEC_LONG_DOUBLE, typeval<std::vector<long
-    // double>>(), std::forward<Args>(args)...);
-    f("VEC_CFLOAT",
-      Datatype::VEC_CFLOAT,
-      typeval<std::vector<std::complex<float>>>(),
-      std::forward<Args>(args)...);
-    f("VEC_CDOUBLE",
-      Datatype::VEC_CDOUBLE,
-      typeval<std::vector<std::complex<double>>>(),
-      std::forward<Args>(args)...);
-    // f("VEC_CLONG_DOUBLE", Datatype::VEC_CLONG_DOUBLE,
-    // typeval<std::vector<std::complex<long double>>>(),
-    // std::forward<Args>(args)...);
-    f("VEC_STRING",
-      Datatype::VEC_STRING,
-      typeval<std::vector<std::string>>(),
-      std::forward<Args>(args)...);
-    f("ARR_DBL_7",
-      Datatype::ARR_DBL_7,
-      typeval<array_double_7>(),
-      std::forward<Args>(args)...);
-    f("BOOL", Datatype::BOOL, typeval<bool>(), std::forward<Args>(args)...);
+    // Do NOT call std::forward<Args>(args)... here
+    // Move semantics must be avoided due to repeated application
+    Action::template call<char>(args...);
+    Action::template call<unsigned char>(args...);
+    Action::template call<signed char>(args...);
+    Action::template call<short>(args...);
+    Action::template call<int>(args...);
+    Action::template call<long>(args...);
+    Action::template call<long long>(args...);
+    Action::template call<unsigned short>(args...);
+    Action::template call<unsigned int>(args...);
+    Action::template call<unsigned long>(args...);
+    Action::template call<unsigned long long>(args...);
+    Action::template call<float>(args...);
+    Action::template call<double>(args...);
+    // We disable `long double` since Julia does not support this type
+    // Action::template call<long double>(args...);
+    Action::template call<std::complex<float>>(args...);
+    Action::template call<std::complex<double>>(args...);
+    // Action::template call<std::complex<long double>>(args...);
+    Action::template call<std::string>(args...);
+    Action::template call<std::vector<char>>(args...);
+    Action::template call<std::vector<short>>(args...);
+    Action::template call<std::vector<int>>(args...);
+    Action::template call<std::vector<long>>(args...);
+    Action::template call<std::vector<long long>>(args...);
+    Action::template call<std::vector<unsigned char>>(args...);
+    Action::template call<std::vector<signed char>>(args...);
+    Action::template call<std::vector<unsigned short>>(args...);
+    Action::template call<std::vector<unsigned int>>(args...);
+    Action::template call<std::vector<unsigned long>>(args...);
+    Action::template call<std::vector<unsigned long long>>(args...);
+    Action::template call<std::vector<float>>(args...);
+    Action::template call<std::vector<double>>(args...);
+    // Action::template call<std::vector<long double>>(args...);
+    Action::template call<std::vector<std::complex<float>>>(args...);
+    Action::template call<std::vector<std::complex<double>>>(args...);
+    // Action::template call<std::vector<std::complex<long double>>>(args...);
+    Action::template call<std::vector<std::string>>(args...);
+    Action::template call<std::array<double, 7>>(args...);
+    Action::template call<bool>(args...);
 }
 
 namespace
diff --git a/src/binding/julia/shared_ptr.cpp b/src/binding/julia/shared_ptr.cpp
index 69c8808fbc..d0fffd69f9 100644
--- a/src/binding/julia/shared_ptr.cpp
+++ b/src/binding/julia/shared_ptr.cpp
@@ -5,15 +5,25 @@
  */
 
 #include "defs.hpp"
+#include "openPMD/Datatype.hpp"
+#include <jlcxx/module.hpp>
 
-void define_julia_shared_ptr(jlcxx::Module &mod)
+namespace
+{
+struct UseType
 {
-#define USE_TYPE(NAME, ENUM, TYPE)                                             \
-    mod.method(                                                                \
-        "create_aliasing_shared_ptr_" NAME,                                    \
-        &create_aliasing_shared_ptr<TYPE>);
+    template <typename T>
+    static void call(jlcxx::Module &mod)
     {
-        FORALL_SCALAR_OPENPMD_TYPES(USE_TYPE)
+        mod.method(
+            "create_aliasing_shared_ptr_" +
+                datatypeToString(determineDatatype<T>()),
+            &create_aliasing_shared_ptr<T>);
     }
-#undef USE_TYPE
+};
+} // namespace
+
+void define_julia_shared_ptr(jlcxx::Module &mod)
+{
+    forallScalarJuliaTypes<UseType>(mod);
 }