diff --git a/include/kfr/cometa/array.hpp b/include/kfr/cometa/array.hpp
index 6a294946..508c627f 100644
--- a/include/kfr/cometa/array.hpp
+++ b/include/kfr/cometa/array.hpp
@@ -11,6 +11,9 @@
 namespace cometa
 {
 
+template <typename Container>
+using container_value_type = std::remove_pointer_t<decltype(std::data(std::declval<Container>()))>;
+
 /// @brief Reference to array
 template <typename T>
 struct array_ref
@@ -29,46 +32,17 @@ struct array_ref
     using difference_type        = std::ptrdiff_t;
 
     constexpr array_ref() CMT_NOEXCEPT : m_data(nullptr), m_size(0) {}
-    constexpr array_ref(const array_ref&) CMT_NOEXCEPT = default;
-    constexpr array_ref(array_ref&&) CMT_NOEXCEPT      = default;
-#ifdef CMT_COMPILER_GNU
+    constexpr array_ref(const array_ref&) CMT_NOEXCEPT            = default;
+    constexpr array_ref(array_ref&&) CMT_NOEXCEPT                 = default;
     constexpr array_ref& operator=(const array_ref&) CMT_NOEXCEPT = default;
     constexpr array_ref& operator=(array_ref&&) CMT_NOEXCEPT      = default;
-#else
-    array_ref& operator=(const array_ref&) = default;
-    array_ref& operator=(array_ref&&)      = default;
-#endif
 
-    template <size_t N>
-    constexpr array_ref(value_type (&arr)[N]) CMT_NOEXCEPT : m_data(arr), m_size(N)
-    {
-    }
-    template <size_t N>
-    constexpr array_ref(const std::array<T, N>& arr) CMT_NOEXCEPT : m_data(arr.data()), m_size(N)
-    {
-    }
-    template <size_t N>
-    constexpr array_ref(std::array<T, N>& arr) CMT_NOEXCEPT : m_data(arr.data()), m_size(N)
-    {
-    }
-    template <typename Alloc>
-    constexpr array_ref(const std::vector<T, Alloc>& vec) CMT_NOEXCEPT : m_data(vec.data()),
-                                                                         m_size(vec.size())
+    template <typename Container, CMT_HAS_DATA_SIZE(Container)>
+    array_ref(Container&& cont) : array_ref(std::data(cont), std::size(cont))
     {
     }
 
-    template <typename Container, CMT_ENABLE_IF(has_data_size<Container>)>
-    array_ref(Container& cont) : array_ref(cont.data(), cont.size())
-    {
-    }
-
-    constexpr array_ref(const std::initializer_list<T>& vec) CMT_NOEXCEPT : m_data(vec.begin()),
-                                                                            m_size(vec.size())
-    {
-    }
-    template <typename InputIter>
-    constexpr array_ref(InputIter first, InputIter last) CMT_NOEXCEPT : m_data(std::addressof(*first)),
-                                                                        m_size(std::distance(first, last))
+    constexpr array_ref(std::initializer_list<T> vec) CMT_NOEXCEPT : m_data(vec.begin()), m_size(vec.size())
     {
     }
     constexpr array_ref(T* data, size_type size) CMT_NOEXCEPT : m_data(data), m_size(size) {}
@@ -89,98 +63,15 @@ struct array_ref
     size_type m_size;
 };
 
-template <typename T, std::size_t size>
-inline array_ref<T> make_array_ref(T (&data)[size])
-{
-    return array_ref<T>(data);
-}
-
 template <typename T>
 inline array_ref<T> make_array_ref(T* data, std::size_t size)
 {
-    return array_ref<T>(data, data + size);
+    return array_ref<T>(data, size);
 }
 
-template <typename Container, CMT_ENABLE_IF(has_data_size<Container>),
-          typename T = std::remove_pointer_t<decltype(std::declval<Container>().data())>>
-inline array_ref<T> make_array_ref(Container& cont)
-{
-    return array_ref<T>(cont.data(), cont.size());
-}
-
-template <typename Container, CMT_ENABLE_IF(has_data_size<Container>),
-          typename T = std::remove_pointer_t<decltype(std::declval<Container>().data())>>
-inline array_ref<const T> make_array_ref(const Container& cont)
-{
-    return array_ref<const T>(cont.data(), cont.size());
-}
-
-template <typename T>
-inline array_ref<T> make_array_ref(std::vector<T>& cont)
-{
-    return array_ref<T>(cont.data(), cont.size());
-}
-template <typename T>
-inline array_ref<const T> make_array_ref(const std::vector<T>& cont)
-{
-    return array_ref<const T>(cont.data(), cont.size());
-}
-
-template <typename C>
-constexpr auto elementtype(C& c)
-{
-    return c[0];
-}
-template <typename C>
-constexpr auto elementtype(const C& c)
-{
-    return c[0];
-}
-template <typename E>
-constexpr E elementtype(const std::initializer_list<E>&)
-{
-    return {};
-}
-template <typename T, std::size_t N>
-constexpr T elementtype(T (&)[N])
-{
-    return {};
-}
-
-template <typename C>
-constexpr auto data(C& c) -> decltype(c.data())
-{
-    return c.data();
-}
-template <typename C>
-constexpr auto data(const C& c) -> decltype(c.data())
-{
-    return c.data();
-}
-template <typename T, std::size_t N>
-constexpr T* data(T (&array)[N]) CMT_NOEXCEPT
-{
-    return array;
-}
-template <typename T>
-constexpr T* data(T* array) CMT_NOEXCEPT
-{
-    return array;
-}
-template <typename E>
-constexpr const E* data(const std::initializer_list<E>& il) CMT_NOEXCEPT
-{
-    return il.begin();
-}
-
-template <typename C>
-constexpr auto size(const C& c) -> decltype(c.size())
-{
-    return c.size();
-}
-template <typename T, std::size_t N>
-constexpr std::size_t size(const T (&)[N]) CMT_NOEXCEPT
+template <typename Container, CMT_HAS_DATA_SIZE(Container), typename T = container_value_type<Container>>
+inline array_ref<T> make_array_ref(Container&& cont)
 {
-    return N;
+    return array_ref<T>(std::data(cont), std::size(cont));
 }
 } // namespace cometa