diff --git a/include/siplasplas/reflection/static/enum.hpp b/include/siplasplas/reflection/static/enum.hpp
index 7e53a50..906586e 100644
--- a/include/siplasplas/reflection/static/enum.hpp
+++ b/include/siplasplas/reflection/static/enum.hpp
@@ -71,7 +71,7 @@ class Enum
     /**
      * \brief Array type returned by values()
      */
-    using values_array_t = const EnumType[sizeof...(Constants)];
+    using values_array_t = cpp::ConstArrayView<EnumType>;
 
     constexpr Enum() = default;
 
@@ -96,10 +96,10 @@ class Enum
 
     /**
      * \brief Returns the set of enum constants values
-     * \returns A const reference to a constexpr C array with the EnumType
+     * \returns A const array view to the enum constants values array
      * values
      */
-    static constexpr const values_array_t& values()
+    static constexpr values_array_t values()
     {
         return ::cpp::meta::PackToArray<EnumType, Constants...>::get();
     }
diff --git a/include/siplasplas/typeerasure/features/valuesemantics.hpp b/include/siplasplas/typeerasure/features/valuesemantics.hpp
index 983ae66..e6ee6ae 100644
--- a/include/siplasplas/typeerasure/features/valuesemantics.hpp
+++ b/include/siplasplas/typeerasure/features/valuesemantics.hpp
@@ -100,40 +100,63 @@ class Constructible
 class CopyConstructible
 {
 public:
-    template<typename T>
-    static T apply(const T& value) noexcept(concepts::CopyConstructible<T>::no_except)
+    template<typename T, bool CopyConstructible = concepts::CopyConstructible<T>::value>
+    struct Apply
     {
-        return cpp::staticIf<concepts::CopyConstructible<T>::value>([&value](auto identity)
+        static T apply(const T& value) noexcept(concepts::CopyConstructible<T>::no_except)
         {
-            return meta::type_t<decltype(identity.template type<T>())>(value);
-        }).Else([](auto) -> T
+            return T{value};
+        }
+
+        static void apply(T* where, const T& value) noexcept(concepts::CopyConstructible<T>::no_except)
+        {
+            return cpp::construct<T>(where, value);
+        }
+
+        static void apply(void* where, const void* other) noexcept(concepts::CopyConstructible<T>::no_except)
+        {
+            return cpp::construct<T>(where, *reinterpret_cast<const T*>(other));
+        }
+    };
+
+    template<typename T>
+    struct Apply<T, false>
+    {
+        static T apply(const T& ealue) noexcept(false)
         {
             throw cpp::exception<std::runtime_error>(
                 "Type '{}' is not copy constructible",
                 ctti::type_id<T>().name()
             );
-        });
+        }
+
+        static void apply(T* where, const T& value) noexcept(false)
+        {
+            apply(value);
+        }
+
+        static void apply(void* where, const void* other) noexcept(false)
+        {
+            apply(reinterpret_cast<T*>(where), *reinterpret_cast<const T*>(other));
+        }
+    };
+
+    template<typename T>
+    static T apply(const T& value) noexcept(concepts::CopyConstructible<T>::no_except)
+    {
+        return Apply<T>::apply(value);
     }
 
     template<typename T>
     static void apply(T* where, const T& value) noexcept(concepts::CopyConstructible<T>::no_except)
     {
-        cpp::staticIf<concepts::CopyConstructible<T>::value>([where, &value](auto identity)
-        {
-            cpp::construct<meta::type_t<decltype(identity.template type<T>())>>(where, value);
-        }).Else([](auto) -> T
-        {
-            throw cpp::exception<std::runtime_error>(
-                "Type '{}' is not copy constructible",
-                ctti::type_id<T>().name()
-            );
-        });
+        Apply<T>::apply(where, value);
     }
 
     template<typename T>
     static void apply(void* where, const void* other) noexcept(concepts::CopyConstructible<T>::no_except)
     {
-        apply<T>(reinterpret_cast<T*>(where), *reinterpret_cast<const T*>(other));
+        Apply<T>::apply(where, other);
     }
 };
 
diff --git a/include/siplasplas/typeerasure/typeinfo.hpp b/include/siplasplas/typeerasure/typeinfo.hpp
index f26c184..c7e4824 100644
--- a/include/siplasplas/typeerasure/typeinfo.hpp
+++ b/include/siplasplas/typeerasure/typeinfo.hpp
@@ -127,7 +127,7 @@ class TypeInfo : public cpp::TypeInfo
      */
     bool isPointer() const
     {
-        return _isPointer;
+        return cpp::TypeInfo::isPointer();
     }
 
     /**
@@ -214,6 +214,16 @@ class TypeInfo : public cpp::TypeInfo
         }
     }
 
+    /**
+     * \brief Returns the type information of the function arguments.
+     *
+     * The behavior is undefined if the type is not a function type
+     */
+    constexpr cpp::ConstArrayView<TypeInfo> arguments() const
+    {
+        return _functionArgs;
+    }
+
     /**
      * \brief Returns the type information of type T
      */
@@ -223,6 +233,15 @@ class TypeInfo : public cpp::TypeInfo
         return TypeInfo{meta::identity<T>()};
     }
 
+    /**
+     * \brief Returns the type information of type T
+     */
+    template<typename T>
+    static constexpr TypeInfo get(const T&)
+    {
+        return TypeInfo::get<T>();
+    }
+
     friend constexpr bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
     {
         return lhs._semantics == rhs._semantics;
@@ -234,20 +253,32 @@ class TypeInfo : public cpp::TypeInfo
     }
 
 private:
+    struct TypeToTypeInfo
+    {
+        using value_type = TypeInfo;
+
+        template<typename T>
+        static constexpr TypeInfo get()
+        {
+            return TypeInfo::get<T>();
+        }
+    };
+
     template<typename T>
     constexpr TypeInfo(meta::identity<T>) :
         cpp::TypeInfo{cpp::TypeInfo::get<T>()},
-        _semantics{detail::valueSemanticsOperation<T>},
-        _isPointer{
-            std::is_pointer<T>::value &&
-            cpp::function_kind<T>() != cpp::FunctionKind::FREE_FUNCTION
+        _semantics{detail::valueSemanticsOperation<std::decay_t<T>>},
+        _functionArgs{
+            cpp::meta::SequenceToArray<
+                cpp::function_arguments<T>,
+                TypeToTypeInfo
+            >::get()
         }
-    {
-        static_assert(alignof(T) < (1 << 16), "Alignment of T cannot be tagged in a pointer, its value overflows a 16 bit unsigned integer");
-    }
+    {}
 
     detail::ValueSemantics _semantics;
-    bool _isPointer;
+    cpp::ConstArrayView<TypeInfo> _functionArgs;
+
 };
 
 }
diff --git a/include/siplasplas/utility/function_traits.hpp b/include/siplasplas/utility/function_traits.hpp
index 43c5f06..50db0b9 100644
--- a/include/siplasplas/utility/function_traits.hpp
+++ b/include/siplasplas/utility/function_traits.hpp
@@ -38,6 +38,7 @@ namespace detail
     template<typename Function>
     struct get_function_signature
     {
+        using args = meta::list<>;
         static constexpr FunctionKind kind = FunctionKind::INVALID;
     };
 
diff --git a/include/siplasplas/utility/meta.hpp b/include/siplasplas/utility/meta.hpp
index aa60880..2c2ef6b 100644
--- a/include/siplasplas/utility/meta.hpp
+++ b/include/siplasplas/utility/meta.hpp
@@ -1,6 +1,7 @@
 #ifndef SIPLASPLAS_UTILITY_META_H
 #define SIPLASPLAS_UTILITY_META_H
 
+#include "array_view.hpp"
 #include <type_traits>
 #include <cstdint>
 
@@ -170,55 +171,204 @@ namespace meta
     template<char... Chars>
     using string = list<std::integral_constant<char, Chars>...>;
 
-    template<typename Sequence>
+    struct DummyValueToType {};
+
+    template<typename Seq, typename TypeToValue>
     class SequenceToArray;
 
-    template<template<typename...> class Seq, typename T, T... Values>
-    class SequenceToArray<Seq<std::integral_constant<T, Values>...>>
+
+    template<template<typename...> class Seq, typename Head, typename... Tail, typename TypeToValue>
+    class SequenceToArray<Seq<Head, Tail...>, TypeToValue>
     {
     public:
-        using array_t = const T[sizeof...(Values)];
+        using value_type = typename TypeToValue::value_type;
+
+        constexpr SequenceToArray() = default;
 
-        static constexpr const array_t& get()
+        static constexpr const value_type& get(std::size_t i)
         {
-            return array;
+            return array[i];
         }
 
-        static constexpr const T get(std::size_t i)
+        static constexpr ConstArrayView<value_type> get()
         {
-            return array[i];
+            return {Bounds::begin(), Bounds::size()};
+        }
+
+        struct Bounds
+        {
+            static constexpr std::size_t size()
+            {
+                return sizeof...(Tail) + 1;
+            }
+
+            static constexpr const value_type* begin()
+            {
+                return array;
+            }
+
+            static constexpr const value_type* end()
+            {
+                return array + size();
+            }
+
+            static constexpr const value_type* const cbegin()
+            {
+                return array;
+            }
+
+            static constexpr const value_type* const cend()
+            {
+                return array + size();
+            }
+        };
+
+        constexpr std::size_t size() const
+        {
+            return Bounds::size();
         }
 
-        static constexpr std::size_t size()
+        constexpr const value_type& operator[](std::size_t i) const
         {
-            return sizeof...(Values);
+            return get(i);
+        }
+
+        constexpr const value_type* begin() const
+        {
+            return Bounds::begin();
+        }
+
+        constexpr const value_type* end() const
+        {
+            return Bounds::end();
+        }
+
+        constexpr const value_type* const cbegin() const
+        {
+            return Bounds::cbegin();
+        }
+
+        constexpr const value_type* const cend() const
+        {
+            return Bounds::cend();
         }
 
     private:
-        static constexpr const T array[sizeof...(Values)] = {Values...};
+        static constexpr value_type array[] = {
+            TypeToValue::template get<Head>(),
+            TypeToValue::template get<Tail>()...
+        };
     };
 
-    template<typename T, T... Values>
-    using PackToArray = SequenceToArray<list<std::integral_constant<T, Values>...>>;
+    template<template<typename...> class Seq, typename Head, typename... Tail, typename TypeToValue>
+    constexpr typename TypeToValue::value_type SequenceToArray<Seq<Head, Tail...>, TypeToValue>::array[sizeof...(Tail) + 1];
+
+    template<template<typename...> class Seq, typename TypeToValue>
+    class SequenceToArray<Seq<>, TypeToValue>
+    {
+    public:
+        using value_type = typename TypeToValue::value_type;
+
+        constexpr SequenceToArray() = default;
+
+        static constexpr const value_type& get(std::size_t i)
+        {
+            return *static_cast<void*>(nullptr);
+        }
+
+        struct Bounds
+        {
+            static constexpr std::size_t size()
+            {
+                return 0;
+            }
+
+            static constexpr const value_type* begin()
+            {
+                return nullptr;
+            }
+
+            static constexpr const value_type* end()
+            {
+                return nullptr;
+            }
+
+            static constexpr const value_type* const cbegin()
+            {
+                return nullptr;
+            }
+
+            static constexpr const value_type* const cend()
+            {
+                return nullptr;
+            }
+        };
+
+        static constexpr ConstArrayView<value_type> get()
+        {
+            return {static_cast<value_type*>(nullptr), static_cast<std::size_t>(0)};
+        }
 
-    template<template<typename...> class Seq, typename T, T... Values>
-    constexpr const T SequenceToArray<Seq<std::integral_constant<T, Values>...>>::array[sizeof...(Values)];
+        constexpr std::size_t size() const
+        {
+            return Bounds::size();
+        }
+
+        constexpr const value_type& operator[](std::size_t i) const
+        {
+            return get(i);
+        }
+
+        constexpr const value_type* begin() const
+        {
+            return Bounds::begin();
+        }
+
+        constexpr const value_type* end() const
+        {
+            return Bounds::end();
+        }
+
+        constexpr const value_type* const cbegin() const
+        {
+            return Bounds::cbegin();
+        }
+
+        constexpr const value_type* const cend() const
+        {
+            return Bounds::cend();
+        }
+    };
+
+    template<typename T>
+    struct IntegralConstantToValue
+    {
+        using value_type = T;
+
+        template<typename IntegralConstant>
+        static constexpr value_type get()
+        {
+            return IntegralConstant::value;
+        }
+    };
+
+    template<typename T, T... Values>
+    using PackToArray = SequenceToArray<
+        list<std::integral_constant<T, Values>...>,
+        IntegralConstantToValue<T>
+    >;
 
     template<typename String>
     class StringToArray;
 
     template<template<typename...> class Seq, char... Chars>
-    class StringToArray<Seq<std::integral_constant<char, Chars>...>> : public SequenceToArray<Seq<std::integral_constant<char, Chars>..., std::integral_constant<char, '\0'>>>
+    class StringToArray<Seq<std::integral_constant<char, Chars>...>> :
+        public PackToArray<char, Chars..., '\0'>
     {
     public:
         static constexpr const char* c_str()
         {
-            return SequenceToArray<Seq<std::integral_constant<char, Chars>..., std::integral_constant<char, '\0'>>>::get();
-        }
-
-        static constexpr std::size_t length()
-        {
-            return sizeof...(Chars);
+            return PackToArray<char, Chars..., '\0'>::Bounds::begin();
         }
     };
 
diff --git a/test/typeerasure/typeinfo_test.cpp b/test/typeerasure/typeinfo_test.cpp
index 547e8f3..58b85d6 100644
--- a/test/typeerasure/typeinfo_test.cpp
+++ b/test/typeerasure/typeinfo_test.cpp
@@ -4,6 +4,11 @@
 using namespace ::testing;
 using namespace ::cpp::typeerasure;
 
+static_assert(
+    TypeInfo::get<void(*)(int, const std::string&)>().arguments()[1] == TypeInfo::get<const std::string&>(),
+    "Second param of void(int, const std::string&) is const std::string&"
+);
+
 TEST(TypeInfoTest, equalityOperator_sameTypesEqual)
 {
     EXPECT_EQ(TypeInfo::get<int>(), TypeInfo::get<int>());